initial import

core/stores/redis/conf.go

@@ -0,0 +1,50 @@
+package redis
+
+import "errors"
+
+var (
+	ErrEmptyHost = errors.New("empty redis host")
+	ErrEmptyType = errors.New("empty redis type")
+	ErrEmptyKey  = errors.New("empty redis key")
+)
+
+type (
+	RedisConf struct {
+		Host string
+		Type string `json:",default=node,options=node|cluster"`
+		Pass string `json:",optional"`
+	}
+
+	RedisKeyConf struct {
+		RedisConf
+		Key string `json:",optional"`
+	}
+)
+
+func (rc RedisConf) NewRedis() *Redis {
+	return NewRedis(rc.Host, rc.Type, rc.Pass)
+}
+
+func (rc RedisConf) Validate() error {
+	if len(rc.Host) == 0 {
+		return ErrEmptyHost
+	}
+
+	if len(rc.Type) == 0 {
+		return ErrEmptyType
+	}
+
+	return nil
+}
+
+func (rkc RedisKeyConf) Validate() error {
+	if err := rkc.RedisConf.Validate(); err != nil {
+		return err
+	}
+
+	if len(rkc.Key) == 0 {
+		return ErrEmptyKey
+	}
+
+	return nil
+}

core/stores/redis/process.go

@@ -0,0 +1,33 @@
+package redis
+
+import (
+	"strings"
+
+	"zero/core/logx"
+	"zero/core/mapping"
+	"zero/core/timex"
+
+	red "github.com/go-redis/redis"
+)
+
+func process(proc func(red.Cmder) error) func(red.Cmder) error {
+	return func(cmd red.Cmder) error {
+		start := timex.Now()
+
+		defer func() {
+			duration := timex.Since(start)
+			if duration > slowThreshold {
+				var buf strings.Builder
+				for i, arg := range cmd.Args() {
+					if i > 0 {
+						buf.WriteByte(' ')
+					}
+					buf.WriteString(mapping.Repr(arg))
+				}
+				logx.WithDuration(duration).Slowf("[REDIS] slowcall on executing: %s", buf.String())
+			}
+		}()
+
+		return proc(cmd)
+	}
+}

core/stores/redis/redis_test.go

@@ -0,0 +1,580 @@
+package redis
+
+import (
+	"errors"
+	"io"
+	"testing"
+	"time"
+
+	"github.com/alicebob/miniredis"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestRedis_Exists(t *testing.T) {
+	runOnRedis(t, func(client *Redis) {
+		ok, err := client.Exists("a")
+		assert.Nil(t, err)
+		assert.False(t, ok)
+		assert.Nil(t, client.Set("a", "b"))
+		ok, err = client.Exists("a")
+		assert.Nil(t, err)
+		assert.True(t, ok)
+	})
+}
+
+func TestRedis_Eval(t *testing.T) {
+	runOnRedis(t, func(client *Redis) {
+		_, err := client.Eval(`redis.call("EXISTS", KEYS[1])`, []string{"notexist"})
+		assert.Equal(t, Nil, err)
+		err = client.Set("key1", "value1")
+		assert.Nil(t, err)
+		_, err = client.Eval(`redis.call("EXISTS", KEYS[1])`, []string{"key1"})
+		assert.Equal(t, Nil, err)
+		val, err := client.Eval(`return redis.call("EXISTS", KEYS[1])`, []string{"key1"})
+		assert.Nil(t, err)
+		assert.Equal(t, int64(1), val)
+	})
+}
+
+func TestRedis_Hgetall(t *testing.T) {
+	runOnRedis(t, func(client *Redis) {
+		assert.Nil(t, client.Hset("a", "aa", "aaa"))
+		assert.Nil(t, client.Hset("a", "bb", "bbb"))
+		vals, err := client.Hgetall("a")
+		assert.Nil(t, err)
+		assert.EqualValues(t, map[string]string{
+			"aa": "aaa",
+			"bb": "bbb",
+		}, vals)
+	})
+}
+
+func TestRedis_Hvals(t *testing.T) {
+	runOnRedis(t, func(client *Redis) {
+		assert.Nil(t, client.Hset("a", "aa", "aaa"))
+		assert.Nil(t, client.Hset("a", "bb", "bbb"))
+		vals, err := client.Hvals("a")
+		assert.Nil(t, err)
+		assert.ElementsMatch(t, []string{"aaa", "bbb"}, vals)
+	})
+}
+
+func TestRedis_Hsetnx(t *testing.T) {
+	runOnRedis(t, func(client *Redis) {
+		assert.Nil(t, client.Hset("a", "aa", "aaa"))
+		assert.Nil(t, client.Hset("a", "bb", "bbb"))
+		ok, err := client.Hsetnx("a", "bb", "ccc")
+		assert.Nil(t, err)
+		assert.False(t, ok)
+		ok, err = client.Hsetnx("a", "dd", "ddd")
+		assert.Nil(t, err)
+		assert.True(t, ok)
+		vals, err := client.Hvals("a")
+		assert.Nil(t, err)
+		assert.ElementsMatch(t, []string{"aaa", "bbb", "ddd"}, vals)
+	})
+}
+
+func TestRedis_HdelHlen(t *testing.T) {
+	runOnRedis(t, func(client *Redis) {
+		assert.Nil(t, client.Hset("a", "aa", "aaa"))
+		assert.Nil(t, client.Hset("a", "bb", "bbb"))
+		num, err := client.Hlen("a")
+		assert.Nil(t, err)
+		assert.Equal(t, 2, num)
+		val, err := client.Hdel("a", "aa")
+		assert.Nil(t, err)
+		assert.True(t, val)
+		vals, err := client.Hvals("a")
+		assert.Nil(t, err)
+		assert.ElementsMatch(t, []string{"bbb"}, vals)
+	})
+}
+
+func TestRedis_HIncrBy(t *testing.T) {
+	runOnRedis(t, func(client *Redis) {
+		val, err := client.Hincrby("key", "field", 2)
+		assert.Nil(t, err)
+		assert.Equal(t, 2, val)
+		val, err = client.Hincrby("key", "field", 3)
+		assert.Nil(t, err)
+		assert.Equal(t, 5, val)
+	})
+}
+
+func TestRedis_Hkeys(t *testing.T) {
+	runOnRedis(t, func(client *Redis) {
+		assert.Nil(t, client.Hset("a", "aa", "aaa"))
+		assert.Nil(t, client.Hset("a", "bb", "bbb"))
+		vals, err := client.Hkeys("a")
+		assert.Nil(t, err)
+		assert.ElementsMatch(t, []string{"aa", "bb"}, vals)
+	})
+}
+
+func TestRedis_Hmget(t *testing.T) {
+	runOnRedis(t, func(client *Redis) {
+		assert.Nil(t, client.Hset("a", "aa", "aaa"))
+		assert.Nil(t, client.Hset("a", "bb", "bbb"))
+		vals, err := client.Hmget("a", "aa", "bb")
+		assert.Nil(t, err)
+		assert.EqualValues(t, []string{"aaa", "bbb"}, vals)
+		vals, err = client.Hmget("a", "aa", "no", "bb")
+		assert.Nil(t, err)
+		assert.EqualValues(t, []string{"aaa", "", "bbb"}, vals)
+	})
+}
+
+func TestRedis_Hmset(t *testing.T) {
+	runOnRedis(t, func(client *Redis) {
+		assert.Nil(t, client.Hmset("a", map[string]string{
+			"aa": "aaa",
+			"bb": "bbb",
+		}))
+		vals, err := client.Hmget("a", "aa", "bb")
+		assert.Nil(t, err)
+		assert.EqualValues(t, []string{"aaa", "bbb"}, vals)
+	})
+}
+
+func TestRedis_Incr(t *testing.T) {
+	runOnRedis(t, func(client *Redis) {
+		val, err := client.Incr("a")
+		assert.Nil(t, err)
+		assert.Equal(t, int64(1), val)
+		val, err = client.Incr("a")
+		assert.Nil(t, err)
+		assert.Equal(t, int64(2), val)
+	})
+}
+
+func TestRedis_IncrBy(t *testing.T) {
+	runOnRedis(t, func(client *Redis) {
+		val, err := client.Incrby("a", 2)
+		assert.Nil(t, err)
+		assert.Equal(t, int64(2), val)
+		val, err = client.Incrby("a", 3)
+		assert.Nil(t, err)
+		assert.Equal(t, int64(5), val)
+	})
+}
+
+func TestRedis_Keys(t *testing.T) {
+	runOnRedis(t, func(client *Redis) {
+		err := client.Set("key1", "value1")
+		assert.Nil(t, err)
+		err = client.Set("key2", "value2")
+		assert.Nil(t, err)
+		keys, err := client.Keys("*")
+		assert.Nil(t, err)
+		assert.ElementsMatch(t, []string{"key1", "key2"}, keys)
+	})
+}
+
+func TestRedis_List(t *testing.T) {
+	runOnRedis(t, func(client *Redis) {
+		val, err := client.Lpush("key", "value1", "value2")
+		assert.Nil(t, err)
+		assert.Equal(t, 2, val)
+		val, err = client.Rpush("key", "value3", "value4")
+		assert.Nil(t, err)
+		assert.Equal(t, 4, val)
+		val, err = client.Llen("key")
+		assert.Nil(t, err)
+		assert.Equal(t, 4, val)
+		vals, err := client.Lrange("key", 0, 10)
+		assert.Nil(t, err)
+		assert.EqualValues(t, []string{"value2", "value1", "value3", "value4"}, vals)
+		v, err := client.Lpop("key")
+		assert.Nil(t, err)
+		assert.Equal(t, "value2", v)
+		val, err = client.Lpush("key", "value1", "value2")
+		assert.Nil(t, err)
+		assert.Equal(t, 5, val)
+		val, err = client.Rpush("key", "value3", "value3")
+		assert.Nil(t, err)
+		assert.Equal(t, 7, val)
+		n, err := client.Lrem("key", 2, "value1")
+		assert.Nil(t, err)
+		assert.Equal(t, 2, n)
+		vals, err = client.Lrange("key", 0, 10)
+		assert.Nil(t, err)
+		assert.EqualValues(t, []string{"value2", "value3", "value4", "value3", "value3"}, vals)
+		n, err = client.Lrem("key", -2, "value3")
+		assert.Nil(t, err)
+		assert.Equal(t, 2, n)
+		vals, err = client.Lrange("key", 0, 10)
+		assert.Nil(t, err)
+		assert.EqualValues(t, []string{"value2", "value3", "value4"}, vals)
+	})
+}
+
+func TestRedis_Mget(t *testing.T) {
+	runOnRedis(t, func(client *Redis) {
+		err := client.Set("key1", "value1")
+		assert.Nil(t, err)
+		err = client.Set("key2", "value2")
+		assert.Nil(t, err)
+		vals, err := client.Mget("key1", "key0", "key2", "key3")
+		assert.Nil(t, err)
+		assert.EqualValues(t, []string{"value1", "", "value2", ""}, vals)
+	})
+}
+
+func TestRedis_SetBit(t *testing.T) {
+	runOnRedis(t, func(client *Redis) {
+		err := client.SetBit("key", 1, 1)
+		assert.Nil(t, err)
+	})
+}
+
+func TestRedis_GetBit(t *testing.T) {
+	runOnRedis(t, func(client *Redis) {
+		err := client.SetBit("key", 2, 1)
+		assert.Nil(t, err)
+		val, err := client.GetBit("key", 2)
+		assert.Nil(t, err)
+		assert.Equal(t, 1, val)
+	})
+}
+
+func TestRedis_Persist(t *testing.T) {
+	runOnRedis(t, func(client *Redis) {
+		ok, err := client.Persist("key")
+		assert.Nil(t, err)
+		assert.False(t, ok)
+		err = client.Set("key", "value")
+		assert.Nil(t, err)
+		ok, err = client.Persist("key")
+		assert.Nil(t, err)
+		assert.False(t, ok)
+		err = client.Expire("key", 5)
+		ok, err = client.Persist("key")
+		assert.Nil(t, err)
+		assert.True(t, ok)
+		err = client.Expireat("key", time.Now().Unix()+5)
+		ok, err = client.Persist("key")
+		assert.Nil(t, err)
+		assert.True(t, ok)
+	})
+}
+
+func TestRedis_Ping(t *testing.T) {
+	runOnRedis(t, func(client *Redis) {
+		ok := client.Ping()
+		assert.True(t, ok)
+	})
+}
+
+func TestRedis_Scan(t *testing.T) {
+	runOnRedis(t, func(client *Redis) {
+		err := client.Set("key1", "value1")
+		assert.Nil(t, err)
+		err = client.Set("key2", "value2")
+		assert.Nil(t, err)
+		keys, _, err := client.Scan(0, "*", 100)
+		assert.Nil(t, err)
+		assert.ElementsMatch(t, []string{"key1", "key2"}, keys)
+	})
+}
+
+func TestRedis_Sscan(t *testing.T) {
+	runOnRedis(t, func(client *Redis) {
+		key := "list"
+		var list []string
+		for i := 0; i < 1550; i++ {
+			list = append(list, randomStr(i))
+		}
+		lens, err := client.Sadd(key, list)
+		assert.Nil(t, err)
+		assert.Equal(t, lens, 1550)
+
+		var cursor uint64 = 0
+		sum := 0
+		for {
+			keys, next, err := client.Sscan(key, cursor, "", 100)
+			assert.Nil(t, err)
+			sum += len(keys)
+			if next == 0 {
+				break
+			}
+			cursor = next
+		}
+
+		assert.Equal(t, sum, 1550)
+		_, err = client.Del(key)
+		assert.Nil(t, err)
+	})
+}
+
+func TestRedis_Set(t *testing.T) {
+	runOnRedis(t, func(client *Redis) {
+		num, err := client.Sadd("key", 1, 2, 3, 4)
+		assert.Nil(t, err)
+		assert.Equal(t, 4, num)
+		val, err := client.Scard("key")
+		assert.Nil(t, err)
+		assert.Equal(t, int64(4), val)
+		ok, err := client.Sismember("key", 2)
+		assert.Nil(t, err)
+		assert.True(t, ok)
+		num, err = client.Srem("key", 3, 4)
+		assert.Nil(t, err)
+		assert.Equal(t, 2, num)
+		vals, err := client.Smembers("key")
+		assert.Nil(t, err)
+		assert.ElementsMatch(t, []string{"1", "2"}, vals)
+		members, err := client.Srandmember("key", 1)
+		assert.Nil(t, err)
+		assert.Len(t, members, 1)
+		assert.Contains(t, []string{"1", "2"}, members[0])
+		member, err := client.Spop("key")
+		assert.Nil(t, err)
+		assert.Contains(t, []string{"1", "2"}, member)
+		vals, err = client.Smembers("key")
+		assert.Nil(t, err)
+		assert.NotContains(t, vals, member)
+		num, err = client.Sadd("key1", 1, 2, 3, 4)
+		assert.Nil(t, err)
+		assert.Equal(t, 4, num)
+		num, err = client.Sadd("key2", 2, 3, 4, 5)
+		assert.Nil(t, err)
+		assert.Equal(t, 4, num)
+		vals, err = client.Sunion("key1", "key2")
+		assert.Nil(t, err)
+		assert.ElementsMatch(t, []string{"1", "2", "3", "4", "5"}, vals)
+		num, err = client.Sunionstore("key3", "key1", "key2")
+		assert.Nil(t, err)
+		assert.Equal(t, 5, num)
+		vals, err = client.Sdiff("key1", "key2")
+		assert.Nil(t, err)
+		assert.EqualValues(t, []string{"1"}, vals)
+		num, err = client.Sdiffstore("key4", "key1", "key2")
+		assert.Nil(t, err)
+		assert.Equal(t, 1, num)
+	})
+}
+
+func TestRedis_SetGetDel(t *testing.T) {
+	runOnRedis(t, func(client *Redis) {
+		err := client.Set("hello", "world")
+		assert.Nil(t, err)
+		val, err := client.Get("hello")
+		assert.Nil(t, err)
+		assert.Equal(t, "world", val)
+		ret, err := client.Del("hello")
+		assert.Nil(t, err)
+		assert.Equal(t, 1, ret)
+	})
+}
+
+func TestRedis_SetExNx(t *testing.T) {
+	runOnRedis(t, func(client *Redis) {
+		err := client.Setex("hello", "world", 5)
+		assert.Nil(t, err)
+		ok, err := client.Setnx("hello", "newworld")
+		assert.Nil(t, err)
+		assert.False(t, ok)
+		ok, err = client.Setnx("newhello", "newworld")
+		assert.Nil(t, err)
+		assert.True(t, ok)
+		val, err := client.Get("hello")
+		assert.Nil(t, err)
+		assert.Equal(t, "world", val)
+		val, err = client.Get("newhello")
+		assert.Nil(t, err)
+		assert.Equal(t, "newworld", val)
+		ttl, err := client.Ttl("hello")
+		assert.Nil(t, err)
+		assert.True(t, ttl > 0)
+		ok, err = client.SetnxEx("newhello", "newworld", 5)
+		assert.Nil(t, err)
+		assert.False(t, ok)
+		num, err := client.Del("newhello")
+		assert.Nil(t, err)
+		assert.Equal(t, 1, num)
+		ok, err = client.SetnxEx("newhello", "newworld", 5)
+		assert.Nil(t, err)
+		assert.True(t, ok)
+		val, err = client.Get("newhello")
+		assert.Nil(t, err)
+		assert.Equal(t, "newworld", val)
+	})
+}
+
+func TestRedis_SetGetDelHashField(t *testing.T) {
+	runOnRedis(t, func(client *Redis) {
+		err := client.Hset("key", "field", "value")
+		assert.Nil(t, err)
+		val, err := client.Hget("key", "field")
+		assert.Nil(t, err)
+		assert.Equal(t, "value", val)
+		ok, err := client.Hexists("key", "field")
+		assert.Nil(t, err)
+		assert.True(t, ok)
+		ret, err := client.Hdel("key", "field")
+		assert.Nil(t, err)
+		assert.True(t, ret)
+		ok, err = client.Hexists("key", "field")
+		assert.Nil(t, err)
+		assert.False(t, ok)
+	})
+}
+
+func TestRedis_SortedSet(t *testing.T) {
+	runOnRedis(t, func(client *Redis) {
+		ok, err := client.Zadd("key", 1, "value1")
+		assert.Nil(t, err)
+		assert.True(t, ok)
+		ok, err = client.Zadd("key", 2, "value1")
+		assert.Nil(t, err)
+		assert.False(t, ok)
+		val, err := client.Zscore("key", "value1")
+		assert.Nil(t, err)
+		assert.Equal(t, int64(2), val)
+		val, err = client.Zincrby("key", 3, "value1")
+		assert.Nil(t, err)
+		assert.Equal(t, int64(5), val)
+		val, err = client.Zscore("key", "value1")
+		assert.Nil(t, err)
+		assert.Equal(t, int64(5), val)
+		ok, err = client.Zadd("key", 6, "value2")
+		assert.Nil(t, err)
+		assert.True(t, ok)
+		ok, err = client.Zadd("key", 7, "value3")
+		assert.Nil(t, err)
+		assert.True(t, ok)
+		rank, err := client.Zrank("key", "value2")
+		assert.Nil(t, err)
+		assert.Equal(t, int64(1), rank)
+		rank, err = client.Zrank("key", "value4")
+		assert.Equal(t, Nil, err)
+		num, err := client.Zrem("key", "value2", "value3")
+		assert.Nil(t, err)
+		assert.Equal(t, 2, num)
+		ok, err = client.Zadd("key", 6, "value2")
+		assert.Nil(t, err)
+		assert.True(t, ok)
+		ok, err = client.Zadd("key", 7, "value3")
+		assert.Nil(t, err)
+		assert.True(t, ok)
+		ok, err = client.Zadd("key", 8, "value4")
+		assert.Nil(t, err)
+		assert.True(t, ok)
+		num, err = client.Zremrangebyscore("key", 6, 7)
+		assert.Nil(t, err)
+		assert.Equal(t, 2, num)
+		ok, err = client.Zadd("key", 6, "value2")
+		assert.Nil(t, err)
+		assert.True(t, ok)
+		ok, err = client.Zadd("key", 7, "value3")
+		assert.Nil(t, err)
+		assert.True(t, ok)
+		num, err = client.Zcount("key", 6, 7)
+		assert.Nil(t, err)
+		assert.Equal(t, 2, num)
+		num, err = client.Zremrangebyrank("key", 1, 2)
+		assert.Nil(t, err)
+		assert.Equal(t, 2, num)
+		card, err := client.Zcard("key")
+		assert.Nil(t, err)
+		assert.Equal(t, 2, card)
+		vals, err := client.Zrange("key", 0, -1)
+		assert.Nil(t, err)
+		assert.EqualValues(t, []string{"value1", "value4"}, vals)
+		vals, err = client.Zrevrange("key", 0, -1)
+		assert.Nil(t, err)
+		assert.EqualValues(t, []string{"value4", "value1"}, vals)
+		pairs, err := client.ZrangeWithScores("key", 0, -1)
+		assert.Nil(t, err)
+		assert.EqualValues(t, []Pair{
+			{
+				Key:   "value1",
+				Score: 5,
+			},
+			{
+				Key:   "value4",
+				Score: 8,
+			},
+		}, pairs)
+		pairs, err = client.ZrangebyscoreWithScores("key", 5, 8)
+		assert.Nil(t, err)
+		assert.EqualValues(t, []Pair{
+			{
+				Key:   "value1",
+				Score: 5,
+			},
+			{
+				Key:   "value4",
+				Score: 8,
+			},
+		}, pairs)
+		pairs, err = client.ZrangebyscoreWithScoresAndLimit("key", 5, 8, 1, 1)
+		assert.Nil(t, err)
+		assert.EqualValues(t, []Pair{
+			{
+				Key:   "value4",
+				Score: 8,
+			},
+		}, pairs)
+		pairs, err = client.ZrevrangebyscoreWithScores("key", 5, 8)
+		assert.Nil(t, err)
+		assert.EqualValues(t, []Pair{
+			{
+				Key:   "value4",
+				Score: 8,
+			},
+			{
+				Key:   "value1",
+				Score: 5,
+			},
+		}, pairs)
+		pairs, err = client.ZrevrangebyscoreWithScoresAndLimit("key", 5, 8, 1, 1)
+		assert.Nil(t, err)
+		assert.EqualValues(t, []Pair{
+			{
+				Key:   "value1",
+				Score: 5,
+			},
+		}, pairs)
+	})
+}
+
+func TestRedis_Pipelined(t *testing.T) {
+	runOnRedis(t, func(client *Redis) {
+		err := client.Pipelined(
+			func(pipe Pipeliner) error {
+				pipe.Incr("pipelined_counter")
+				pipe.Expire("pipelined_counter", time.Hour)
+				pipe.ZAdd("zadd", Z{Score: 12, Member: "zadd"})
+				return nil
+			},
+		)
+		assert.Nil(t, err)
+		ttl, err := client.Ttl("pipelined_counter")
+		assert.Nil(t, err)
+		assert.Equal(t, 3600, ttl)
+		value, err := client.Get("pipelined_counter")
+		assert.Nil(t, err)
+		assert.Equal(t, "1", value)
+		score, err := client.Zscore("zadd", "zadd")
+		assert.Equal(t, int64(12), score)
+	})
+}
+
+func runOnRedis(t *testing.T, fn func(client *Redis)) {
+	s, err := miniredis.Run()
+	assert.Nil(t, err)
+	defer func() {
+		client, err := clientManager.GetResource(s.Addr(), func() (io.Closer, error) {
+			return nil, errors.New("should already exist")
+		})
+		if err != nil {
+			t.Error(err)
+		}
+
+		client.Close()
+	}()
+
+	fn(NewRedis(s.Addr(), NodeType))
+}

core/stores/redis/redisblockingnode.go

@@ -0,0 +1,66 @@
+package redis
+
+import (
+	"fmt"
+
+	"zero/core/logx"
+
+	red "github.com/go-redis/redis"
+)
+
+type ClosableNode interface {
+	RedisNode
+	Close()
+}
+
+func CreateBlockingNode(r *Redis) (ClosableNode, error) {
+	timeout := readWriteTimeout + blockingQueryTimeout
+
+	switch r.Type {
+	case NodeType:
+		client := red.NewClient(&red.Options{
+			Addr:         r.Addr,
+			Password:     r.Pass,
+			DB:           defaultDatabase,
+			MaxRetries:   maxRetries,
+			PoolSize:     1,
+			MinIdleConns: 1,
+			ReadTimeout:  timeout,
+		})
+		return &clientBridge{client}, nil
+	case ClusterType:
+		client := red.NewClusterClient(&red.ClusterOptions{
+			Addrs:        []string{r.Addr},
+			Password:     r.Pass,
+			MaxRetries:   maxRetries,
+			PoolSize:     1,
+			MinIdleConns: 1,
+			ReadTimeout:  timeout,
+		})
+		return &clusterBridge{client}, nil
+	default:
+		return nil, fmt.Errorf("unknown redis type: %s", r.Type)
+	}
+}
+
+type (
+	clientBridge struct {
+		*red.Client
+	}
+
+	clusterBridge struct {
+		*red.ClusterClient
+	}
+)
+
+func (bridge *clientBridge) Close() {
+	if err := bridge.Client.Close(); err != nil {
+		logx.Errorf("Error occurred on close redis client: %s", err)
+	}
+}
+
+func (bridge *clusterBridge) Close() {
+	if err := bridge.ClusterClient.Close(); err != nil {
+		logx.Errorf("Error occurred on close redis cluster: %s", err)
+	}
+}

core/stores/redis/redisclientmanager.go

@@ -0,0 +1,36 @@
+package redis
+
+import (
+	"io"
+
+	"zero/core/syncx"
+
+	red "github.com/go-redis/redis"
+)
+
+const (
+	defaultDatabase = 0
+	maxRetries      = 3
+	idleConns       = 8
+)
+
+var clientManager = syncx.NewResourceManager()
+
+func getClient(server, pass string) (*red.Client, error) {
+	val, err := clientManager.GetResource(server, func() (io.Closer, error) {
+		store := red.NewClient(&red.Options{
+			Addr:         server,
+			Password:     pass,
+			DB:           defaultDatabase,
+			MaxRetries:   maxRetries,
+			MinIdleConns: idleConns,
+		})
+		store.WrapProcess(process)
+		return store, nil
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return val.(*red.Client), nil
+}

core/stores/redis/redisclustermanager.go

@@ -0,0 +1,30 @@
+package redis
+
+import (
+	"io"
+
+	"zero/core/syncx"
+
+	red "github.com/go-redis/redis"
+)
+
+var clusterManager = syncx.NewResourceManager()
+
+func getCluster(server, pass string) (*red.ClusterClient, error) {
+	val, err := clusterManager.GetResource(server, func() (io.Closer, error) {
+		store := red.NewClusterClient(&red.ClusterOptions{
+			Addrs:        []string{server},
+			Password:     pass,
+			MaxRetries:   maxRetries,
+			MinIdleConns: idleConns,
+		})
+		store.WrapProcess(process)
+
+		return store, nil
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return val.(*red.ClusterClient), nil
+}

core/stores/redis/redislock.go

@@ -0,0 +1,96 @@
+package redis
+
+import (
+	"math/rand"
+	"strconv"
+	"sync/atomic"
+	"time"
+
+	"zero/core/logx"
+
+	red "github.com/go-redis/redis"
+)
+
+const (
+	letters     = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+	lockCommand = `if redis.call("GET", KEYS[1]) == ARGV[1] then
+    redis.call("SET", KEYS[1], ARGV[1], "PX", ARGV[2])
+    return "OK"
+else
+    return redis.call("SET", KEYS[1], ARGV[1], "NX", "PX", ARGV[2])
+end`
+	delCommand = `if redis.call("GET", KEYS[1]) == ARGV[1] then
+    return redis.call("DEL", KEYS[1])
+else
+    return 0
+end`
+	randomLen       = 16
+	tolerance       = 500 // milliseconds
+	millisPerSecond = 1000
+)
+
+type RedisLock struct {
+	store   *Redis
+	seconds uint32
+	key     string
+	id      string
+}
+
+func init() {
+	rand.Seed(time.Now().UnixNano())
+}
+
+func NewRedisLock(store *Redis, key string) *RedisLock {
+	return &RedisLock{
+		store: store,
+		key:   key,
+		id:    randomStr(randomLen),
+	}
+}
+
+func (rl *RedisLock) Acquire() (bool, error) {
+	seconds := atomic.LoadUint32(&rl.seconds)
+	resp, err := rl.store.Eval(lockCommand, []string{rl.key}, []string{
+		rl.id, strconv.Itoa(int(seconds)*millisPerSecond + tolerance)})
+	if err == red.Nil {
+		return false, nil
+	} else if err != nil {
+		logx.Errorf("Error on acquiring lock for %s, %s", rl.key, err.Error())
+		return false, err
+	} else if resp == nil {
+		return false, nil
+	}
+
+	reply, ok := resp.(string)
+	if ok && reply == "OK" {
+		return true, nil
+	} else {
+		logx.Errorf("Unknown reply when acquiring lock for %s: %v", rl.key, resp)
+		return false, nil
+	}
+}
+
+func (rl *RedisLock) Release() (bool, error) {
+	resp, err := rl.store.Eval(delCommand, []string{rl.key}, []string{rl.id})
+	if err != nil {
+		return false, err
+	}
+
+	if reply, ok := resp.(int64); !ok {
+		return false, nil
+	} else {
+		return reply == 1, nil
+	}
+}
+
+func (rl *RedisLock) SetExpire(seconds int) {
+	atomic.StoreUint32(&rl.seconds, uint32(seconds))
+}
+
+func randomStr(n int) string {
+	b := make([]byte, n)
+	for i := range b {
+		b[i] = letters[rand.Intn(len(letters))]
+	}
+	return string(b)
+}

core/stores/redis/redislock_test.go

@@ -0,0 +1,34 @@
+package redis
+
+import (
+	"testing"
+
+	"zero/core/stringx"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestRedisLock(t *testing.T) {
+	runOnRedis(t, func(client *Redis) {
+		key := stringx.Rand()
+		firstLock := NewRedisLock(client, key)
+		firstLock.SetExpire(5)
+		firstAcquire, err := firstLock.Acquire()
+		assert.Nil(t, err)
+		assert.True(t, firstAcquire)
+
+		secondLock := NewRedisLock(client, key)
+		secondLock.SetExpire(5)
+		againAcquire, err := secondLock.Acquire()
+		assert.Nil(t, err)
+		assert.False(t, againAcquire)
+
+		release, err := firstLock.Release()
+		assert.Nil(t, err)
+		assert.True(t, release)
+
+		endAcquire, err := secondLock.Acquire()
+		assert.Nil(t, err)
+		assert.True(t, endAcquire)
+	})
+}

core/stores/redis/scriptcache.go

@@ -0,0 +1,48 @@
+package redis
+
+import (
+	"sync"
+	"sync/atomic"
+)
+
+var (
+	once     sync.Once
+	lock     sync.Mutex
+	instance *ScriptCache
+)
+
+type (
+	Map map[string]string
+
+	ScriptCache struct {
+		atomic.Value
+	}
+)
+
+func GetScriptCache() *ScriptCache {
+	once.Do(func() {
+		instance = &ScriptCache{}
+		instance.Store(make(Map))
+	})
+
+	return instance
+}
+
+func (sc *ScriptCache) GetSha(script string) (string, bool) {
+	cache := sc.Load().(Map)
+	ret, ok := cache[script]
+	return ret, ok
+}
+
+func (sc *ScriptCache) SetSha(script, sha string) {
+	lock.Lock()
+	defer lock.Unlock()
+
+	cache := sc.Load().(Map)
+	newCache := make(Map)
+	for k, v := range cache {
+		newCache[k] = v
+	}
+	newCache[script] = sha
+	sc.Store(newCache)
+}