v1.4.1 add pool get timeout

cache.go

@@ -1,9 +1,12 @@
 package cache
 
 import (
+	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
+	"reflect"
+	"sync"
 	"time"
 
 	"github.com/gomodule/redigo/redis"
@@ -11,9 +14,12 @@ import (
 )
 
 var (
+	ErrExpired        = errors.New("expired")
 	ErrNotFound       = errors.New("not found")
+	ErrTimeout        = errors.New("not found(timeout)")
 	OptWithoutGetter  = optWithoutGetter{}  // for get only
 	OptWithCreateTime = optWithCreateTime{} // for set & get
+	OptWithRedisConn  = optWithRedisConn{}  // for set & get
 )
 
 type Cacher[T any] interface {
@@ -25,6 +31,13 @@ type Getter[T any] interface {
 	GetById(id string) (dat *T, err error)
 }
 
+type cacher[T any] struct {
+	cfg        Config
+	getter     Getter[T]
+	localCache *localCacher[T]
+	redisCache *redisCacher[T]
+}
+
 type (
 	Option            any
 	optWithoutGetter  struct{}                        // for get only
@@ -41,24 +54,25 @@ type Config struct {
 	UseLocalCache            bool        // use localcache or not
 	LocalCacheLifetimeSecond int64       // local cache lifetime(t<0: forever; t=0: default; t>0: seconds)
 	UseRedisCache            bool        // use redis or not
-	RedisCacheConn           redis.Conn  // redis.Conn
-	RedisCacheConnPool       *redis.Pool // redis.Pool
+	RedisCacheConn           redis.Conn  `json:"-"` // redis.Conn
+	RedisCacheConnPool       *redis.Pool `json:"-"` // redis.Pool
 	RedisCacheKeyPrefix      string      // redis key prefix
 	RedisCacheLifetimeSecond int64       // redis cache lifetime(t<0: forever; t=0: default; t>0: seconds)
 	UseGetter                bool        // not used
 	GetterNoWarning          bool        // no warning if no getter
+	UseExpiredCache          *bool       // use expired cache or not (true: &[]bool{true}[0], false: &[]bool{true}[0])
 }
 
 func NewCache[T any](getter Getter[T], cfg Config) Cacher[T] {
 	var c = new(cacher[T])
 	// Getter
-	c.cfg = cfg
 	c.getter = getter
 
 	// Local cache
 	if cfg.UseLocalCache {
 		c.localCache = new(localCacher[T])
-		c.localCache.cacheItems = map[string]*cacheItem[T]{}
+		c.localCache.cacher = c
+		c.localCache.cacheItems = sync.Map{} //map[string]*cacheItem[T]{}
 		c.localCache.cacheDuration = time.Duration(cfg.LocalCacheLifetimeSecond) * time.Second
 		if c.localCache.cacheDuration.Nanoseconds() == 0 {
 			c.localCache.cacheDuration = 60 * time.Second
@@ -71,6 +85,7 @@ func NewCache[T any](getter Getter[T], cfg Config) Cacher[T] {
 			panic("redis cache's key prefix must not be null")
 		}
 		c.redisCache = new(redisCacher[T])
+		c.redisCache.cacher = c
 		c.redisCache.rds = cfg.RedisCacheConn
 		c.redisCache.rdsPool = cfg.RedisCacheConnPool
 		c.redisCache.cacheDuration = time.Duration(cfg.RedisCacheLifetimeSecond) * time.Second
@@ -82,6 +97,14 @@ func NewCache[T any](getter Getter[T], cfg Config) Cacher[T] {
 		panic("want to user redis cache, but redis.Conn is nil")
 	}
 
+	//UseExpiredCache
+	if cfg.UseExpiredCache == nil {
+		cfg.UseExpiredCache = &[]bool{true}[0]
+	}
+
+	c.cfg = cfg
+	name := reflect.TypeOf(*new(T)).String()
+	log.PrintPretty("new cache '"+name+"' by config:", cfg)
 	return c
 }
 
@@ -139,45 +162,56 @@ type cacheItem[T any] struct {
 }
 
 type localCacher[T any] struct {
-	cacheItems    map[string]*cacheItem[T]
-	cacheDuration time.Duration
+	cacher        *cacher[T]    // parents cacher pointer
+	cacheItems    sync.Map      // map[string]*cacheItem[T]
+	cacheDuration time.Duration // cache alive duration
 }
 
 type redisCacher[T any] struct {
-	rds           redis.Conn
-	rdsPool       *redis.Pool
+	cacher        *cacher[T]
 	cachePrefix   string
 	cacheDuration time.Duration
-}
-
-type cacher[T any] struct {
-	cfg        Config
-	getter     Getter[T]
-	localCache *localCacher[T]
-	redisCache *redisCacher[T]
+	rds           redis.Conn
+	rdsPool       *redis.Pool
 }
 
 func (c *localCacher[T]) GetFromCache(id string, options ...Option) (t *T, err error) {
-	var a, ok = c.cacheItems[id]
-	if !ok {
+	// Step 1. get from map
+	var a *cacheItem[T] = nil
+	if aa, ok := c.cacheItems.Load(id); !ok {
 		return nil, ErrNotFound
+	} else if a, ok = aa.(*cacheItem[T]); !ok {
+		panic("unreachable code, inner item type must be '*cacheItem[T]'")
 	}
 
+	// Step 2. check is expired or not
 	if c.cacheDuration.Nanoseconds() > 0 {
 		var earliestCreateTime = time.Now().Add(-c.cacheDuration)
 		if a.CreateTime.Before(earliestCreateTime) {
-			log.Infof("cache(%s) is in local cache but expired", id)
-			//TODO: cocurrent
-			delete(c.cacheItems, id)
+			if *c.cacher.cfg.UseExpiredCache {
+				log.Infof("cache(%s) in local is expired, "+
+					"we will use it when all other caches are missing", id)
+				err = ErrExpired
+			} else {
+				log.Infof("cache(%s) is in local cache but expired, we delete it", id)
+				c.cacheItems.Delete(id)
 				return nil, ErrNotFound
 			}
 		}
+	}
 
+	// Step 3. get cache creattime if need
 	var opt = optionParser(options...)
 	if isOptWithCreateTimeForGetter(opt) {
 		*opt.withCreateTime.createtime = a.CreateTime
 	}
 
+	// Step 4. return
+	if err == ErrExpired {
+		return a.Data, ErrExpired
+	} else if err != nil {
+		panic("unreachable code: only ErrExpired error valid when data exist")
+	}
 	return a.Data, nil
 }
 
@@ -189,7 +223,7 @@ func (c *localCacher[T]) SetIntoCache(id string, t *T, options ...Option) (err e
 	} else {
 		newitem.CreateTime = time.Now()
 	}
-	c.cacheItems[id] = newitem
+	c.cacheItems.Store(id, newitem)
 	return nil
 }
 
@@ -204,7 +238,14 @@ func (c *redisCacher[T]) GetFromCache(id string, options ...Option) (*T, error)
 	if opt.withRedisConn != nil && opt.withRedisConn.redisconn != nil {
 		rds = opt.withRedisConn.redisconn
 	} else if c.rdsPool != nil {
-		rds = c.rdsPool.Get()
+		// timeout context
+		ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+		defer cancel()
+		// redis conn from pool
+		rds, err = c.rdsPool.GetContext(ctx)
+		if err != nil {
+			return nil, ErrTimeout
+		}
 		defer rds.Close()
 	} else if c.rds != nil {
 		rds = c.rds
@@ -227,16 +268,28 @@ func (c *redisCacher[T]) GetFromCache(id string, options ...Option) (*T, error)
 	if c.cacheDuration.Nanoseconds() > 0 {
 		var earliestCreateTime = time.Now().Add(-c.cacheDuration)
 		if a.CreateTime.Before(earliestCreateTime) {
+			if *c.cacher.cfg.UseExpiredCache {
+				log.Infof("cache(%s) in redis is expired, "+
+					"we will use it when all other caches are missing", id)
+				err = ErrExpired
+			} else {
 				log.Infof("app(%s) is in redis cache but expired", id)
 				return nil, ErrNotFound
 			}
 		}
+	}
 
 	// Step 4. get cache creattime if need
 	if isOptWithCreateTimeForGetter(opt) {
 		*opt.withCreateTime.createtime = a.CreateTime
 	}
 
+	// Step 5. return
+	if err == ErrExpired {
+		return a.Data, ErrExpired
+	} else if err != nil {
+		panic("unreachable code")
+	}
 	return a.Data, nil
 }
 
@@ -252,7 +305,14 @@ func (c *redisCacher[T]) SetIntoCache(id string, t *T, options ...Option) error
 	if opt.withRedisConn != nil && opt.withRedisConn.redisconn != nil {
 		rds = opt.withRedisConn.redisconn
 	} else if c.rdsPool != nil {
-		rds = c.rdsPool.Get()
+		// timeout context
+		ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+		defer cancel()
+		// redis conn from pool
+		rds, err = c.rdsPool.GetContext(ctx)
+		if err != nil {
+			return errors.New("set cache failed: 'get redis conn timeout'")
+		}
 		defer rds.Close()
 	} else if c.rds != nil {
 		rds = c.rds
@@ -286,13 +346,18 @@ func (c *cacher[T]) GetFromCache(id string, options ...Option) (dat *T, err erro
 	}
 
 	var opt = optionParser(options...)
+	var lastExpiredDat *T = nil
 	// Step 2. get from [local]
 	if c.localCache != nil {
 		if dat, err := c.localCache.GetFromCache(id, options...); err == nil {
 			log.Infof("get cache(id:%s) from localCacher success", id)
 			return dat, nil
+		} else if err == ErrExpired {
+			log.Infof("get cache(id:%s) from localCacher success(but expired), need try next", id)
+			lastExpiredDat = dat
+		} else {
+			log.Infof("get cache(id:%s) from localCacher failed, need try next", id)
 		}
-		log.Infof("get cache(id:%s) from localCacher failed, try next", id)
 	}
 
 	// Step 3. get from [redis]
@@ -307,16 +372,28 @@ func (c *cacher[T]) GetFromCache(id string, options ...Option) (dat *T, err erro
 			}
 			log.Infof("get cache(id:%s) from redisCacher success", id)
 			return dat, nil
+		} else if err == ErrExpired {
+			if c.localCache != nil {
+				c.localCache.SetIntoCache(id, dat, options...) //set create time from redis
+				log.Infof("set cache(id:%s) to localCache by redisCacher done", id)
+			}
+			log.Infof("get cache(id:%s) from redisCacher success(but expired), need try next", id)
+			lastExpiredDat = dat
+		} else {
+			log.Infof("get cache(id:%s) from redisCacher failed, need try from next cacher", id)
 		}
-		log.Infof("get cache(id:%s) from redisCacher failed, try next", id)
 	}
 
 	var getter = c.getter
 	if opt.withoutGetter != nil {
-		log.Infof("all cache failed, and option 'withnogetter' is set, return ErrNotFound")
+		log.Infof("all cache failed, and option 'withoutgetter' is set, return ErrNotFound")
 		return nil, ErrNotFound
 	}
-	if getter == nil {
+
+	if getter == nil && lastExpiredDat != nil {
+		log.Infof("all cache failed(and getter is nil) but expired cache is avaliable, we use it")
+		return lastExpiredDat, nil
+	} else if getter == nil {
 		log.Infof("all cache failed, and getter is nil, return ErrNotFound")
 		if c.cfg.GetterNoWarning == false {
 			log.Warningf("cache 'getter' is nil, did you save right config in database?")
@@ -326,7 +403,10 @@ func (c *cacher[T]) GetFromCache(id string, options ...Option) (dat *T, err erro
 
 	// Step 4. get from [storager(database or somewhere)]
 	dat, err = getter.GetById(id)
-	if err != nil {
+	if err != nil && lastExpiredDat != nil {
+		log.Infof("all cache failed and getter failed, expired cache is avaliable, we will use it")
+		return lastExpiredDat, nil
+	} else if err != nil {
 		log.Errorf("cache(id:%s) is not in database, something error: %s", id, err)
 		return nil, ErrNotFound
 	}