From 475d17e17db33b56d6559f78247aac6c11b668c6 Mon Sep 17 00:00:00 2001 From: benqi Date: Mon, 4 Apr 2022 23:19:58 +0800 Subject: [PATCH] feat: support ctx in kv methods (#1759) --- core/stores/kv/store.go | 456 ++++++++++++++++++++++++++++++++++------ 1 file changed, 390 insertions(+), 66 deletions(-) diff --git a/core/stores/kv/store.go b/core/stores/kv/store.go index d39334cc..f7ee6b42 100644 --- a/core/stores/kv/store.go +++ b/core/stores/kv/store.go @@ -1,6 +1,7 @@ package kv import ( + "context" "errors" "log" @@ -17,69 +18,133 @@ type ( // Store interface represents a KV store. Store interface { Decr(key string) (int64, error) - Decrby(key string, increment int64) (int64, error) + DecrCtx(ctx context.Context, key string) (int64, error) + Decrby(key string, decrement int64) (int64, error) + DecrbyCtx(ctx context.Context, key string, decrement int64) (int64, error) Del(keys ...string) (int, error) + DelCtx(ctx context.Context, keys ...string) (int, error) Eval(script, key string, args ...interface{}) (interface{}, error) + EvalCtx(ctx context.Context, script, key string, args ...interface{}) (interface{}, error) Exists(key string) (bool, error) + ExistsCtx(ctx context.Context, key string) (bool, error) Expire(key string, seconds int) error + ExpireCtx(ctx context.Context, key string, seconds int) error Expireat(key string, expireTime int64) error + ExpireatCtx(ctx context.Context, key string, expireTime int64) error Get(key string) (string, error) + GetCtx(ctx context.Context, key string) (string, error) GetSet(key, value string) (string, error) + GetSetCtx(ctx context.Context, key, value string) (string, error) Hdel(key, field string) (bool, error) + HdelCtx(ctx context.Context, key, field string) (bool, error) Hexists(key, field string) (bool, error) + HexistsCtx(ctx context.Context, key, field string) (bool, error) Hget(key, field string) (string, error) + HgetCtx(ctx context.Context, key, field string) (string, error) Hgetall(key string) (map[string]string, error) + HgetallCtx(ctx context.Context, key string) (map[string]string, error) Hincrby(key, field string, increment int) (int, error) + HincrbyCtx(ctx context.Context, key, field string, increment int) (int, error) Hkeys(key string) ([]string, error) + HkeysCtx(ctx context.Context, key string) ([]string, error) Hlen(key string) (int, error) + HlenCtx(ctx context.Context, key string) (int, error) Hmget(key string, fields ...string) ([]string, error) + HmgetCtx(ctx context.Context, key string, fields ...string) ([]string, error) Hset(key, field, value string) error + HsetCtx(ctx context.Context, key, field, value string) error Hsetnx(key, field, value string) (bool, error) + HsetnxCtx(ctx context.Context, key, field, value string) (bool, error) Hmset(key string, fieldsAndValues map[string]string) error + HmsetCtx(ctx context.Context, key string, fieldsAndValues map[string]string) error Hvals(key string) ([]string, error) + HvalsCtx(ctx context.Context, key string) ([]string, error) Incr(key string) (int64, error) + IncrCtx(ctx context.Context, key string) (int64, error) Incrby(key string, increment int64) (int64, error) + IncrbyCtx(ctx context.Context, key string, increment int64) (int64, error) Lindex(key string, index int64) (string, error) + LindexCtx(ctx context.Context, key string, index int64) (string, error) Llen(key string) (int, error) + LlenCtx(ctx context.Context, key string) (int, error) Lpop(key string) (string, error) + LpopCtx(ctx context.Context, key string) (string, error) Lpush(key string, values ...interface{}) (int, error) + LpushCtx(ctx context.Context, key string, values ...interface{}) (int, error) Lrange(key string, start, stop int) ([]string, error) + LrangeCtx(ctx context.Context, key string, start, stop int) ([]string, error) Lrem(key string, count int, value string) (int, error) + LremCtx(ctx context.Context, key string, count int, value string) (int, error) Persist(key string) (bool, error) + PersistCtx(ctx context.Context, key string) (bool, error) Pfadd(key string, values ...interface{}) (bool, error) + PfaddCtx(ctx context.Context, key string, values ...interface{}) (bool, error) Pfcount(key string) (int64, error) + PfcountCtx(ctx context.Context, key string) (int64, error) Rpush(key string, values ...interface{}) (int, error) + RpushCtx(ctx context.Context, key string, values ...interface{}) (int, error) Sadd(key string, values ...interface{}) (int, error) + SaddCtx(ctx context.Context, key string, values ...interface{}) (int, error) Scard(key string) (int64, error) + ScardCtx(ctx context.Context, key string) (int64, error) Set(key, value string) error + SetCtx(ctx context.Context, key, value string) error Setex(key, value string, seconds int) error + SetexCtx(ctx context.Context, key, value string, seconds int) error Setnx(key, value string) (bool, error) + SetnxCtx(ctx context.Context, key, value string) (bool, error) SetnxEx(key, value string, seconds int) (bool, error) + SetnxExCtx(ctx context.Context, key, value string, seconds int) (bool, error) Sismember(key string, value interface{}) (bool, error) + SismemberCtx(ctx context.Context, key string, value interface{}) (bool, error) Smembers(key string) ([]string, error) + SmembersCtx(ctx context.Context, key string) ([]string, error) Spop(key string) (string, error) + SpopCtx(ctx context.Context, key string) (string, error) Srandmember(key string, count int) ([]string, error) + SrandmemberCtx(ctx context.Context, key string, count int) ([]string, error) Srem(key string, values ...interface{}) (int, error) + SremCtx(ctx context.Context, key string, values ...interface{}) (int, error) Sscan(key string, cursor uint64, match string, count int64) (keys []string, cur uint64, err error) + SscanCtx(ctx context.Context, key string, cursor uint64, match string, count int64) (keys []string, cur uint64, err error) Ttl(key string) (int, error) + TtlCtx(ctx context.Context, key string) (int, error) Zadd(key string, score int64, value string) (bool, error) + ZaddCtx(ctx context.Context, key string, score int64, value string) (bool, error) Zadds(key string, ps ...redis.Pair) (int64, error) + ZaddsCtx(ctx context.Context, key string, ps ...redis.Pair) (int64, error) Zcard(key string) (int, error) + ZcardCtx(ctx context.Context, key string) (int, error) Zcount(key string, start, stop int64) (int, error) + ZcountCtx(ctx context.Context, key string, start, stop int64) (int, error) Zincrby(key string, increment int64, field string) (int64, error) + ZincrbyCtx(ctx context.Context, key string, increment int64, field string) (int64, error) Zrange(key string, start, stop int64) ([]string, error) + ZrangeCtx(ctx context.Context, key string, start, stop int64) ([]string, error) ZrangeWithScores(key string, start, stop int64) ([]redis.Pair, error) + ZrangeWithScoresCtx(ctx context.Context, key string, start, stop int64) ([]redis.Pair, error) ZrangebyscoreWithScores(key string, start, stop int64) ([]redis.Pair, error) + ZrangebyscoreWithScoresCtx(ctx context.Context, key string, start, stop int64) ([]redis.Pair, error) ZrangebyscoreWithScoresAndLimit(key string, start, stop int64, page, size int) ([]redis.Pair, error) + ZrangebyscoreWithScoresAndLimitCtx(ctx context.Context, key string, start, stop int64, page, size int) ([]redis.Pair, error) Zrank(key, field string) (int64, error) + ZrankCtx(ctx context.Context, key, field string) (int64, error) Zrem(key string, values ...interface{}) (int, error) + ZremCtx(ctx context.Context, key string, values ...interface{}) (int, error) Zremrangebyrank(key string, start, stop int64) (int, error) + ZremrangebyrankCtx(ctx context.Context, key string, start, stop int64) (int, error) Zremrangebyscore(key string, start, stop int64) (int, error) + ZremrangebyscoreCtx(ctx context.Context, key string, start, stop int64) (int, error) Zrevrange(key string, start, stop int64) ([]string, error) + ZrevrangeCtx(ctx context.Context, key string, start, stop int64) ([]string, error) ZrevrangebyscoreWithScores(key string, start, stop int64) ([]redis.Pair, error) + ZrevrangebyscoreWithScoresCtx(ctx context.Context, key string, start, stop int64) ([]redis.Pair, error) ZrevrangebyscoreWithScoresAndLimit(key string, start, stop int64, page, size int) ([]redis.Pair, error) + ZrevrangebyscoreWithScoresAndLimitCtx(ctx context.Context, key string, start, stop int64, page, size int) ([]redis.Pair, error) Zscore(key, value string) (int64, error) + ZscoreCtx(ctx context.Context, key, value string) (int64, error) Zrevrank(key, field string) (int64, error) + ZrevrankCtx(ctx context.Context, key, field string) (int64, error) } clusterStore struct { @@ -107,24 +172,36 @@ func NewStore(c KvConf) Store { } func (cs clusterStore) Decr(key string) (int64, error) { + return cs.DecrCtx(context.Background(), key) +} + +func (cs clusterStore) DecrCtx(ctx context.Context, key string) (int64, error) { node, err := cs.getRedis(key) if err != nil { return 0, err } - return node.Decr(key) + return node.DecrCtx(ctx, key) } -func (cs clusterStore) Decrby(key string, increment int64) (int64, error) { +func (cs clusterStore) Decrby(key string, decrement int64) (int64, error) { + return cs.DecrbyCtx(context.Background(), key, decrement) +} + +func (cs clusterStore) DecrbyCtx(ctx context.Context, key string, decrement int64) (int64, error) { node, err := cs.getRedis(key) if err != nil { return 0, err } - return node.Decrby(key, increment) + return node.DecrbyCtx(ctx, key, decrement) } func (cs clusterStore) Del(keys ...string) (int, error) { + return cs.DelCtx(context.Background(), keys...) +} + +func (cs clusterStore) DelCtx(ctx context.Context, keys ...string) (int, error) { var val int var be errorx.BatchError @@ -135,7 +212,7 @@ func (cs clusterStore) Del(keys ...string) (int, error) { continue } - if v, e := node.Del(key); e != nil { + if v, e := node.DelCtx(ctx, key); e != nil { be.Add(e) } else { val += v @@ -146,555 +223,802 @@ func (cs clusterStore) Del(keys ...string) (int, error) { } func (cs clusterStore) Eval(script, key string, args ...interface{}) (interface{}, error) { + return cs.EvalCtx(context.Background(), script, key, args...) +} + +func (cs clusterStore) EvalCtx(ctx context.Context, script, key string, args ...interface{}) (interface{}, error) { node, err := cs.getRedis(key) if err != nil { return nil, err } - return node.Eval(script, []string{key}, args...) + return node.EvalCtx(ctx, script, []string{key}, args...) } func (cs clusterStore) Exists(key string) (bool, error) { + return cs.ExistsCtx(context.Background(), key) +} + +func (cs clusterStore) ExistsCtx(ctx context.Context, key string) (bool, error) { node, err := cs.getRedis(key) if err != nil { return false, err } - return node.Exists(key) + return node.ExistsCtx(ctx, key) } func (cs clusterStore) Expire(key string, seconds int) error { + return cs.ExpireCtx(context.Background(), key, seconds) +} + +func (cs clusterStore) ExpireCtx(ctx context.Context, key string, seconds int) error { node, err := cs.getRedis(key) if err != nil { return err } - return node.Expire(key, seconds) + return node.ExpireCtx(ctx, key, seconds) } func (cs clusterStore) Expireat(key string, expireTime int64) error { + return cs.ExpireatCtx(context.Background(), key, expireTime) +} + +func (cs clusterStore) ExpireatCtx(ctx context.Context, key string, expireTime int64) error { node, err := cs.getRedis(key) if err != nil { return err } - return node.Expireat(key, expireTime) + return node.ExpireatCtx(ctx, key, expireTime) } func (cs clusterStore) Get(key string) (string, error) { + return cs.GetCtx(context.Background(), key) +} + +func (cs clusterStore) GetCtx(ctx context.Context, key string) (string, error) { node, err := cs.getRedis(key) if err != nil { return "", err } - return node.Get(key) + return node.GetCtx(ctx, key) } func (cs clusterStore) Hdel(key, field string) (bool, error) { + return cs.HdelCtx(context.Background(), key, field) +} + +func (cs clusterStore) HdelCtx(ctx context.Context, key, field string) (bool, error) { node, err := cs.getRedis(key) if err != nil { return false, err } - return node.Hdel(key, field) + return node.HdelCtx(ctx, key, field) } func (cs clusterStore) Hexists(key, field string) (bool, error) { + return cs.HexistsCtx(context.Background(), key, field) +} + +func (cs clusterStore) HexistsCtx(ctx context.Context, key, field string) (bool, error) { node, err := cs.getRedis(key) if err != nil { return false, err } - return node.Hexists(key, field) + return node.HexistsCtx(ctx, key, field) } func (cs clusterStore) Hget(key, field string) (string, error) { + return cs.HgetCtx(context.Background(), key, field) +} + +func (cs clusterStore) HgetCtx(ctx context.Context, key, field string) (string, error) { node, err := cs.getRedis(key) if err != nil { return "", err } - return node.Hget(key, field) + return node.HgetCtx(ctx, key, field) } func (cs clusterStore) Hgetall(key string) (map[string]string, error) { + return cs.HgetallCtx(context.Background(), key) +} + +func (cs clusterStore) HgetallCtx(ctx context.Context, key string) (map[string]string, error) { node, err := cs.getRedis(key) if err != nil { return nil, err } - return node.Hgetall(key) + return node.HgetallCtx(ctx, key) } func (cs clusterStore) Hincrby(key, field string, increment int) (int, error) { + return cs.HincrbyCtx(context.Background(), key, field, increment) +} + +func (cs clusterStore) HincrbyCtx(ctx context.Context, key, field string, increment int) (int, error) { node, err := cs.getRedis(key) if err != nil { return 0, err } - return node.Hincrby(key, field, increment) + return node.HincrbyCtx(ctx, key, field, increment) } func (cs clusterStore) Hkeys(key string) ([]string, error) { + return cs.HkeysCtx(context.Background(), key) +} + +func (cs clusterStore) HkeysCtx(ctx context.Context, key string) ([]string, error) { node, err := cs.getRedis(key) if err != nil { return nil, err } - return node.Hkeys(key) + return node.HkeysCtx(ctx, key) } func (cs clusterStore) Hlen(key string) (int, error) { + return cs.HlenCtx(context.Background(), key) +} + +func (cs clusterStore) HlenCtx(ctx context.Context, key string) (int, error) { node, err := cs.getRedis(key) if err != nil { return 0, err } - return node.Hlen(key) + return node.HlenCtx(ctx, key) } func (cs clusterStore) Hmget(key string, fields ...string) ([]string, error) { + return cs.HmgetCtx(context.Background(), key, fields...) +} + +func (cs clusterStore) HmgetCtx(ctx context.Context, key string, fields ...string) ([]string, error) { node, err := cs.getRedis(key) if err != nil { return nil, err } - return node.Hmget(key, fields...) + return node.HmgetCtx(ctx, key, fields...) } func (cs clusterStore) Hset(key, field, value string) error { + return cs.HsetCtx(context.Background(), key, field, value) +} + +func (cs clusterStore) HsetCtx(ctx context.Context, key, field, value string) error { node, err := cs.getRedis(key) if err != nil { return err } - return node.Hset(key, field, value) + return node.HsetCtx(ctx, key, field, value) } func (cs clusterStore) Hsetnx(key, field, value string) (bool, error) { + return cs.HsetnxCtx(context.Background(), key, field, value) +} + +func (cs clusterStore) HsetnxCtx(ctx context.Context, key, field, value string) (bool, error) { node, err := cs.getRedis(key) if err != nil { return false, err } - return node.Hsetnx(key, field, value) + return node.HsetnxCtx(ctx, key, field, value) } func (cs clusterStore) Hmset(key string, fieldsAndValues map[string]string) error { + return cs.HmsetCtx(context.Background(), key, fieldsAndValues) +} + +func (cs clusterStore) HmsetCtx(ctx context.Context, key string, fieldsAndValues map[string]string) error { node, err := cs.getRedis(key) if err != nil { return err } - return node.Hmset(key, fieldsAndValues) + return node.HmsetCtx(ctx, key, fieldsAndValues) } func (cs clusterStore) Hvals(key string) ([]string, error) { + return cs.HvalsCtx(context.Background(), key) +} + +func (cs clusterStore) HvalsCtx(ctx context.Context, key string) ([]string, error) { node, err := cs.getRedis(key) if err != nil { return nil, err } - return node.Hvals(key) + return node.HvalsCtx(ctx, key) } func (cs clusterStore) Incr(key string) (int64, error) { + return cs.IncrCtx(context.Background(), key) +} + +func (cs clusterStore) IncrCtx(ctx context.Context, key string) (int64, error) { node, err := cs.getRedis(key) if err != nil { return 0, err } - return node.Incr(key) + return node.IncrCtx(ctx, key) } func (cs clusterStore) Incrby(key string, increment int64) (int64, error) { + return cs.IncrbyCtx(context.Background(), key, increment) +} + +func (cs clusterStore) IncrbyCtx(ctx context.Context, key string, increment int64) (int64, error) { node, err := cs.getRedis(key) if err != nil { return 0, err } - return node.Incrby(key, increment) + return node.IncrbyCtx(ctx, key, increment) } func (cs clusterStore) Llen(key string) (int, error) { + return cs.LlenCtx(context.Background(), key) +} + +func (cs clusterStore) LlenCtx(ctx context.Context, key string) (int, error) { node, err := cs.getRedis(key) if err != nil { return 0, err } - return node.Llen(key) + return node.LlenCtx(ctx, key) } func (cs clusterStore) Lindex(key string, index int64) (string, error) { + return cs.LindexCtx(context.Background(), key, index) +} + +func (cs clusterStore) LindexCtx(ctx context.Context, key string, index int64) (string, error) { node, err := cs.getRedis(key) if err != nil { return "", err } - return node.Lindex(key, index) + return node.LindexCtx(ctx, key, index) } func (cs clusterStore) Lpop(key string) (string, error) { + return cs.LpopCtx(context.Background(), key) +} + +func (cs clusterStore) LpopCtx(ctx context.Context, key string) (string, error) { node, err := cs.getRedis(key) if err != nil { return "", err } - return node.Lpop(key) + return node.LpopCtx(ctx, key) } func (cs clusterStore) Lpush(key string, values ...interface{}) (int, error) { + return cs.LpushCtx(context.Background(), key, values...) +} + +func (cs clusterStore) LpushCtx(ctx context.Context, key string, values ...interface{}) (int, error) { node, err := cs.getRedis(key) if err != nil { return 0, err } - return node.Lpush(key, values...) + return node.LpushCtx(ctx, key, values...) } func (cs clusterStore) Lrange(key string, start, stop int) ([]string, error) { + return cs.LrangeCtx(context.Background(), key, start, stop) +} + +func (cs clusterStore) LrangeCtx(ctx context.Context, key string, start, stop int) ([]string, error) { node, err := cs.getRedis(key) if err != nil { return nil, err } - return node.Lrange(key, start, stop) + return node.LrangeCtx(ctx, key, start, stop) } func (cs clusterStore) Lrem(key string, count int, value string) (int, error) { + return cs.LremCtx(context.Background(), key, count, value) +} + +func (cs clusterStore) LremCtx(ctx context.Context, key string, count int, value string) (int, error) { node, err := cs.getRedis(key) if err != nil { return 0, err } - return node.Lrem(key, count, value) + return node.LremCtx(ctx, key, count, value) } func (cs clusterStore) Persist(key string) (bool, error) { + return cs.PersistCtx(context.Background(), key) +} + +func (cs clusterStore) PersistCtx(ctx context.Context, key string) (bool, error) { node, err := cs.getRedis(key) if err != nil { return false, err } - return node.Persist(key) + return node.PersistCtx(ctx, key) } func (cs clusterStore) Pfadd(key string, values ...interface{}) (bool, error) { + return cs.PfaddCtx(context.Background(), key, values...) +} + +func (cs clusterStore) PfaddCtx(ctx context.Context, key string, values ...interface{}) (bool, error) { node, err := cs.getRedis(key) if err != nil { return false, err } - return node.Pfadd(key, values...) + return node.PfaddCtx(ctx, key, values...) } func (cs clusterStore) Pfcount(key string) (int64, error) { + return cs.PfcountCtx(context.Background(), key) +} + +func (cs clusterStore) PfcountCtx(ctx context.Context, key string) (int64, error) { node, err := cs.getRedis(key) if err != nil { return 0, err } - return node.Pfcount(key) + return node.PfcountCtx(ctx, key) } func (cs clusterStore) Rpush(key string, values ...interface{}) (int, error) { + return cs.RpushCtx(context.Background(), key, values...) +} + +func (cs clusterStore) RpushCtx(ctx context.Context, key string, values ...interface{}) (int, error) { node, err := cs.getRedis(key) if err != nil { return 0, err } - return node.Rpush(key, values...) + return node.RpushCtx(ctx, key, values...) } func (cs clusterStore) Sadd(key string, values ...interface{}) (int, error) { + return cs.SaddCtx(context.Background(), key, values...) +} + +func (cs clusterStore) SaddCtx(ctx context.Context, key string, values ...interface{}) (int, error) { node, err := cs.getRedis(key) if err != nil { return 0, err } - return node.Sadd(key, values...) + return node.SaddCtx(ctx, key, values...) } func (cs clusterStore) Scard(key string) (int64, error) { + return cs.ScardCtx(context.Background(), key) +} + +func (cs clusterStore) ScardCtx(ctx context.Context, key string) (int64, error) { node, err := cs.getRedis(key) if err != nil { return 0, err } - return node.Scard(key) + return node.ScardCtx(ctx, key) } func (cs clusterStore) Set(key, value string) error { + return cs.SetCtx(context.Background(), key, value) +} + +func (cs clusterStore) SetCtx(ctx context.Context, key, value string) error { node, err := cs.getRedis(key) if err != nil { return err } - return node.Set(key, value) + return node.SetCtx(ctx, key, value) } func (cs clusterStore) Setex(key, value string, seconds int) error { + return cs.SetexCtx(context.Background(), key, value, seconds) +} + +func (cs clusterStore) SetexCtx(ctx context.Context, key, value string, seconds int) error { node, err := cs.getRedis(key) if err != nil { return err } - return node.Setex(key, value, seconds) + return node.SetexCtx(ctx, key, value, seconds) } func (cs clusterStore) Setnx(key, value string) (bool, error) { + return cs.SetnxCtx(context.Background(), key, value) +} + +func (cs clusterStore) SetnxCtx(ctx context.Context, key, value string) (bool, error) { node, err := cs.getRedis(key) if err != nil { return false, err } - return node.Setnx(key, value) + return node.SetnxCtx(ctx, key, value) } func (cs clusterStore) SetnxEx(key, value string, seconds int) (bool, error) { + return cs.SetnxExCtx(context.Background(), key, value, seconds) +} + +func (cs clusterStore) SetnxExCtx(ctx context.Context, key, value string, seconds int) (bool, error) { node, err := cs.getRedis(key) if err != nil { return false, err } - return node.SetnxEx(key, value, seconds) + return node.SetnxExCtx(ctx, key, value, seconds) } func (cs clusterStore) GetSet(key, value string) (string, error) { + return cs.GetSetCtx(context.Background(), key, value) +} + +func (cs clusterStore) GetSetCtx(ctx context.Context, key, value string) (string, error) { node, err := cs.getRedis(key) if err != nil { return "", err } - return node.GetSet(key, value) + return node.GetSetCtx(ctx, key, value) } func (cs clusterStore) Sismember(key string, value interface{}) (bool, error) { + return cs.SismemberCtx(context.Background(), key, value) +} + +func (cs clusterStore) SismemberCtx(ctx context.Context, key string, value interface{}) (bool, error) { node, err := cs.getRedis(key) if err != nil { return false, err } - return node.Sismember(key, value) + return node.SismemberCtx(ctx, key, value) } func (cs clusterStore) Smembers(key string) ([]string, error) { + return cs.SmembersCtx(context.Background(), key) +} + +func (cs clusterStore) SmembersCtx(ctx context.Context, key string) ([]string, error) { node, err := cs.getRedis(key) if err != nil { return nil, err } - return node.Smembers(key) + return node.SmembersCtx(ctx, key) } func (cs clusterStore) Spop(key string) (string, error) { + return cs.SpopCtx(context.Background(), key) +} + +func (cs clusterStore) SpopCtx(ctx context.Context, key string) (string, error) { node, err := cs.getRedis(key) if err != nil { return "", err } - return node.Spop(key) + return node.SpopCtx(ctx, key) } func (cs clusterStore) Srandmember(key string, count int) ([]string, error) { + return cs.SrandmemberCtx(context.Background(), key, count) +} + +func (cs clusterStore) SrandmemberCtx(ctx context.Context, key string, count int) ([]string, error) { node, err := cs.getRedis(key) if err != nil { return nil, err } - return node.Srandmember(key, count) + return node.SrandmemberCtx(ctx, key, count) } func (cs clusterStore) Srem(key string, values ...interface{}) (int, error) { + return cs.SremCtx(context.Background(), key, values...) +} + +func (cs clusterStore) SremCtx(ctx context.Context, key string, values ...interface{}) (int, error) { node, err := cs.getRedis(key) if err != nil { return 0, err } - return node.Srem(key, values...) + return node.SremCtx(ctx, key, values...) } func (cs clusterStore) Sscan(key string, cursor uint64, match string, count int64) ( + keys []string, cur uint64, err error) { + return cs.SscanCtx(context.Background(), key, cursor, match, count) +} + +func (cs clusterStore) SscanCtx(ctx context.Context, key string, cursor uint64, match string, count int64) ( keys []string, cur uint64, err error) { node, err := cs.getRedis(key) if err != nil { return nil, 0, err } - return node.Sscan(key, cursor, match, count) + return node.SscanCtx(ctx, key, cursor, match, count) } func (cs clusterStore) Ttl(key string) (int, error) { + return cs.TtlCtx(context.Background(), key) +} + +func (cs clusterStore) TtlCtx(ctx context.Context, key string) (int, error) { node, err := cs.getRedis(key) if err != nil { return 0, err } - return node.Ttl(key) + return node.TtlCtx(ctx, key) } func (cs clusterStore) Zadd(key string, score int64, value string) (bool, error) { + return cs.ZaddCtx(context.Background(), key, score, value) +} + +func (cs clusterStore) ZaddCtx(ctx context.Context, key string, score int64, value string) (bool, error) { node, err := cs.getRedis(key) if err != nil { return false, err } - return node.Zadd(key, score, value) + return node.ZaddCtx(ctx, key, score, value) } func (cs clusterStore) Zadds(key string, ps ...redis.Pair) (int64, error) { + return cs.ZaddsCtx(context.Background(), key, ps...) +} + +func (cs clusterStore) ZaddsCtx(ctx context.Context, key string, ps ...redis.Pair) (int64, error) { node, err := cs.getRedis(key) if err != nil { return 0, err } - return node.Zadds(key, ps...) + return node.ZaddsCtx(ctx, key, ps...) } func (cs clusterStore) Zcard(key string) (int, error) { + return cs.ZcardCtx(context.Background(), key) +} + +func (cs clusterStore) ZcardCtx(ctx context.Context, key string) (int, error) { node, err := cs.getRedis(key) if err != nil { return 0, err } - return node.Zcard(key) + return node.ZcardCtx(ctx, key) } func (cs clusterStore) Zcount(key string, start, stop int64) (int, error) { + return cs.ZcountCtx(context.Background(), key, start, stop) +} + +func (cs clusterStore) ZcountCtx(ctx context.Context, key string, start, stop int64) (int, error) { node, err := cs.getRedis(key) if err != nil { return 0, err } - return node.Zcount(key, start, stop) + return node.ZcountCtx(ctx, key, start, stop) } func (cs clusterStore) Zincrby(key string, increment int64, field string) (int64, error) { + return cs.ZincrbyCtx(context.Background(), key, increment, field) +} + +func (cs clusterStore) ZincrbyCtx(ctx context.Context, key string, increment int64, field string) (int64, error) { node, err := cs.getRedis(key) if err != nil { return 0, err } - return node.Zincrby(key, increment, field) + return node.ZincrbyCtx(ctx, key, increment, field) } func (cs clusterStore) Zrank(key, field string) (int64, error) { + return cs.ZrankCtx(context.Background(), key, field) +} + +func (cs clusterStore) ZrankCtx(ctx context.Context, key, field string) (int64, error) { node, err := cs.getRedis(key) if err != nil { return 0, err } - return node.Zrank(key, field) + return node.ZrankCtx(ctx, key, field) } func (cs clusterStore) Zrange(key string, start, stop int64) ([]string, error) { + return cs.ZrangeCtx(context.Background(), key, start, stop) +} + +func (cs clusterStore) ZrangeCtx(ctx context.Context, key string, start, stop int64) ([]string, error) { node, err := cs.getRedis(key) if err != nil { return nil, err } - return node.Zrange(key, start, stop) + return node.ZrangeCtx(ctx, key, start, stop) } func (cs clusterStore) ZrangeWithScores(key string, start, stop int64) ([]redis.Pair, error) { + return cs.ZrangeWithScoresCtx(context.Background(), key, start, stop) +} + +func (cs clusterStore) ZrangeWithScoresCtx(ctx context.Context, key string, start, stop int64) ([]redis.Pair, error) { node, err := cs.getRedis(key) if err != nil { return nil, err } - return node.ZrangeWithScores(key, start, stop) + return node.ZrangeWithScoresCtx(ctx, key, start, stop) } func (cs clusterStore) ZrangebyscoreWithScores(key string, start, stop int64) ([]redis.Pair, error) { + return cs.ZrangebyscoreWithScoresCtx(context.Background(), key, start, stop) +} + +func (cs clusterStore) ZrangebyscoreWithScoresCtx(ctx context.Context, key string, start, stop int64) ([]redis.Pair, error) { node, err := cs.getRedis(key) if err != nil { return nil, err } - return node.ZrangebyscoreWithScores(key, start, stop) + return node.ZrangebyscoreWithScoresCtx(ctx, key, start, stop) } func (cs clusterStore) ZrangebyscoreWithScoresAndLimit(key string, start, stop int64, page, size int) ( + []redis.Pair, error) { + return cs.ZrangebyscoreWithScoresAndLimitCtx(context.Background(), key, start, stop, page, size) +} + +func (cs clusterStore) ZrangebyscoreWithScoresAndLimitCtx(ctx context.Context, key string, start, stop int64, page, size int) ( []redis.Pair, error) { node, err := cs.getRedis(key) if err != nil { return nil, err } - return node.ZrangebyscoreWithScoresAndLimit(key, start, stop, page, size) + return node.ZrangebyscoreWithScoresAndLimitCtx(ctx, key, start, stop, page, size) } func (cs clusterStore) Zrem(key string, values ...interface{}) (int, error) { + return cs.ZremCtx(context.Background(), key, values...) +} + +func (cs clusterStore) ZremCtx(ctx context.Context, key string, values ...interface{}) (int, error) { node, err := cs.getRedis(key) if err != nil { return 0, err } - return node.Zrem(key, values...) + return node.ZremCtx(ctx, key, values...) } func (cs clusterStore) Zremrangebyrank(key string, start, stop int64) (int, error) { + return cs.ZremrangebyrankCtx(context.Background(), key, start, stop) +} + +func (cs clusterStore) ZremrangebyrankCtx(ctx context.Context, key string, start, stop int64) (int, error) { node, err := cs.getRedis(key) if err != nil { return 0, err } - return node.Zremrangebyrank(key, start, stop) + return node.ZremrangebyrankCtx(ctx, key, start, stop) } func (cs clusterStore) Zremrangebyscore(key string, start, stop int64) (int, error) { + return cs.ZremrangebyscoreCtx(context.Background(), key, start, stop) +} + +func (cs clusterStore) ZremrangebyscoreCtx(ctx context.Context, key string, start, stop int64) (int, error) { node, err := cs.getRedis(key) if err != nil { return 0, err } - return node.Zremrangebyscore(key, start, stop) + return node.ZremrangebyscoreCtx(ctx, key, start, stop) } func (cs clusterStore) Zrevrange(key string, start, stop int64) ([]string, error) { + return cs.ZrevrangeCtx(context.Background(), key, start, stop) +} + +func (cs clusterStore) ZrevrangeCtx(ctx context.Context, key string, start, stop int64) ([]string, error) { node, err := cs.getRedis(key) if err != nil { return nil, err } - return node.Zrevrange(key, start, stop) + return node.ZrevrangeCtx(ctx, key, start, stop) } func (cs clusterStore) ZrevrangebyscoreWithScores(key string, start, stop int64) ([]redis.Pair, error) { + return cs.ZrevrangebyscoreWithScoresCtx(context.Background(), key, start, stop) +} + +func (cs clusterStore) ZrevrangebyscoreWithScoresCtx(ctx context.Context, key string, start, stop int64) ([]redis.Pair, error) { node, err := cs.getRedis(key) if err != nil { return nil, err } - return node.ZrevrangebyscoreWithScores(key, start, stop) + return node.ZrevrangebyscoreWithScoresCtx(ctx, key, start, stop) } func (cs clusterStore) ZrevrangebyscoreWithScoresAndLimit(key string, start, stop int64, page, size int) ( + []redis.Pair, error) { + return cs.ZrevrangebyscoreWithScoresAndLimitCtx(context.Background(), key, start, stop, page, size) +} + +func (cs clusterStore) ZrevrangebyscoreWithScoresAndLimitCtx(ctx context.Context, key string, start, stop int64, page, size int) ( []redis.Pair, error) { node, err := cs.getRedis(key) if err != nil { return nil, err } - return node.ZrevrangebyscoreWithScoresAndLimit(key, start, stop, page, size) + return node.ZrevrangebyscoreWithScoresAndLimitCtx(ctx, key, start, stop, page, size) } func (cs clusterStore) Zrevrank(key, field string) (int64, error) { + return cs.ZrevrankCtx(context.Background(), key, field) +} + +func (cs clusterStore) ZrevrankCtx(ctx context.Context, key, field string) (int64, error) { node, err := cs.getRedis(key) if err != nil { return 0, err } - return node.Zrevrank(key, field) + return node.ZrevrankCtx(ctx, key, field) } func (cs clusterStore) Zscore(key, value string) (int64, error) { + return cs.ZscoreCtx(context.Background(), key, value) +} + +func (cs clusterStore) ZscoreCtx(ctx context.Context, key, value string) (int64, error) { node, err := cs.getRedis(key) if err != nil { return 0, err } - return node.Zscore(key, value) + return node.ZscoreCtx(ctx, key, value) } func (cs clusterStore) getRedis(key string) (*redis.Redis, error) {