cache/cache.go

package cache

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"reflect"
	"sync"
	"time"

	"github.com/gomodule/redigo/redis"
	"qoobing.com/gomod/log"
)

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 {
	GetFromCache(id string, options ...Option) (dat *T, err error)
	SetIntoCache(id string, dat *T, options ...Option) (err error)
}

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
	optWithRedisConn  struct{ redisconn redis.Conn }  // for set & get
	optWithCreateTime struct{ createtime *time.Time } // for set & get
	Options           struct {
		withoutGetter  *optWithoutGetter
		withCreateTime *optWithCreateTime
		withRedisConn  *optWithRedisConn
	}
)

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  `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.getter = getter

	// Local cache
	if cfg.UseLocalCache {
		c.localCache = new(localCacher[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
		}
	}

	// Redis cache
	if cfg.UseRedisCache && (cfg.RedisCacheConn != nil || cfg.RedisCacheConnPool != nil) {
		if cfg.RedisCacheKeyPrefix == "" {
			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
		c.redisCache.cachePrefix = fmt.Sprintf("%s-cache-id:", cfg.RedisCacheKeyPrefix)
		if c.redisCache.cacheDuration.Nanoseconds() == 0 {
			c.redisCache.cacheDuration = 180 * time.Second
		}
	} else if cfg.UseRedisCache {
		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
}

func optionParser(options ...Option) (opts Options) {
	var l = len(options)
	if l == 0 {
		return opts
	}
	//TODO: add i out of range & options[i] type mismatch panic recover
	for i := 0; i < l; i++ {
		o := options[i]
		switch o.(type) {
		case optWithoutGetter:
			opts.withoutGetter = new(optWithoutGetter)
		case optWithCreateTime:
			opts.withCreateTime = new(optWithCreateTime)
			i++
			opts.withCreateTime.createtime = options[i].(*time.Time)
		case optWithRedisConn:
			opts.withRedisConn = new(optWithRedisConn)
			i++
			opts.withRedisConn.redisconn = options[i].(redis.Conn)
		default:
			panic("unreachable code, maybe miss some code modification")
		}
	}
	return opts
}

func isOptWithCreateTimeForSetter(opts Options) bool {
	if opts.withCreateTime == nil {
		return false
	}
	var createtime = opts.withCreateTime.createtime
	if createtime == nil {
		return false
	}
	return !createtime.IsZero()
}

func isOptWithCreateTimeForGetter(opts Options) bool {
	if opts.withCreateTime == nil {
		return false
	}
	var createtime = opts.withCreateTime.createtime
	if createtime == nil {
		return false
	}
	return createtime.IsZero()
}

type cacheItem[T any] struct {
	Data       *T        `json:"d"` //cache data
	CreateTime time.Time `json:"t"` //cache create time
}

type localCacher[T any] struct {
	cacher        *cacher[T]    // parents cacher pointer
	cacheItems    sync.Map      // map[string]*cacheItem[T]
	cacheDuration time.Duration // cache alive duration
}

type redisCacher[T any] struct {
	cacher        *cacher[T]
	cachePrefix   string
	cacheDuration time.Duration
	rds           redis.Conn
	rdsPool       *redis.Pool
}

func (c *localCacher[T]) GetFromCache(id string, options ...Option) (t *T, err error) {
	// 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) {
			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
}

func (c *localCacher[T]) SetIntoCache(id string, t *T, options ...Option) (err error) {
	var opt = optionParser(options...)
	var newitem = &cacheItem[T]{Data: t}
	if isOptWithCreateTimeForSetter(opt) {
		newitem.CreateTime = *opt.withCreateTime.createtime
	} else {
		newitem.CreateTime = time.Now()
	}
	c.cacheItems.Store(id, newitem)
	return nil
}

func (c *redisCacher[T]) GetFromCache(id string, options ...Option) (*T, error) {
	var (
		err        error      = nil
		rds        redis.Conn = nil
		opt                   = optionParser(options...)
		redisKey              = c.cachePrefix + id
		redisValue            = ""
	)
	if opt.withRedisConn != nil && opt.withRedisConn.redisconn != nil {
		rds = opt.withRedisConn.redisconn
	} else if c.rdsPool != nil {
		// 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
	}

	// Step 1. read from redis
	if redisValue, err = redis.String(rds.Do("GET", redisKey)); err != nil {
		log.Infof("get cache failed: 'redis return<%s>'", err.Error())
		return nil, ErrNotFound
	}

	// Step 2. decode from string
	a := &cacheItem[T]{}
	if err = json.Unmarshal([]byte(redisValue), a); err != nil {
		log.Errorf("get cache failed: 'json unmarshal failed <%s>'", err.Error())
		return nil, ErrNotFound
	}

	// Step 3. check expire time
	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
}

func (c *redisCacher[T]) SetIntoCache(id string, t *T, options ...Option) error {
	var (
		opt                   = optionParser(options...)
		rds        redis.Conn = nil
		redisKey              = c.cachePrefix + id
		redisValue            = []byte{}
		err        error      = nil
	)
	// Step 0. redis.Conn
	if opt.withRedisConn != nil && opt.withRedisConn.redisconn != nil {
		rds = opt.withRedisConn.redisconn
	} else if c.rdsPool != nil {
		// 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
	}

	// Step 1. encode  to string
	var a = cacheItem[T]{Data: t}
	if isOptWithCreateTimeForSetter(opt) {
		a.CreateTime = *opt.withCreateTime.createtime
	} else {
		a.CreateTime = time.Now()
	}
	if redisValue, err = json.Marshal(a); err != nil {
		log.Errorf("set cache failed: 'json marshal failed <%s>'", err.Error())
		return errors.New("set cache failed: 'marshal failed'")
	}

	// Step 2. write into redis
	if _, err = rds.Do("SET", redisKey, string(redisValue)); err != nil {
		log.Errorf("set cache failed: 'redis failed <%s>'", err.Error())
		return errors.New("set cache failed: 'redis failed'")
	}

	return nil
}

func (c *cacher[T]) GetFromCache(id string, options ...Option) (dat *T, err error) {
	// Step 1. check id
	if len(id) < 1 {
		return nil, ErrNotFound
	}

	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)
		}
	}

	// Step 3. get from [redis]
	if c.redisCache != nil {
		//if opt.withCreateTime == nil { //get create time from redis
		//	options = append(options, OptWithCreateTime, new(time.Time))
		//}
		if dat, err := c.redisCache.GetFromCache(id, options...); err == nil {
			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", 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)
		}
	}

	var getter = c.getter
	if opt.withoutGetter != nil {
		log.Infof("all cache failed, and option 'withoutgetter' is set, return ErrNotFound")
		return nil, ErrNotFound
	}

	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?")
		}
		return nil, ErrNotFound
	}

	// Step 4. get from [storager(database or somewhere)]
	dat, err = getter.GetById(id)
	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
	}
	log.Infof("get cache(id:%s) from exportStorager(maybe database) success", id)

	// Step 5. set to cacha
	if c.localCache != nil {
		c.localCache.SetIntoCache(id, dat, options...)
	}
	if c.redisCache != nil {
		c.redisCache.SetIntoCache(id, dat, options...)
	}

	// Step 6. return
	log.PrintPretty("success cached/return app:", dat)
	return dat, nil
}

func (c *cacher[T]) SetIntoCache(id string, dat *T, options ...Option) (err error) {
	// localCache
	if c.localCache != nil {
		if err = c.localCache.SetIntoCache(id, dat, options...); err != nil {
			log.Infof("set data into localCache failed, err:%s", err)
		} else {
			log.Debugf("success set data into localCache, id: %s", id)
		}
	}

	// redisCache
	if c.redisCache != nil {
		if err = c.redisCache.SetIntoCache(id, dat, options...); err != nil {
			log.Infof("set data into redisCache failed, err:%s", err)
		} else {
			log.Debugf("success set data into redisCache, id: %s", id)
		}
	}
	return nil
}