cache add expire strategy

README.MD

@@ -15,7 +15,9 @@ Similar as [dnsmasq](http://www.thekelleys.org.uk/dnsmasq/doc.html) ,but support
 * Cache records save in memory or redis configurable
 
 
-## Install & Running
+## Install
+
+## Running
 
 
 
@@ -46,6 +48,19 @@ If multi `namerserver` set at resolv.conf, the upsteam server will try in order
 
 Only the local memory storage backend implemented now.  The redis backend is in todo list
 
+```
+[cache]
+backend = "memory"   
+expire = 600  # default expire time 10 minutes
+maxcount = 100000
+```
+
+
+## TODO
+
+* The redis cache backend
+* Update ttl
+
 
 
 

cache.go

@@ -39,69 +39,82 @@ func (e SerializerError) Error() string {
 	return "Serializer error"
 }
 
+type Mesg struct {
+	Msg    *dns.Msg
+	Expire time.Time
+}
+
 type Cache interface {
-	Get(key string) (*dns.Msg, error)
+	Get(key string) (Msg *dns.Msg, err error)
-	Set(key string, mesg *dns.Msg) error
+	Set(key string, Msg *dns.Msg) error
 	Exists(key string) bool
 	Remove(key string)
 	Length() int
 }
 
 type MemoryCache struct {
-	backend  map[string]*dns.Msg
+	Backend  map[string]Mesg
-	expire   time.Duration
+	Expire   time.Duration
-	maxcount int
+	Maxcount int
 }
 
 func (c *MemoryCache) Get(key string) (*dns.Msg, error) {
 
-	mesg, ok := c.backend[key]
+	mesg, ok := c.Backend[key]
 	if !ok {
 		return nil, KeyNotFound{key}
 	}
 
-	return mesg, nil
+	if mesg.Expire.Before(time.Now()) {
+		c.Remove(key)
+		return nil, KeyExpired{key}
+	}
+
+	return mesg.Msg, nil
 
 }
 
-func (c *MemoryCache) Set(key string, mesg *dns.Msg) error {
+func (c *MemoryCache) Set(key string, msg *dns.Msg) error {
 	if c.Full() && !c.Exists(key) {
 		return CacheIsFull{}
 	}
-	c.backend[key] = mesg
+
+	expire := time.Now().Add(c.Expire)
+	mesg := Mesg{msg, expire}
+	c.Backend[key] = mesg
 	return nil
 }
 
 func (c *MemoryCache) Remove(key string) {
-	delete(c.backend, key)
+	delete(c.Backend, key)
 }
 
 func (c *MemoryCache) Exists(key string) bool {
-	_, ok := c.backend[key]
+	_, ok := c.Backend[key]
 	return ok
 }
 
 func (c *MemoryCache) Length() int {
-	return len(c.backend)
+	return len(c.Backend)
 }
 
 func (c *MemoryCache) Full() bool {
-	// if maxcount is zero. the cache will never be full.
+	// if Maxcount is zero. the cache will never be full.
-	if c.maxcount == 0 {
+	if c.Maxcount == 0 {
 		return false
 	}
-	return c.Length() >= c.maxcount
+	return c.Length() >= c.Maxcount
 }
 
 /*
-TODO: Redis cache backend
+TODO: Redis cache Backend
 */
 
 type RedisCache struct {
-	backend    *redis.Client
+	Backend    *redis.Client
-	serializer JsonSerializer
+	Serializer JsonSerializer
-	expire     time.Duration
+	Expire     time.Duration
-	maxcount   int
+	Maxcount   int
 }
 
 func (c *RedisCache) Get() {

handler.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"github.com/miekg/dns"
+	"time"
 )
 
 type Question struct {
@@ -42,16 +43,16 @@ func NewHandler() *GODNSHandler {
 	switch cacheConfig.Backend {
 	case "memory":
 		cache = &MemoryCache{
-			backend:  make(map[string]*dns.Msg),
+			Backend:  make(map[string]Mesg),
-			expire:   cacheConfig.Expire,
+			Expire:   time.Duration(cacheConfig.Expire) * time.Second,
-			maxcount: cacheConfig.Maxcount,
+			Maxcount: cacheConfig.Maxcount,
 		}
 	case "redis":
 		// cache = &MemoryCache{
-		// 	backend:    make(map[string]*dns.Msg),
+		// 	Backend:    make(map[string]*dns.Msg),
-		// 	serializer: new(JsonSerializer),
+		//  Expire:   time.Duration(cacheConfig.Expire) * time.Second,
-		// 	expire:     cacheConfig.Expire,
+		// 	Serializer: new(JsonSerializer),
-		// 	maxcount:   cacheConfig.Maxcount,
+		// 	Maxcount:   cacheConfig.Maxcount,
 		// }
 		panic("Redis cache backend not implement yet")
 	default:

settings.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"github.com/BurntSushi/toml"
 	"os"
-	"time"
 )
 
 var (
@@ -45,7 +44,7 @@ type LogSettings struct {
 
 type CacheSettings struct {
 	Backend  string
-	Expire   time.Duration
+	Expire   int
 	Maxcount int
 }