feat: support ctx in kv methods (#1759)

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