Remove some non-essential plugins from this repo (#2780)

Brotli encoder, jsonc and json5 config adapters, and the unfinished
HTTP cache handler are removed.

They will be available in separate repos.

7 files changed, 11 insertions, 353 deletions

diff --git a/modules/caddyhttp/encode/brotli/brotli.go b/modules/caddyhttp/encode/brotli/brotli.go
deleted file mode 100644
index fababd3..0000000
--- a/modules/caddyhttp/encode/brotli/brotli.go
+++ /dev/null
@@ -1,95 +0,0 @@
-// Copyright 2015 Matthew Holt and The Caddy Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package caddybrotli
-
-import (
-	"fmt"
-	"strconv"
-
-	"github.com/andybalholm/brotli"
-	"github.com/caddyserver/caddy/v2"
-	"github.com/caddyserver/caddy/v2/caddyconfig/caddyfile"
-	"github.com/caddyserver/caddy/v2/modules/caddyhttp/encode"
-)
-
-func init() {
-	caddy.RegisterModule(Brotli{})
-}
-
-// Brotli can create brotli encoders. Note that brotli
-// is not known for great encoding performance, and
-// its use during requests is discouraged; instead,
-// pre-compress the content instead.
-type Brotli struct {
-	Quality *int `json:"quality,omitempty"`
-}
-
-// CaddyModule returns the Caddy module information.
-func (Brotli) CaddyModule() caddy.ModuleInfo {
-	return caddy.ModuleInfo{
-		ID:  "http.encoders.brotli",
-		New: func() caddy.Module { return new(Brotli) },
-	}
-}
-
-// UnmarshalCaddyfile sets up the handler from Caddyfile tokens.
-func (b *Brotli) UnmarshalCaddyfile(d *caddyfile.Dispenser) error {
-	for d.Next() {
-		if !d.NextArg() {
-			continue
-		}
-		qualityStr := d.Val()
-		quality, err := strconv.Atoi(qualityStr)
-		if err != nil {
-			return err
-		}
-		b.Quality = &quality
-	}
-	return nil
-}
-
-// Validate validates b's configuration.
-func (b Brotli) Validate() error {
-	if b.Quality != nil {
-		quality := *b.Quality
-		if quality < brotli.BestSpeed {
-			return fmt.Errorf("quality too low; must be >= %d", brotli.BestSpeed)
-		}
-		if quality > brotli.BestCompression {
-			return fmt.Errorf("quality too high; must be <= %d", brotli.BestCompression)
-		}
-	}
-	return nil
-}
-
-// AcceptEncoding returns the name of the encoding as
-// used in the Accept-Encoding request headers.
-func (Brotli) AcceptEncoding() string { return "br" }
-
-// NewEncoder returns a new brotli writer.
-func (b Brotli) NewEncoder() encode.Encoder {
-	quality := brotli.DefaultCompression
-	if b.Quality != nil {
-		quality = *b.Quality
-	}
-	return brotli.NewWriterLevel(nil, quality)
-}
-
-// Interface guards
-var (
-	_ encode.Encoding       = (*Brotli)(nil)
-	_ caddy.Validator       = (*Brotli)(nil)
-	_ caddyfile.Unmarshaler = (*Brotli)(nil)
-)
diff --git a/modules/caddyhttp/encode/caddyfile.go b/modules/caddyhttp/encode/caddyfile.go
index 629f0e2..9d9646c 100644
--- a/modules/caddyhttp/encode/caddyfile.go
+++ b/modules/caddyhttp/encode/caddyfile.go
@@ -42,7 +42,6 @@ func parseCaddyfile(h httpcaddyfile.Helper) (caddyhttp.MiddlewareHandler, error)
 //     encode [<matcher>] <formats...> {
 //         gzip [<level>]
 //         zstd
-//         brotli [<quality>]
 //     }
 //
 // Specifying the formats on the first line will use those formats' defaults.
diff --git a/modules/caddyhttp/httpcache/httpcache.go b/modules/caddyhttp/httpcache/httpcache.go
deleted file mode 100644
index 605a183..0000000
--- a/modules/caddyhttp/httpcache/httpcache.go
+++ /dev/null
@@ -1,242 +0,0 @@
-// Copyright 2015 Matthew Holt and The Caddy Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package httpcache
-
-import (
-	"bytes"
-	"context"
-	"encoding/gob"
-	"fmt"
-	"io"
-	"log"
-	"net/http"
-	"sync"
-
-	"github.com/caddyserver/caddy/v2"
-	"github.com/caddyserver/caddy/v2/modules/caddyhttp"
-	"github.com/golang/groupcache"
-)
-
-func init() {
-	caddy.RegisterModule(Cache{})
-}
-
-// Cache implements a simple distributed cache.
-//
-// NOTE: This module is a work-in-progress. It is
-// not finished and is NOT ready for production use.
-// [We need your help to finish it! Please volunteer
-// in this issue.](https://github.com/caddyserver/caddy/issues/2820)
-// Until it is finished, this module is subject to
-// breaking changes.
-//
-// Caches only GET and HEAD requests. Honors the Cache-Control: no-cache header.
-//
-// Still TODO:
-//
-// - Eviction policies and API
-// - Use single cache per-process
-// - Preserve cache through config reloads
-// - More control over what gets cached
-type Cache struct {
-	// The network address of this cache instance; required.
-	Self string `json:"self,omitempty"`
-
-	// A list of network addresses of cache instances in the group.
-	Peers []string `json:"peers,omitempty"`
-
-	// Maximum size of the cache, in bytes. Default is 512 MB.
-	MaxSize int64 `json:"max_size,omitempty"`
-
-	group *groupcache.Group
-}
-
-// CaddyModule returns the Caddy module information.
-func (Cache) CaddyModule() caddy.ModuleInfo {
-	return caddy.ModuleInfo{
-		ID:  "http.handlers.cache",
-		New: func() caddy.Module { return new(Cache) },
-	}
-}
-
-// Provision provisions c.
-func (c *Cache) Provision(ctx caddy.Context) error {
-	// TODO: use UsagePool so that cache survives config reloads - TODO: a single cache for whole process?
-	maxSize := c.MaxSize
-	if maxSize == 0 {
-		const maxMB = 512
-		maxSize = int64(maxMB << 20)
-	}
-	poolMu.Lock()
-	if pool == nil {
-		pool = groupcache.NewHTTPPool(c.Self)
-		c.group = groupcache.NewGroup(groupName, maxSize, groupcache.GetterFunc(c.getter))
-	} else {
-		c.group = groupcache.GetGroup(groupName)
-	}
-	pool.Set(append(c.Peers, c.Self)...)
-	poolMu.Unlock()
-
-	return nil
-}
-
-// Validate validates c.
-func (c *Cache) Validate() error {
-	if c.Self == "" {
-		return fmt.Errorf("address of this instance (self) is required")
-	}
-	if c.MaxSize < 0 {
-		return fmt.Errorf("size must be greater than 0")
-	}
-	return nil
-}
-
-func (c *Cache) ServeHTTP(w http.ResponseWriter, r *http.Request, next caddyhttp.Handler) error {
-	// TODO: proper RFC implementation of cache control headers...
-	if r.Header.Get("Cache-Control") == "no-cache" || (r.Method != "GET" && r.Method != "HEAD") {
-		return next.ServeHTTP(w, r)
-	}
-
-	getterCtx := getterContext{w, r, next}
-	ctx := context.WithValue(r.Context(), getterContextCtxKey, getterCtx)
-
-	// TODO: rigorous performance testing
-
-	// TODO: pretty much everything else to handle the nuances of HTTP caching...
-
-	// TODO: groupcache has no explicit cache eviction, so we need to embed
-	// all information related to expiring cache entries into the key; right
-	// now we just use the request URI as a proof-of-concept
-	key := r.RequestURI
-
-	var cachedBytes []byte
-	err := c.group.Get(ctx, key, groupcache.AllocatingByteSliceSink(&cachedBytes))
-	if err == errUncacheable {
-		return nil
-	}
-	if err != nil {
-		return err
-	}
-
-	// the cached bytes consists of two parts: first a
-	// gob encoding of the status and header, immediately
-	// followed by the raw bytes of the response body
-	rdr := bytes.NewReader(cachedBytes)
-
-	// read the header and status first
-	var hs headerAndStatus
-	err = gob.NewDecoder(rdr).Decode(&hs)
-	if err != nil {
-		return err
-	}
-
-	// set and write the cached headers
-	for k, v := range hs.Header {
-		w.Header()[k] = v
-	}
-	w.WriteHeader(hs.Status)
-
-	// write the cached response body
-	io.Copy(w, rdr)
-
-	return nil
-}
-
-func (c *Cache) getter(ctx context.Context, key string, dest groupcache.Sink) error {
-	combo := ctx.Value(getterContextCtxKey).(getterContext)
-
-	// the buffer will store the gob-encoded header, then the body
-	buf := bufPool.Get().(*bytes.Buffer)
-	buf.Reset()
-	defer bufPool.Put(buf)
-
-	// we need to record the response if we are to cache it; only cache if
-	// request is successful (TODO: there's probably much more nuance needed here)
-	rr := caddyhttp.NewResponseRecorder(combo.rw, buf, func(status int, header http.Header) bool {
-		shouldBuf := status < 300
-
-		if shouldBuf {
-			// store the header before the body, so we can efficiently
-			// and conveniently use a single buffer for both; gob
-			// decoder will only read up to end of gob message, and
-			// the rest will be the body, which will be written
-			// implicitly for us by the recorder
-			err := gob.NewEncoder(buf).Encode(headerAndStatus{
-				Header: header,
-				Status: status,
-			})
-			if err != nil {
-				log.Printf("[ERROR] Encoding headers for cache entry: %v; not caching this request", err)
-				return false
-			}
-		}
-
-		return shouldBuf
-	})
-
-	// execute next handlers in chain
-	err := combo.next.ServeHTTP(rr, combo.req)
-	if err != nil {
-		return err
-	}
-
-	// if response body was not buffered, response was
-	// already written and we are unable to cache
-	if !rr.Buffered() {
-		return errUncacheable
-	}
-
-	// add to cache
-	dest.SetBytes(buf.Bytes())
-
-	return nil
-}
-
-type headerAndStatus struct {
-	Header http.Header
-	Status int
-}
-
-type getterContext struct {
-	rw   http.ResponseWriter
-	req  *http.Request
-	next caddyhttp.Handler
-}
-
-var bufPool = sync.Pool{
-	New: func() interface{} {
-		return new(bytes.Buffer)
-	},
-}
-
-var (
-	pool   *groupcache.HTTPPool
-	poolMu sync.Mutex
-)
-
-var errUncacheable = fmt.Errorf("uncacheable")
-
-const groupName = "http_requests"
-
-type ctxKey string
-
-const getterContextCtxKey ctxKey = "getter_context"
-
-// Interface guards
-var (
-	_ caddy.Provisioner           = (*Cache)(nil)
-	_ caddy.Validator             = (*Cache)(nil)
-	_ caddyhttp.MiddlewareHandler = (*Cache)(nil)
-)
diff --git a/modules/caddyhttp/requestbody/requestbody.go b/modules/caddyhttp/requestbody/requestbody.go
index dcebd8c..76cd274 100644
--- a/modules/caddyhttp/requestbody/requestbody.go
+++ b/modules/caddyhttp/requestbody/requestbody.go
@@ -34,7 +34,7 @@ type RequestBody struct {
 // CaddyModule returns the Caddy module information.
 func (RequestBody) CaddyModule() caddy.ModuleInfo {
 	return caddy.ModuleInfo{
-		ID:  "http.handlers.request_body", // TODO: better name for this?
+		ID:  "http.handlers.request_body",
 		New: func() caddy.Module { return new(RequestBody) },
 	}
 }
diff --git a/modules/caddyhttp/reverseproxy/circuitbreaker.go b/modules/caddyhttp/reverseproxy/circuitbreaker.go
index 00b38a8..830ab43 100644
--- a/modules/caddyhttp/reverseproxy/circuitbreaker.go
+++ b/modules/caddyhttp/reverseproxy/circuitbreaker.go
@@ -24,12 +24,12 @@ import (
 )
 
 func init() {
-	caddy.RegisterModule(localCircuitBreaker{})
+	caddy.RegisterModule(internalCircuitBreaker{})
 }
 
-// localCircuitBreaker implements circuit breaking functionality
+// internalCircuitBreaker implements circuit breaking functionality
 // for requests within this process over a sliding time window.
-type localCircuitBreaker struct {
+type internalCircuitBreaker struct {
 	tripped   int32
 	cbFactor  int32
 	threshold float64
@@ -39,15 +39,15 @@ type localCircuitBreaker struct {
 }
 
 // CaddyModule returns the Caddy module information.
-func (localCircuitBreaker) CaddyModule() caddy.ModuleInfo {
+func (internalCircuitBreaker) CaddyModule() caddy.ModuleInfo {
 	return caddy.ModuleInfo{
-		ID:  "http.reverse_proxy.circuit_breakers.local",
-		New: func() caddy.Module { return new(localCircuitBreaker) },
+		ID:  "http.reverse_proxy.circuit_breakers.internal",
+		New: func() caddy.Module { return new(internalCircuitBreaker) },
 	}
 }
 
 // Provision sets up a configured circuit breaker.
-func (c *localCircuitBreaker) Provision(ctx caddy.Context) error {
+func (c *internalCircuitBreaker) Provision(ctx caddy.Context) error {
 	f, ok := typeCB[c.Factor]
 	if !ok {
 		return fmt.Errorf("type is not defined")
@@ -77,19 +77,19 @@ func (c *localCircuitBreaker) Provision(ctx caddy.Context) error {
 }
 
 // Ok returns whether the circuit breaker is tripped or not.
-func (c *localCircuitBreaker) Ok() bool {
+func (c *internalCircuitBreaker) Ok() bool {
 	tripped := atomic.LoadInt32(&c.tripped)
 	return tripped == 0
 }
 
 // RecordMetric records a response status code and execution time of a request. This function should be run in a separate goroutine.
-func (c *localCircuitBreaker) RecordMetric(statusCode int, latency time.Duration) {
+func (c *internalCircuitBreaker) RecordMetric(statusCode int, latency time.Duration) {
 	c.metrics.Record(statusCode, latency)
 	c.checkAndSet()
 }
 
 // Ok checks our metrics to see if we should trip our circuit breaker, or if the fallback duration has completed.
-func (c *localCircuitBreaker) checkAndSet() {
+func (c *internalCircuitBreaker) checkAndSet() {
 	var isTripped bool
 
 	switch c.cbFactor {
diff --git a/modules/caddyhttp/standard/imports.go b/modules/caddyhttp/standard/imports.go
index 1effb5a..a0ccf6e 100644
--- a/modules/caddyhttp/standard/imports.go
+++ b/modules/caddyhttp/standard/imports.go
@@ -5,12 +5,10 @@ import (
 	_ "github.com/caddyserver/caddy/v2/modules/caddyhttp"
 	_ "github.com/caddyserver/caddy/v2/modules/caddyhttp/caddyauth"
 	_ "github.com/caddyserver/caddy/v2/modules/caddyhttp/encode"
-	_ "github.com/caddyserver/caddy/v2/modules/caddyhttp/encode/brotli"
 	_ "github.com/caddyserver/caddy/v2/modules/caddyhttp/encode/gzip"
 	_ "github.com/caddyserver/caddy/v2/modules/caddyhttp/encode/zstd"
 	_ "github.com/caddyserver/caddy/v2/modules/caddyhttp/fileserver"
 	_ "github.com/caddyserver/caddy/v2/modules/caddyhttp/headers"
-	_ "github.com/caddyserver/caddy/v2/modules/caddyhttp/httpcache"
 	_ "github.com/caddyserver/caddy/v2/modules/caddyhttp/requestbody"
 	_ "github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy"
 	_ "github.com/caddyserver/caddy/v2/modules/caddyhttp/reverseproxy/fastcgi"
diff --git a/modules/standard/import.go b/modules/standard/import.go
index a88200f..dddf712 100644
--- a/modules/standard/import.go
+++ b/modules/standard/import.go
@@ -3,8 +3,6 @@ package standard
 import (
 	// standard Caddy modules
 	_ "github.com/caddyserver/caddy/v2/caddyconfig/caddyfile"
-	_ "github.com/caddyserver/caddy/v2/caddyconfig/json5"
-	_ "github.com/caddyserver/caddy/v2/caddyconfig/jsonc"
 	_ "github.com/caddyserver/caddy/v2/modules/caddyhttp/standard"
 	_ "github.com/caddyserver/caddy/v2/modules/caddypki"
 	_ "github.com/caddyserver/caddy/v2/modules/caddytls"