1 files changed, 22 insertions, 16 deletions

diff --git a/middleware/cache/cache.go b/middleware/cache/cache.go
index bd29a815c..3bb1b21f9 100644
--- a/middleware/cache/cache.go
+++ b/middleware/cache/cache.go
@@ -20,6 +20,7 @@ type Cache struct {
 	cap   time.Duration
 }
 
+// NewCache returns a new cache.
 func NewCache(ttl int, zones []string, next middleware.Handler) Cache {
 	return Cache{Next: next, Zones: zones, cache: gcache.New(defaultDuration, purgeDuration), cap: time.Duration(ttl) * time.Second}
 }
@@ -46,17 +47,20 @@ func cacheKey(m *dns.Msg, t response.Type, do bool) string {
 	return ""
 }
 
-type CachingResponseWriter struct {
+// ResponseWriter is a response writer that caches the reply message.
+type ResponseWriter struct {
 	dns.ResponseWriter
 	cache *gcache.Cache
 	cap   time.Duration
 }
 
-func NewCachingResponseWriter(w dns.ResponseWriter, cache *gcache.Cache, cap time.Duration) *CachingResponseWriter {
-	return &CachingResponseWriter{w, cache, cap}
+// NewCachingResponseWriter returns a new ResponseWriter.
+func NewCachingResponseWriter(w dns.ResponseWriter, cache *gcache.Cache, cap time.Duration) *ResponseWriter {
+	return &ResponseWriter{w, cache, cap}
 }
 
-func (c *CachingResponseWriter) WriteMsg(res *dns.Msg) error {
+// WriteMsg implements the dns.ResponseWriter interface.
+func (c *ResponseWriter) WriteMsg(res *dns.Msg) error {
 	do := false
 	mt, opt := response.Classify(res)
 	if opt != nil {
@@ -73,7 +77,7 @@ func (c *CachingResponseWriter) WriteMsg(res *dns.Msg) error {
 	return c.ResponseWriter.WriteMsg(res)
 }
 
-func (c *CachingResponseWriter) set(m *dns.Msg, key string, mt response.Type) {
+func (c *ResponseWriter) set(m *dns.Msg, key string, mt response.Type) {
 	if key == "" {
 		log.Printf("[ERROR] Caching called with empty cache key")
 		return
@@ -83,14 +87,14 @@ func (c *CachingResponseWriter) set(m *dns.Msg, key string, mt response.Type) {
 	switch mt {
 	case response.Success, response.Delegation:
 		if c.cap == 0 {
-			duration = minTtl(m.Answer, mt)
+			duration = minTTL(m.Answer, mt)
 		}
 		i := newItem(m, duration)
 
 		c.cache.Set(key, i, duration)
 	case response.NameError, response.NoData:
 		if c.cap == 0 {
-			duration = minTtl(m.Ns, mt)
+			duration = minTTL(m.Ns, mt)
 		}
 		i := newItem(m, duration)
 
@@ -102,23 +106,25 @@ func (c *CachingResponseWriter) set(m *dns.Msg, key string, mt response.Type) {
 	}
 }
 
-func (c *CachingResponseWriter) Write(buf []byte) (int, error) {
+// Write implements the dns.ResponseWriter interface.
+func (c *ResponseWriter) Write(buf []byte) (int, error) {
 	log.Printf("[WARNING] Caching called with Write: not caching reply")
 	n, err := c.ResponseWriter.Write(buf)
 	return n, err
 }
 
-func (c *CachingResponseWriter) Hijack() {
+// Hijack implements the dns.ResponseWriter interface.
+func (c *ResponseWriter) Hijack() {
 	c.ResponseWriter.Hijack()
 	return
 }
 
-func minTtl(rrs []dns.RR, mt response.Type) time.Duration {
+func minTTL(rrs []dns.RR, mt response.Type) time.Duration {
 	if mt != response.Success && mt != response.NameError && mt != response.NoData {
 		return 0
 	}
 
-	minTtl := maxTtl
+	minTTL := maxTTL
 	for _, r := range rrs {
 		switch mt {
 		case response.NameError, response.NoData:
@@ -126,17 +132,17 @@ func minTtl(rrs []dns.RR, mt response.Type) time.Duration {
 				return time.Duration(r.(*dns.SOA).Minttl) * time.Second
 			}
 		case response.Success, response.Delegation:
-			if r.Header().Ttl < minTtl {
-				minTtl = r.Header().Ttl
+			if r.Header().Ttl < minTTL {
+				minTTL = r.Header().Ttl
 			}
 		}
 	}
-	return time.Duration(minTtl) * time.Second
+	return time.Duration(minTTL) * time.Second
 }
 
 const (
 	purgeDuration          = 1 * time.Minute
 	defaultDuration        = 20 * time.Minute
-	baseTtl                = 5 // minimum ttl that we will allow
-	maxTtl          uint32 = 2 * 3600
+	baseTTL                = 5 // minimum TTL that we will allow
+	maxTTL          uint32 = 2 * 3600
 )