diff --git a/core/stores/redis/conf.go b/core/stores/redis/conf.go index 083a7e25..2d93723b 100644 --- a/core/stores/redis/conf.go +++ b/core/stores/redis/conf.go @@ -14,10 +14,10 @@ var ( type ( // A RedisConf is a redis config. RedisConf struct { - Host string - Type string `json:",default=node,options=node|cluster"` - Pass string `json:",optional"` - TLSFlag bool `json:",default=false,options=true|false"` + Host string + Type string `json:",default=node,options=node|cluster"` + Pass string `json:",optional"` + Tls bool `json:",default=false,options=true|false"` } // A RedisKeyConf is a redis config with key. @@ -29,10 +29,18 @@ type ( // NewRedis returns a Redis. func (rc RedisConf) NewRedis() *Redis { - if rc.TLSFlag { - return NewRedisWithTLS(rc.Host, rc.Type, rc.TLSFlag, rc.Pass) + var opts []Option + if rc.Type == ClusterType { + opts = append(opts, Cluster()) } - return NewRedis(rc.Host, rc.Type, rc.Pass) + if len(rc.Pass) > 0 { + opts = append(opts, WithPass(rc.Pass)) + } + if rc.Tls { + opts = append(opts, WithTLS()) + } + + return New(rc.Host, opts...) } // Validate validates the RedisConf. diff --git a/core/stores/redis/redis.go b/core/stores/redis/redis.go index 697cd177..f2f29a19 100644 --- a/core/stores/redis/redis.go +++ b/core/stores/redis/redis.go @@ -29,6 +29,9 @@ const ( var ErrNilNode = errors.New("nil redis node") type ( + // Option defines the method to customize a Redis. + Option func(r *Redis) + // A Pair is a key/pair set used in redis zset. Pair struct { Key string @@ -37,11 +40,11 @@ type ( // Redis defines a redis node/cluster. It is thread-safe. Redis struct { - Addr string - Type string - Pass string - brk breaker.Breaker - TLSFlag bool + Addr string + Type string + Pass string + tls bool + brk breaker.Breaker } // RedisNode interface represents a redis node. @@ -70,24 +73,32 @@ type ( FloatCmd = red.FloatCmd ) -// NewRedis returns a Redis. -func NewRedis(redisAddr, redisType string, redisPass ...string) *Redis { - return NewRedisWithTLS(redisAddr, redisType, false, redisPass...) +// New returns a Redis with given options. +func New(addr string, opts ...Option) *Redis { + r := &Redis{ + Addr: addr, + Type: NodeType, + brk: breaker.NewBreaker(), + } + + for _, opt := range opts { + opt(r) + } + + return r } -func NewRedisWithTLS(redisAddr, redisType string, tlsFlag bool, redisPass ...string) *Redis { - var pass string +// NewRedis returns a Redis. +func NewRedis(redisAddr, redisType string, redisPass ...string) *Redis { + var opts []Option + if redisType == ClusterType { + opts = append(opts, Cluster()) + } for _, v := range redisPass { - pass = v + opts = append(opts, WithPass(v)) } - return &Redis{ - Addr: redisAddr, - Type: redisType, - Pass: pass, - brk: breaker.NewBreaker(), - TLSFlag: tlsFlag, - } + return New(redisAddr, opts...) } // BitCount is redis bitcount command implementation. @@ -1703,6 +1714,27 @@ func (s *Redis) Zunionstore(dest string, store ZStore, keys ...string) (val int6 return } +// Cluster customizes the given Redis as a cluster. +func Cluster() Option { + return func(r *Redis) { + r.Type = ClusterType + } +} + +// WithPass customizes the given Redis with given password. +func WithPass(pass string) Option { + return func(r *Redis) { + r.Pass = pass + } +} + +// WithTLS customizes the given Redis with TLS enabled. +func WithTLS() Option { + return func(r *Redis) { + r.tls = true + } +} + func acceptable(err error) bool { return err == nil || err == red.Nil } @@ -1710,14 +1742,14 @@ func acceptable(err error) bool { func getRedis(r *Redis) (RedisNode, error) { switch r.Type { case ClusterType: - if r.TLSFlag { - return getClusterWithTLS(r.Addr, r.Pass, r.TLSFlag) + if r.tls { + return getClusterWithTLS(r.Addr, r.Pass, r.tls) } else { return getCluster(r.Addr, r.Pass) } case NodeType: - if r.TLSFlag { - return getClientWithTLS(r.Addr, r.Pass, r.TLSFlag) + if r.tls { + return getClientWithTLS(r.Addr, r.Pass, r.tls) } else { return getClient(r.Addr, r.Pass) } diff --git a/core/stores/redis/redis_test.go b/core/stores/redis/redis_test.go index c4950d2c..e88065df 100644 --- a/core/stores/redis/redis_test.go +++ b/core/stores/redis/redis_test.go @@ -15,8 +15,6 @@ import ( func TestRedis_Exists(t *testing.T) { runOnRedis(t, func(client *Redis) { - _, err := NewRedis(client.Addr, "").Exists("a") - assert.NotNil(t, err) ok, err := client.Exists("a") assert.Nil(t, err) assert.False(t, ok) @@ -29,7 +27,7 @@ func TestRedis_Exists(t *testing.T) { func TestRedisTLS_Exists(t *testing.T) { runOnRedisTLS(t, func(client *Redis) { - _, err := NewRedisWithTLS(client.Addr, "", true).Exists("a") + _, err := New(client.Addr, WithTLS()).Exists("a") assert.NotNil(t, err) ok, err := client.Exists("a") assert.NotNil(t, err) @@ -43,9 +41,7 @@ func TestRedisTLS_Exists(t *testing.T) { func TestRedis_Eval(t *testing.T) { runOnRedis(t, func(client *Redis) { - _, err := NewRedis(client.Addr, "").Eval(`redis.call("EXISTS", KEYS[1])`, []string{"notexist"}) - assert.NotNil(t, err) - _, err = client.Eval(`redis.call("EXISTS", KEYS[1])`, []string{"notexist"}) + _, err := client.Eval(`redis.call("EXISTS", KEYS[1])`, []string{"notexist"}) assert.Equal(t, Nil, err) err = client.Set("key1", "value1") assert.Nil(t, err) @@ -68,8 +64,6 @@ 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")) - _, err := NewRedis(client.Addr, "").Hgetall("a") - assert.NotNil(t, err) vals, err := client.Hgetall("a") assert.Nil(t, err) assert.EqualValues(t, map[string]string{ @@ -81,11 +75,8 @@ func TestRedis_Hgetall(t *testing.T) { func TestRedis_Hvals(t *testing.T) { runOnRedis(t, func(client *Redis) { - assert.NotNil(t, NewRedis(client.Addr, "").Hset("a", "aa", "aaa")) assert.Nil(t, client.Hset("a", "aa", "aaa")) assert.Nil(t, client.Hset("a", "bb", "bbb")) - _, err := NewRedis(client.Addr, "").Hvals("a") - assert.NotNil(t, err) vals, err := client.Hvals("a") assert.Nil(t, err) assert.ElementsMatch(t, []string{"aaa", "bbb"}, vals) @@ -96,8 +87,6 @@ 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")) - _, err := NewRedis(client.Addr, "").Hsetnx("a", "bb", "ccc") - assert.NotNil(t, err) ok, err := client.Hsetnx("a", "bb", "ccc") assert.Nil(t, err) assert.False(t, ok) @@ -114,8 +103,6 @@ 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")) - _, err := NewRedis(client.Addr, "").Hlen("a") - assert.NotNil(t, err) num, err := client.Hlen("a") assert.Nil(t, err) assert.Equal(t, 2, num) @@ -130,8 +117,6 @@ func TestRedis_HdelHlen(t *testing.T) { func TestRedis_HIncrBy(t *testing.T) { runOnRedis(t, func(client *Redis) { - _, err := NewRedis(client.Addr, "").Hincrby("key", "field", 2) - assert.NotNil(t, err) val, err := client.Hincrby("key", "field", 2) assert.Nil(t, err) assert.Equal(t, 2, val) @@ -145,8 +130,6 @@ 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")) - _, err := NewRedis(client.Addr, "").Hkeys("a") - assert.NotNil(t, err) vals, err := client.Hkeys("a") assert.Nil(t, err) assert.ElementsMatch(t, []string{"aa", "bb"}, vals) @@ -157,8 +140,6 @@ 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")) - _, err := NewRedis(client.Addr, "").Hmget("a", "aa", "bb") - assert.NotNil(t, err) vals, err := client.Hmget("a", "aa", "bb") assert.Nil(t, err) assert.EqualValues(t, []string{"aaa", "bbb"}, vals) @@ -194,8 +175,6 @@ func TestRedis_Hscan(t *testing.T) { var cursor uint64 = 0 sum := 0 for { - _, _, err := NewRedis(client.Addr, "").Hscan(key, cursor, "*", 100) - assert.NotNil(t, err) reMap, next, err := client.Hscan(key, cursor, "*", 100) assert.Nil(t, err) sum += len(reMap) @@ -206,8 +185,6 @@ func TestRedis_Hscan(t *testing.T) { } assert.Equal(t, sum, 3100) - _, err = NewRedis(client.Addr, "").Del(key) - assert.NotNil(t, err) _, err = client.Del(key) assert.Nil(t, err) }) @@ -215,8 +192,6 @@ func TestRedis_Hscan(t *testing.T) { func TestRedis_Incr(t *testing.T) { runOnRedis(t, func(client *Redis) { - _, err := NewRedis(client.Addr, "").Incr("a") - assert.NotNil(t, err) val, err := client.Incr("a") assert.Nil(t, err) assert.Equal(t, int64(1), val) @@ -228,8 +203,6 @@ func TestRedis_Incr(t *testing.T) { func TestRedis_IncrBy(t *testing.T) { runOnRedis(t, func(client *Redis) { - _, err := NewRedis(client.Addr, "").Incrby("a", 2) - assert.NotNil(t, err) val, err := client.Incrby("a", 2) assert.Nil(t, err) assert.Equal(t, int64(2), val) @@ -245,8 +218,6 @@ func TestRedis_Keys(t *testing.T) { assert.Nil(t, err) err = client.Set("key2", "value2") assert.Nil(t, err) - _, err = NewRedis(client.Addr, "").Keys("*") - assert.NotNil(t, err) keys, err := client.Keys("*") assert.Nil(t, err) assert.ElementsMatch(t, []string{"key1", "key2"}, keys) @@ -268,47 +239,33 @@ func TestRedis_HyperLogLog(t *testing.T) { func TestRedis_List(t *testing.T) { runOnRedis(t, func(client *Redis) { - _, err := NewRedis(client.Addr, "").Lpush("key", "value1", "value2") - assert.NotNil(t, err) val, err := client.Lpush("key", "value1", "value2") assert.Nil(t, err) assert.Equal(t, 2, val) - _, err = NewRedis(client.Addr, "").Rpush("key", "value3", "value4") - assert.NotNil(t, err) val, err = client.Rpush("key", "value3", "value4") assert.Nil(t, err) assert.Equal(t, 4, val) - _, err = NewRedis(client.Addr, "").Llen("key") - assert.NotNil(t, err) 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) - _, err = NewRedis(client.Addr, "").Lpop("key") - assert.NotNil(t, err) 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) - _, err = NewRedis(client.Addr, "").Rpop("key") - assert.NotNil(t, err) v, err = client.Rpop("key") assert.Nil(t, err) assert.Equal(t, "value4", v) val, err = client.Rpush("key", "value4", "value3", "value3") assert.Nil(t, err) assert.Equal(t, 7, val) - _, err = NewRedis(client.Addr, "").Lrem("key", 2, "value1") - assert.NotNil(t, err) n, err := client.Lrem("key", 2, "value1") assert.Nil(t, err) assert.Equal(t, 2, n) - _, err = NewRedis(client.Addr, "").Lrange("key", 0, 10) - assert.NotNil(t, err) vals, err = client.Lrange("key", 0, 10) assert.Nil(t, err) assert.EqualValues(t, []string{"value2", "value3", "value4", "value3", "value3"}, vals) @@ -327,8 +284,6 @@ func TestRedis_Mget(t *testing.T) { assert.Nil(t, err) err = client.Set("key2", "value2") assert.Nil(t, err) - _, err = NewRedis(client.Addr, "").Mget("key1", "key0", "key2", "key3") - assert.NotNil(t, err) vals, err := client.Mget("key1", "key0", "key2", "key3") assert.Nil(t, err) assert.EqualValues(t, []string{"value1", "", "value2", ""}, vals) @@ -337,10 +292,7 @@ func TestRedis_Mget(t *testing.T) { func TestRedis_SetBit(t *testing.T) { runOnRedis(t, func(client *Redis) { - err := NewRedis(client.Addr, "").SetBit("key", 1, 1) - assert.NotNil(t, err) - err = client.SetBit("key", 1, 1) - assert.Nil(t, err) + assert.Nil(t, client.SetBit("key", 1, 1)) }) } @@ -348,8 +300,6 @@ func TestRedis_GetBit(t *testing.T) { runOnRedis(t, func(client *Redis) { err := client.SetBit("key", 2, 1) assert.Nil(t, err) - _, err = NewRedis(client.Addr, "").GetBit("key", 2) - assert.NotNil(t, err) val, err := client.GetBit("key", 2) assert.Nil(t, err) assert.Equal(t, 1, val) @@ -363,8 +313,6 @@ func TestRedis_BitCount(t *testing.T) { assert.Nil(t, err) } - _, err := NewRedis(client.Addr, "").BitCount("key", 0, -1) - assert.NotNil(t, err) val, err := client.BitCount("key", 0, -1) assert.Nil(t, err) assert.Equal(t, int64(11), val) @@ -394,14 +342,11 @@ func TestRedis_BitOpAnd(t *testing.T) { assert.Nil(t, err) err = client.Set("key2", "1") assert.Nil(t, err) - _, err = NewRedis(client.Addr, "").BitOpAnd("destKey", "key1", "key2") - assert.NotNil(t, err) val, err := client.BitOpAnd("destKey", "key1", "key2") assert.Nil(t, err) assert.Equal(t, int64(1), val) valStr, err := client.Get("destKey") assert.Nil(t, err) - //destKey binary 110000 ascii 0 assert.Equal(t, "0", valStr) }) } @@ -410,8 +355,6 @@ func TestRedis_BitOpNot(t *testing.T) { runOnRedis(t, func(client *Redis) { err := client.Set("key1", "\u0000") assert.Nil(t, err) - _, err = NewRedis(client.Addr, "").BitOpNot("destKey", "key1") - assert.NotNil(t, err) val, err := client.BitOpNot("destKey", "key1") assert.Nil(t, err) assert.Equal(t, int64(1), val) @@ -427,8 +370,6 @@ func TestRedis_BitOpOr(t *testing.T) { assert.Nil(t, err) err = client.Set("key2", "0") assert.Nil(t, err) - _, err = NewRedis(client.Addr, "").BitOpOr("destKey", "key1", "key2") - assert.NotNil(t, err) val, err := client.BitOpOr("destKey", "key1", "key2") assert.Nil(t, err) assert.Equal(t, int64(1), val) @@ -444,8 +385,6 @@ func TestRedis_BitOpXor(t *testing.T) { assert.Nil(t, err) err = client.Set("key2", "\x0f") assert.Nil(t, err) - _, err = NewRedis(client.Addr, "").BitOpXor("destKey", "key1", "key2") - assert.NotNil(t, err) val, err := client.BitOpXor("destKey", "key1", "key2") assert.Nil(t, err) assert.Equal(t, int64(1), val) @@ -456,12 +395,10 @@ func TestRedis_BitOpXor(t *testing.T) { } func TestRedis_BitPos(t *testing.T) { runOnRedis(t, func(client *Redis) { - //11111111 11110000 00000000 + // 11111111 11110000 00000000 err := client.Set("key", "\xff\xf0\x00") assert.Nil(t, err) - _, err = NewRedis(client.Addr, "").BitPos("key", 0, 0, -1) - assert.NotNil(t, err) val, err := client.BitPos("key", 0, 0, 2) assert.Nil(t, err) assert.Equal(t, int64(12), val) @@ -487,8 +424,6 @@ func TestRedis_BitPos(t *testing.T) { func TestRedis_Persist(t *testing.T) { runOnRedis(t, func(client *Redis) { - _, err := NewRedis(client.Addr, "").Persist("key") - assert.NotNil(t, err) ok, err := client.Persist("key") assert.Nil(t, err) assert.False(t, ok) @@ -497,15 +432,11 @@ func TestRedis_Persist(t *testing.T) { ok, err = client.Persist("key") assert.Nil(t, err) assert.False(t, ok) - err = NewRedis(client.Addr, "").Expire("key", 5) - assert.NotNil(t, err) err = client.Expire("key", 5) assert.Nil(t, err) ok, err = client.Persist("key") assert.Nil(t, err) assert.True(t, ok) - err = NewRedis(client.Addr, "").Expireat("key", time.Now().Unix()+5) - assert.NotNil(t, err) err = client.Expireat("key", time.Now().Unix()+5) assert.Nil(t, err) ok, err = client.Persist("key") @@ -527,8 +458,6 @@ func TestRedis_Scan(t *testing.T) { assert.Nil(t, err) err = client.Set("key2", "value2") assert.Nil(t, err) - _, _, err = NewRedis(client.Addr, "").Scan(0, "*", 100) - assert.NotNil(t, err) keys, _, err := client.Scan(0, "*", 100) assert.Nil(t, err) assert.ElementsMatch(t, []string{"key1", "key2"}, keys) @@ -549,8 +478,6 @@ func TestRedis_Sscan(t *testing.T) { var cursor uint64 = 0 sum := 0 for { - _, _, err := NewRedis(client.Addr, "").Sscan(key, cursor, "", 100) - assert.NotNil(t, err) keys, next, err := client.Sscan(key, cursor, "", 100) assert.Nil(t, err) sum += len(keys) @@ -561,8 +488,6 @@ func TestRedis_Sscan(t *testing.T) { } assert.Equal(t, sum, 1550) - _, err = NewRedis(client.Addr, "").Del(key) - assert.NotNil(t, err) _, err = client.Del(key) assert.Nil(t, err) }) @@ -570,72 +495,46 @@ func TestRedis_Sscan(t *testing.T) { func TestRedis_Set(t *testing.T) { runOnRedis(t, func(client *Redis) { - _, err := NewRedis(client.Addr, "").Sadd("key", 1, 2, 3, 4) - assert.NotNil(t, err) num, err := client.Sadd("key", 1, 2, 3, 4) assert.Nil(t, err) assert.Equal(t, 4, num) - _, err = NewRedis(client.Addr, "").Scard("key") - assert.NotNil(t, err) val, err := client.Scard("key") assert.Nil(t, err) assert.Equal(t, int64(4), val) - _, err = NewRedis(client.Addr, "").Sismember("key", 2) - assert.NotNil(t, err) ok, err := client.Sismember("key", 2) assert.Nil(t, err) assert.True(t, ok) - _, err = NewRedis(client.Addr, "").Srem("key", 3, 4) - assert.NotNil(t, err) num, err = client.Srem("key", 3, 4) assert.Nil(t, err) assert.Equal(t, 2, num) - _, err = NewRedis(client.Addr, "").Smembers("key") - assert.NotNil(t, err) vals, err := client.Smembers("key") assert.Nil(t, err) assert.ElementsMatch(t, []string{"1", "2"}, vals) - _, err = NewRedis(client.Addr, "").Srandmember("key", 1) - assert.NotNil(t, err) members, err := client.Srandmember("key", 1) assert.Nil(t, err) assert.Len(t, members, 1) assert.Contains(t, []string{"1", "2"}, members[0]) - _, err = NewRedis(client.Addr, "").Spop("key") - assert.NotNil(t, err) member, err := client.Spop("key") assert.Nil(t, err) assert.Contains(t, []string{"1", "2"}, member) - _, err = NewRedis(client.Addr, "").Smembers("key") - assert.NotNil(t, err) vals, err = client.Smembers("key") assert.Nil(t, err) assert.NotContains(t, vals, member) - _, err = NewRedis(client.Addr, "").Sadd("key1", 1, 2, 3, 4) - assert.NotNil(t, err) 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) - _, err = NewRedis(client.Addr, "").Sunion("key1", "key2") - assert.NotNil(t, err) vals, err = client.Sunion("key1", "key2") assert.Nil(t, err) assert.ElementsMatch(t, []string{"1", "2", "3", "4", "5"}, vals) - _, err = NewRedis(client.Addr, "").Sunionstore("key3", "key1", "key2") - assert.NotNil(t, err) num, err = client.Sunionstore("key3", "key1", "key2") assert.Nil(t, err) assert.Equal(t, 5, num) - _, err = NewRedis(client.Addr, "").Sdiff("key1", "key2") - assert.NotNil(t, err) vals, err = client.Sdiff("key1", "key2") assert.Nil(t, err) assert.EqualValues(t, []string{"1"}, vals) - _, err = NewRedis(client.Addr, "").Sdiffstore("key4", "key1", "key2") - assert.NotNil(t, err) num, err = client.Sdiffstore("key4", "key1", "key2") assert.Nil(t, err) assert.Equal(t, 1, num) @@ -644,12 +543,8 @@ func TestRedis_Set(t *testing.T) { func TestRedis_SetGetDel(t *testing.T) { runOnRedis(t, func(client *Redis) { - err := NewRedis(client.Addr, "").Set("hello", "world") - assert.NotNil(t, err) - err = client.Set("hello", "world") + err := client.Set("hello", "world") assert.Nil(t, err) - _, err = NewRedis(client.Addr, "").Get("hello") - assert.NotNil(t, err) val, err := client.Get("hello") assert.Nil(t, err) assert.Equal(t, "world", val) @@ -661,12 +556,8 @@ func TestRedis_SetGetDel(t *testing.T) { func TestRedis_SetExNx(t *testing.T) { runOnRedis(t, func(client *Redis) { - err := NewRedis(client.Addr, "").Setex("hello", "world", 5) - assert.NotNil(t, err) - err = client.Setex("hello", "world", 5) + err := client.Setex("hello", "world", 5) assert.Nil(t, err) - _, err = NewRedis(client.Addr, "").Setnx("hello", "newworld") - assert.NotNil(t, err) ok, err := client.Setnx("hello", "newworld") assert.Nil(t, err) assert.False(t, ok) @@ -682,8 +573,6 @@ func TestRedis_SetExNx(t *testing.T) { ttl, err := client.Ttl("hello") assert.Nil(t, err) assert.True(t, ttl > 0) - _, err = NewRedis(client.Addr, "").SetnxEx("newhello", "newworld", 5) - assert.NotNil(t, err) ok, err = client.SetnxEx("newhello", "newworld", 5) assert.Nil(t, err) assert.False(t, ok) @@ -703,18 +592,12 @@ func TestRedis_SetGetDelHashField(t *testing.T) { runOnRedis(t, func(client *Redis) { err := client.Hset("key", "field", "value") assert.Nil(t, err) - _, err = NewRedis(client.Addr, "").Hget("key", "field") - assert.NotNil(t, err) val, err := client.Hget("key", "field") assert.Nil(t, err) assert.Equal(t, "value", val) - _, err = NewRedis(client.Addr, "").Hexists("key", "field") - assert.NotNil(t, err) ok, err := client.Hexists("key", "field") assert.Nil(t, err) assert.True(t, ok) - _, err = NewRedis(client.Addr, "").Hdel("key", "field") - assert.NotNil(t, err) ret, err := client.Hdel("key", "field") assert.Nil(t, err) assert.True(t, ret) @@ -735,18 +618,12 @@ func TestRedis_SortedSet(t *testing.T) { val, err := client.Zscore("key", "value1") assert.Nil(t, err) assert.Equal(t, int64(2), val) - _, err = NewRedis(client.Addr, "").Zincrby("key", 3, "value1") - assert.NotNil(t, err) val, err = client.Zincrby("key", 3, "value1") assert.Nil(t, err) assert.Equal(t, int64(5), val) - _, err = NewRedis(client.Addr, "").Zscore("key", "value1") - assert.NotNil(t, err) val, err = client.Zscore("key", "value1") assert.Nil(t, err) assert.Equal(t, int64(5), val) - _, err = NewRedis(client.Addr, "").Zadds("key") - assert.NotNil(t, err) val, err = client.Zadds("key", Pair{ Key: "value2", Score: 6, @@ -756,8 +633,6 @@ func TestRedis_SortedSet(t *testing.T) { }) assert.Nil(t, err) assert.Equal(t, int64(2), val) - _, err = NewRedis(client.Addr, "").ZRevRangeWithScores("key", 1, 3) - assert.NotNil(t, err) pairs, err := client.ZRevRangeWithScores("key", 1, 3) assert.Nil(t, err) assert.EqualValues(t, []Pair{ @@ -776,12 +651,8 @@ func TestRedis_SortedSet(t *testing.T) { rank, err = client.Zrevrank("key", "value1") assert.Nil(t, err) assert.Equal(t, int64(2), rank) - _, err = NewRedis(client.Addr, "").Zrank("key", "value4") - assert.NotNil(t, err) _, err = client.Zrank("key", "value4") assert.Equal(t, Nil, err) - _, err = NewRedis(client.Addr, "").Zrem("key", "value2", "value3") - assert.NotNil(t, err) num, err := client.Zrem("key", "value2", "value3") assert.Nil(t, err) assert.Equal(t, 2, num) @@ -794,46 +665,30 @@ func TestRedis_SortedSet(t *testing.T) { ok, err = client.Zadd("key", 8, "value4") assert.Nil(t, err) assert.True(t, ok) - _, err = NewRedis(client.Addr, "").Zremrangebyscore("key", 6, 7) - assert.NotNil(t, err) 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) - _, err = NewRedis(client.Addr, "").Zadd("key", 7, "value3") - assert.NotNil(t, err) ok, err = client.Zadd("key", 7, "value3") assert.Nil(t, err) assert.True(t, ok) - _, err = NewRedis(client.Addr, "").Zcount("key", 6, 7) - assert.NotNil(t, err) num, err = client.Zcount("key", 6, 7) assert.Nil(t, err) assert.Equal(t, 2, num) - _, err = NewRedis(client.Addr, "").Zremrangebyrank("key", 1, 2) - assert.NotNil(t, err) num, err = client.Zremrangebyrank("key", 1, 2) assert.Nil(t, err) assert.Equal(t, 2, num) - _, err = NewRedis(client.Addr, "").Zcard("key") - assert.NotNil(t, err) card, err := client.Zcard("key") assert.Nil(t, err) assert.Equal(t, 2, card) - _, err = NewRedis(client.Addr, "").Zrange("key", 0, -1) - assert.NotNil(t, err) vals, err := client.Zrange("key", 0, -1) assert.Nil(t, err) assert.EqualValues(t, []string{"value1", "value4"}, vals) - _, err = NewRedis(client.Addr, "").Zrevrange("key", 0, -1) - assert.NotNil(t, err) vals, err = client.Zrevrange("key", 0, -1) assert.Nil(t, err) assert.EqualValues(t, []string{"value4", "value1"}, vals) - _, err = NewRedis(client.Addr, "").ZrangeWithScores("key", 0, -1) - assert.NotNil(t, err) pairs, err = client.ZrangeWithScores("key", 0, -1) assert.Nil(t, err) assert.EqualValues(t, []Pair{ @@ -846,8 +701,6 @@ func TestRedis_SortedSet(t *testing.T) { Score: 8, }, }, pairs) - _, err = NewRedis(client.Addr, "").ZrangebyscoreWithScores("key", 5, 8) - assert.NotNil(t, err) pairs, err = client.ZrangebyscoreWithScores("key", 5, 8) assert.Nil(t, err) assert.EqualValues(t, []Pair{ @@ -860,9 +713,6 @@ func TestRedis_SortedSet(t *testing.T) { Score: 8, }, }, pairs) - _, err = NewRedis(client.Addr, "").ZrangebyscoreWithScoresAndLimit( - "key", 5, 8, 1, 1) - assert.NotNil(t, err) pairs, err = client.ZrangebyscoreWithScoresAndLimit("key", 5, 8, 1, 1) assert.Nil(t, err) assert.EqualValues(t, []Pair{ @@ -874,8 +724,6 @@ func TestRedis_SortedSet(t *testing.T) { pairs, err = client.ZrangebyscoreWithScoresAndLimit("key", 5, 8, 1, 0) assert.Nil(t, err) assert.Equal(t, 0, len(pairs)) - _, err = NewRedis(client.Addr, "").ZrevrangebyscoreWithScores("key", 5, 8) - assert.NotNil(t, err) pairs, err = client.ZrevrangebyscoreWithScores("key", 5, 8) assert.Nil(t, err) assert.EqualValues(t, []Pair{ @@ -888,9 +736,6 @@ func TestRedis_SortedSet(t *testing.T) { Score: 5, }, }, pairs) - _, err = NewRedis(client.Addr, "").ZrevrangebyscoreWithScoresAndLimit( - "key", 5, 8, 1, 1) - assert.NotNil(t, err) pairs, err = client.ZrevrangebyscoreWithScoresAndLimit("key", 5, 8, 1, 1) assert.Nil(t, err) assert.EqualValues(t, []Pair{ @@ -902,8 +747,6 @@ func TestRedis_SortedSet(t *testing.T) { pairs, err = client.ZrevrangebyscoreWithScoresAndLimit("key", 5, 8, 1, 0) assert.Nil(t, err) assert.Equal(t, 0, len(pairs)) - _, err = NewRedis(client.Addr, "").Zrevrank("key", "value") - assert.NotNil(t, err) client.Zadd("second", 2, "aa") client.Zadd("third", 3, "bbb") val, err = client.Zunionstore("union", ZStore{ @@ -923,9 +766,6 @@ func TestRedis_SortedSet(t *testing.T) { func TestRedis_Pipelined(t *testing.T) { runOnRedis(t, func(client *Redis) { - assert.NotNil(t, NewRedis(client.Addr, "").Pipelined(func(pipeliner Pipeliner) error { - return nil - })) err := client.Pipelined( func(pipe Pipeliner) error { pipe.Incr("pipelined_counter") @@ -935,8 +775,6 @@ func TestRedis_Pipelined(t *testing.T) { }, ) assert.Nil(t, err) - _, err = NewRedis(client.Addr, "").Ttl("pipelined_counter") - assert.NotNil(t, err) ttl, err := client.Ttl("pipelined_counter") assert.Nil(t, err) assert.Equal(t, 3600, ttl) @@ -955,16 +793,13 @@ func TestRedisString(t *testing.T) { _, err := getRedis(NewRedis(client.Addr, ClusterType)) assert.Nil(t, err) assert.Equal(t, client.Addr, client.String()) - assert.NotNil(t, NewRedis(client.Addr, "").Ping()) }) } func TestRedisScriptLoad(t *testing.T) { runOnRedis(t, func(client *Redis) { client.Ping() - _, err := NewRedis(client.Addr, "").ScriptLoad("foo") - assert.NotNil(t, err) - _, err = client.ScriptLoad("foo") + _, err := client.ScriptLoad("foo") assert.NotNil(t, err) }) } @@ -1098,7 +933,7 @@ func runOnRedisTLS(t *testing.T, fn func(client *Redis)) { client.Close() } }() - fn(NewRedisWithTLS(s.Addr(), NodeType, true)) + fn(New(s.Addr(), WithTLS())) } type mockedNode struct { diff --git a/core/stores/redis/redisclientmanager.go b/core/stores/redis/redisclientmanager.go index f5a1f718..4d18ded1 100644 --- a/core/stores/redis/redisclientmanager.go +++ b/core/stores/redis/redisclientmanager.go @@ -20,10 +20,10 @@ func getClient(server, pass string) (*red.Client, error) { return getClientWithTLS(server, pass, false) } -func getClientWithTLS(server, pass string, tlsFlag bool) (*red.Client, error) { +func getClientWithTLS(server, pass string, tlsEnabled bool) (*red.Client, error) { val, err := clientManager.GetResource(server, func() (io.Closer, error) { - var tlsConfig *tls.Config = nil - if tlsFlag { + var tlsConfig *tls.Config + if tlsEnabled { tlsConfig = &tls.Config{ InsecureSkipVerify: true, } diff --git a/core/stores/redis/redisclustermanager.go b/core/stores/redis/redisclustermanager.go index eec9e2a0..d2d5bdcd 100644 --- a/core/stores/redis/redisclustermanager.go +++ b/core/stores/redis/redisclustermanager.go @@ -14,10 +14,10 @@ func getCluster(server, pass string) (*red.ClusterClient, error) { return getClusterWithTLS(server, pass, false) } -func getClusterWithTLS(server, pass string, tlsFlag bool) (*red.ClusterClient, error) { +func getClusterWithTLS(server, pass string, tlsEnabled bool) (*red.ClusterClient, error) { val, err := clusterManager.GetResource(server, func() (io.Closer, error) { - var tlsConfig *tls.Config = nil - if tlsFlag { + var tlsConfig *tls.Config + if tlsEnabled { tlsConfig = &tls.Config{ InsecureSkipVerify: true, }