foomap.go

// Code generated by cacheme, DO NOT EDIT.
package store

import (
	"bytes"
	"context"
	"errors"
	"fmt"
	"sort"
	"strings"
	"text/template"
	"time"

	cacheme "github.com/Yiling-J/cacheme-go"
	"github.com/go-redis/redis/v8"
)

// FooMapCache is the store for FooMap
type FooMapCache struct {
	Fetch         func(ctx context.Context, ID string) (map[string]string, error)
	tag           string
	memo          *cacheme.RedisMemoLock
	client        *Client
	versionString string
	versionFunc   func() string
	singleflight  bool
	metadata      bool
}

// FooMapPromise is the promise for FooMap
type FooMapPromise struct {
	executed     chan bool
	redisPromise *redis.StringCmd
	result       map[string]string
	error        error
	store        *FooMapCache
	ctx          context.Context
}

func (p *FooMapPromise) waitExecute(cp *cacheme.CachePipeline, key string, ID string) {
	defer cp.Wg.Done()
	var t map[string]string
	memo := p.store.memo

	<-cp.Executed
	value, err := p.redisPromise.Bytes()
	if err == nil {
		p.store.client.logger.Log(p.store.tag, key, Hit)
		err = cacheme.Unmarshal(value, &t)
		p.result, p.error = t, err
		return
	}

	resourceLock, err := memo.Lock(p.ctx, key)
	if err != nil {
		p.error = err
		return
	}
	p.store.client.logger.Log(p.store.tag, key, Miss)

	if resourceLock {
		p.store.client.logger.Log(p.store.tag, key, Fetch)
		value, err := p.store.Fetch(
			p.ctx,
			ID)
		if err != nil {
			p.error = err
			return
		}
		p.result = value
		packed, err := cacheme.Marshal(value)
		if err == nil {
			memo.SetCache(p.ctx, key, packed, time.Millisecond*300000)
			if p.store.metadata {
				memo.AddGroup(p.ctx, p.store.group(), key)
			}
		}
		p.error = err
		return
	}

	var res []byte
	if p.store.singleflight {
		res, err = memo.WaitSingle(p.ctx, key)
	} else {
		res, err = memo.Wait(p.ctx, key)
	}
	if err == nil {
		err = cacheme.Unmarshal(res, &t)
	}
	p.result, p.error = t, err
}

// Result return promise result.
func (p *FooMapPromise) Result() (map[string]string, error) {
	return p.result, p.error
}

func (s *FooMapCache) setClient(c *Client) {
	s.client = c
}

func (s *FooMapCache) clone(r cacheme.RedisClient) *FooMapCache {
	value := *s
	new := &value
	lock, err := cacheme.NewRedisMemoLock(
		context.TODO(), "cacheme", r, s.tag, 5*time.Second,
	)
	if err != nil {
		fmt.Println(err)
	}
	new.memo = lock

	return new
}

func (s *FooMapCache) version() string {
	if s.versionFunc != nil {
		return s.versionFunc()
	}
	return s.versionString
}

func (s *FooMapCache) keyTemplate() string {
	return "foomap:{{.ID}}" + ":v" + s.version()
}

func (s *FooMapCache) key(p *fooMapParam) (string, error) {
	t := template.Must(template.New("").Parse(s.keyTemplate()))
	t = t.Option("missingkey=zero")
	var tpl bytes.Buffer
	err := t.Execute(&tpl, p)
	return tpl.String(), err
}

func (s *FooMapCache) group() string {
	return "cacheme" + ":group:" + s.tag + ":v" + s.version()
}

func (s *FooMapCache) versionedGroup(v string) string {
	return "cacheme" + ":group:" + s.tag + ":v" + v
}

func (s *FooMapCache) addMemoLock() error {
	lock, err := cacheme.NewRedisMemoLock(context.TODO(), "cacheme", s.client.redis, s.tag, 5*time.Second)
	if err != nil {
		return err
	}

	s.memo = lock
	return nil
}

func (s *FooMapCache) initialized() bool {
	return s.Fetch != nil
}

// GetP return a pipeline getter.
func (s *FooMapCache) GetP(ctx context.Context, pp *cacheme.CachePipeline, ID string) (*FooMapPromise, error) {
	param := &fooMapParam{}

	param.ID = ID

	key, err := s.key(param)
	if err != nil {
		return nil, err
	}

	cacheme := s.memo

	promise := &FooMapPromise{
		executed: pp.Executed,
		ctx:      ctx,
		store:    s,
	}

	wait := cacheme.GetCachedP(ctx, pp.Pipeline, key)
	promise.redisPromise = wait
	pp.Wg.Add(1)
	go promise.waitExecute(
		pp, key, ID)
	return promise, nil
}

// Get return result from store.
func (s *FooMapCache) Get(ctx context.Context, ID string) (map[string]string, error) {

	param := &fooMapParam{}

	param.ID = ID

	var t map[string]string

	key, err := s.key(param)
	if err != nil {
		return t, err
	}

	if s.singleflight {
		data, err, _ := s.memo.SingleGroup().Do(key, func() (interface{}, error) {
			return s.get(ctx, ID)
		})
		return data.(map[string]string), err
	}
	return s.get(ctx, ID)
}

type fooMapParam struct {
	ID string
}

func (p *fooMapParam) pid() string {
	var id string

	id = id + p.ID

	return id
}

type FooMapMultiGetter struct {
	store *FooMapCache
	keys  []fooMapParam
}

// FooMapQuerySet is a query struct, using Get to get a single element or GetSlice to get all elements.
type FooMapQuerySet struct {
	keys    []string
	results map[string]map[string]string
}

// Get return single element for queryset with give params, return error if not found.
func (q *FooMapQuerySet) Get(ID string) (map[string]string, error) {
	param := fooMapParam{

		ID: ID,
	}
	v, ok := q.results[param.pid()]
	if !ok {
		return v, errors.New("not found")
	}
	return v, nil
}

// GetSlice return all elements from queryset. Same order as input.
func (q *FooMapQuerySet) GetSlice() []map[string]string {
	var results []map[string]string
	for _, k := range q.keys {
		results = append(results, q.results[k])
	}
	return results
}

// MGetter return a new multiple getter for current store.
func (s *FooMapCache) MGetter() *FooMapMultiGetter {
	return &FooMapMultiGetter{
		store: s,
		keys:  []fooMapParam{},
	}
}

// GetM append a new get promise to getter.
func (g *FooMapMultiGetter) GetM(ID string) *FooMapMultiGetter {
	g.keys = append(g.keys, fooMapParam{ID: ID})
	return g
}

// Do send all requests to redis using pipeline and get results, missing parts will call fetch function.
func (g *FooMapMultiGetter) Do(ctx context.Context) (*FooMapQuerySet, error) {
	qs := &FooMapQuerySet{}
	var keys []string
	for _, k := range g.keys {
		pid := k.pid()
		qs.keys = append(qs.keys, pid)
		keys = append(keys, pid)
	}
	if g.store.singleflight {
		sort.Strings(keys)
		group := strings.Join(keys, ":")
		data, err, _ := g.store.memo.SingleGroup().Do(group, func() (interface{}, error) {
			return g.pipeDo(ctx)
		})
		qs.results = data.(map[string]map[string]string)
		return qs, err
	}
	data, err := g.pipeDo(ctx)
	qs.results = data
	return qs, err
}

func (g *FooMapMultiGetter) pipeDo(ctx context.Context) (map[string]map[string]string, error) {
	pipeline := cacheme.NewPipeline(g.store.client.Redis())
	ps := make(map[string]*FooMapPromise)
	for _, k := range g.keys {
		pid := k.pid()
		if _, ok := ps[pid]; ok {
			continue
		}
		promise, err := g.store.GetP(ctx, pipeline, k.ID)
		if err != nil {
			return nil, err
		}
		ps[pid] = promise
	}

	err := pipeline.Execute(ctx)
	if err != nil {
		return nil, err
	}

	results := make(map[string]map[string]string)
	for k, p := range ps {
		r, err := p.Result()
		if err != nil {
			return nil, err
		}
		results[k] = r
	}
	return results, nil
}

// GetM append a new get promise to getter.
func (s *FooMapCache) GetM(ID string) *FooMapMultiGetter {
	return &FooMapMultiGetter{
		store: s,
		keys:  []fooMapParam{{ID: ID}},
	}
}

func (s *FooMapCache) get(ctx context.Context, ID string) (map[string]string, error) {
	param := &fooMapParam{}

	param.ID = ID

	var t map[string]string

	key, err := s.key(param)
	if err != nil {
		return t, err
	}

	memo := s.memo
	var res []byte

	res, err = memo.GetCached(ctx, key)
	if err == nil {
		s.client.logger.Log(s.tag, key, Hit)
		err = cacheme.Unmarshal(res, &t)
		return t, err
	}

	if err != redis.Nil {
		return t, errors.New("")
	}
	s.client.logger.Log(s.tag, key, Miss)

	resourceLock, err := memo.Lock(ctx, key)
	if err != nil {
		return t, err
	}

	if resourceLock {
		s.client.logger.Log(s.tag, key, Fetch)
		value, err := s.Fetch(ctx, ID)
		if err != nil {
			return value, err
		}
		packed, err := cacheme.Marshal(value)
		if err == nil {
			memo.SetCache(ctx, key, packed, time.Millisecond*300000)
			if s.metadata {
				memo.AddGroup(ctx, s.group(), key)
			}
		}
		return value, err
	}

	res, err = memo.Wait(ctx, key)

	if err == nil {
		err = cacheme.Unmarshal(res, &t)
		return t, err
	}
	return t, err
}

// Update call fetch function with given params and update Redis.
func (s *FooMapCache) Update(ctx context.Context, ID string) error {

	param := &fooMapParam{}

	param.ID = ID

	key, err := s.key(param)
	if err != nil {
		return err
	}

	value, err := s.Fetch(ctx, ID)
	if err != nil {
		return err
	}
	packed, err := cacheme.Marshal(value)
	if err == nil {
		s.memo.SetCache(ctx, key, packed, time.Millisecond*300000)
		if s.metadata {
			s.memo.AddGroup(ctx, s.group(), key)
		}
	}
	return err
}

// Update remove cache with given params from Redis.
func (s *FooMapCache) Invalid(ctx context.Context, ID string) error {

	param := &fooMapParam{}

	param.ID = ID

	key, err := s.key(param)
	if err != nil {
		return err
	}
	return s.memo.DeleteCache(ctx, key)

}

// InvalidAll will invalid all caches match provided version from current store.
func (s *FooMapCache) InvalidAll(ctx context.Context, version string) error {
	group := s.versionedGroup(version)
	if s.client.cluster {
		return cacheme.InvalidAllCluster(ctx, group, s.client.redis)
	}
	return cacheme.InvalidAll(ctx, group, s.client.redis)

}