6abbe231e5
* middleware/cache: cache 0 will be capped at 5 cache 0 would return TTL=0 records, up that to the documented minimum of 5 seconds. * middleware/cache: check for 0 TTL Handle 0 TTL differently and return an error, we might need to special case this in the future.
137 lines
3.1 KiB
Go
137 lines
3.1 KiB
Go
package cache
|
|
|
|
import (
|
|
"fmt"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/miekg/coredns/core/dnsserver"
|
|
"github.com/miekg/coredns/middleware"
|
|
|
|
"github.com/hashicorp/golang-lru"
|
|
"github.com/mholt/caddy"
|
|
)
|
|
|
|
func init() {
|
|
caddy.RegisterPlugin("cache", caddy.Plugin{
|
|
ServerType: "dns",
|
|
Action: setup,
|
|
})
|
|
}
|
|
|
|
func setup(c *caddy.Controller) error {
|
|
ca, err := cacheParse(c)
|
|
if err != nil {
|
|
return middleware.Error("cache", err)
|
|
}
|
|
dnsserver.GetConfig(c).AddMiddleware(func(next middleware.Handler) middleware.Handler {
|
|
ca.Next = next
|
|
return ca
|
|
})
|
|
|
|
// Export the capacity for the metrics. This only happens once, because this is a re-load change only.
|
|
cacheCapacity.WithLabelValues(Success).Set(float64(ca.pcap))
|
|
cacheCapacity.WithLabelValues(Denial).Set(float64(ca.ncap))
|
|
|
|
return nil
|
|
}
|
|
|
|
func cacheParse(c *caddy.Controller) (*Cache, error) {
|
|
|
|
ca := &Cache{pcap: defaultCap, ncap: defaultCap, pttl: maxTTL, nttl: maxNTTL}
|
|
|
|
for c.Next() {
|
|
// cache [ttl] [zones..]
|
|
origins := make([]string, len(c.ServerBlockKeys))
|
|
copy(origins, c.ServerBlockKeys)
|
|
args := c.RemainingArgs()
|
|
|
|
if len(args) > 0 {
|
|
// first args may be just a number, then it is the ttl, if not it is a zone
|
|
ttl, err := strconv.Atoi(args[0])
|
|
if err == nil {
|
|
// Reserve 0 (and smaller for future things)
|
|
if ttl <= 0 {
|
|
return nil, fmt.Errorf("cache TTL can not be zero or negative: %d", ttl)
|
|
}
|
|
ca.pttl = time.Duration(ttl) * time.Second
|
|
ca.nttl = time.Duration(ttl) * time.Second
|
|
args = args[1:]
|
|
}
|
|
if len(args) > 0 {
|
|
copy(origins, args)
|
|
}
|
|
}
|
|
|
|
// Refinements? In an extra block.
|
|
for c.NextBlock() {
|
|
switch c.Val() {
|
|
// first number is cap, second is an new ttl
|
|
case Success:
|
|
args := c.RemainingArgs()
|
|
if len(args) == 0 {
|
|
return nil, c.ArgErr()
|
|
}
|
|
pcap, err := strconv.Atoi(args[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
ca.pcap = pcap
|
|
if len(args) > 1 {
|
|
pttl, err := strconv.Atoi(args[1])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
// Reserve 0 (and smaller for future things)
|
|
if pttl <= 0 {
|
|
return nil, fmt.Errorf("cache TTL can not be zero or negative: %d", pttl)
|
|
}
|
|
ca.pttl = time.Duration(pttl) * time.Second
|
|
}
|
|
case Denial:
|
|
args := c.RemainingArgs()
|
|
if len(args) == 0 {
|
|
return nil, c.ArgErr()
|
|
}
|
|
ncap, err := strconv.Atoi(args[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
ca.ncap = ncap
|
|
if len(args) > 1 {
|
|
nttl, err := strconv.Atoi(args[1])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
// Reserve 0 (and smaller for future things)
|
|
if nttl <= 0 {
|
|
return nil, fmt.Errorf("cache TTL can not be zero or negative: %d", nttl)
|
|
}
|
|
ca.nttl = time.Duration(nttl) * time.Second
|
|
}
|
|
default:
|
|
return nil, c.ArgErr()
|
|
}
|
|
}
|
|
|
|
for i := range origins {
|
|
origins[i] = middleware.Host(origins[i]).Normalize()
|
|
}
|
|
|
|
var err error
|
|
ca.Zones = origins
|
|
|
|
ca.pcache, err = lru.New(ca.pcap)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
ca.ncache, err = lru.New(ca.ncap)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return ca, nil
|
|
}
|
|
|
|
return nil, nil
|
|
}
|