add reverse for v1.0.4 分佣规则Test

db/db_sys_cfg.go

@@ -2,10 +2,7 @@ package db
 
 import (
 	"code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git/db/model"
-	"code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git/md"
-	"code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git/utils/cache"
 	zhios_order_relate_logx "code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git/utils/logx"
-	"fmt"
 	"xorm.io/xorm"
 )
 
@@ -26,32 +23,3 @@ func SysCfgGetOne(Db *xorm.Engine, key string) (*model.SysCfg, error) {
 	}
 	return &cfgList, nil
 }
-
-// 多条记录获取DB
-func SysCfgFindWithDb(eg *xorm.Engine, masterId string, keys ...string) map[string]string {
-	res := map[string]string{}
-	cacheKey := fmt.Sprintf(md.AppCfgCacheKey, masterId)
-	err := cache.GetJson(cacheKey, &res)
-	if err != nil || len(res) == 0 {
-		cfgList, _ := SysCfgGetAll(eg)
-		if cfgList == nil {
-			return nil
-		}
-		for _, v := range *cfgList {
-			res[v.Key] = v.Val
-		}
-		cache.SetJson(cacheKey, res, md.CfgCacheTime)
-	}
-	if len(keys) == 0 {
-		return res
-	}
-	tmp := map[string]string{}
-	for _, v := range keys {
-		if val, ok := res[v]; ok {
-			tmp[v] = val
-		} else {
-			tmp[v] = ""
-		}
-	}
-	return tmp
-}

db/db_virtual_coin.go

@@ -2,25 +2,15 @@ package db
 
 import (
 	"code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git/db/model"
-	"code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git/md"
-	"code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git/utils/cache"
-	"fmt"
 	"xorm.io/xorm"
 )
 
 // VirtualCoinListInUse 查询正在使用中的虚拟币
 func VirtualCoinListInUse(Db *xorm.Engine, masterId string) ([]*model.VirtualCoin, error) {
 	var m []*model.VirtualCoin
-	cacheKey := fmt.Sprintf(md.VirtualCoinCfgCacheKey, masterId)
-
-	err := cache.GetJson(cacheKey, &m)
-	if err != nil || len(m) == 0 {
-		err := Db.Where("is_use=1").Find(&m)
-		if err != nil {
-			return nil, err
-		}
-		cache.SetJson(cacheKey, m, md.CfgCacheTime)
+	err := Db.Where("is_use=1").Find(&m)
+	if err != nil {
+		return nil, err
 	}
-
 	return m, nil
 }

db/dbs_plan_reward.go

@@ -4,7 +4,6 @@ import (
 	"code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git/db/model"
 	zhios_order_relate_logx "code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git/utils/logx"
 	"xorm.io/xorm"
-
 )
 
 func DbsPlanRewardByPvd(eg *xorm.Engine, pvd string) (*model.PlanReward, error) {

go.mod

@@ -3,8 +3,6 @@ module code.fnuoos.com/go_rely_warehouse/zyos_go_order_relate_rule.git
 go 1.15
 
 require (
-	github.com/go-redis/redis v6.15.9+incompatible
-	github.com/gomodule/redigo/redis v0.0.1
 	github.com/syyongx/php2go v0.9.6
 	go.uber.org/zap v1.13.0
 	golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f

rule/relate_commission.go

@@ -25,10 +25,10 @@ func BatchGetCommission(eg *xorm.Engine, dbName string, commissionParamList []*m
 
 	group, _ := errgroup.WithContext(context.Background())
 	var mu sync.Mutex
-	virCfg := db.SysCfgFindWithDb(eg, dbName, "virtual_coin_rebate_type")
+	virCfg, _ := db.SysCfgGetOne(eg, "virtual_coin_rebate_type")
 	var virType = "price"
-	if virCfg["virtual_coin_rebate_type"] != "" {
-		virType = virCfg["virtual_coin_rebate_type"]
+	if virCfg != nil && virCfg.Val != "" {
+		virType = virCfg.Val
 	}
 	for _, param := range commissionParamList {
 		param := param // 为下面的闭包创建局部变量

utils/cache/base.go

@@ -1,421 +0,0 @@
-package cache
-
-import (
-	"errors"
-	"fmt"
-	"strconv"
-	"time"
-)
-
-const (
-	redisDialTTL         = 10 * time.Second
-	redisReadTTL         = 3 * time.Second
-	redisWriteTTL        = 3 * time.Second
-	redisIdleTTL         = 10 * time.Second
-	redisPoolTTL         = 10 * time.Second
-	redisPoolSize    int = 512
-	redisMaxIdleConn int = 64
-	redisMaxActive   int = 512
-)
-
-var (
-	ErrNil          = errors.New("nil return")
-	ErrWrongArgsNum = errors.New("args num error")
-	ErrNegativeInt  = errors.New("redis cluster: unexpected value for Uint64")
-)
-
-// 以下为提供类型转换
-
-func Int(reply interface{}, err error) (int, error) {
-	if err != nil {
-		return 0, err
-	}
-	switch reply := reply.(type) {
-	case int:
-		return reply, nil
-	case int8:
-		return int(reply), nil
-	case int16:
-		return int(reply), nil
-	case int32:
-		return int(reply), nil
-	case int64:
-		x := int(reply)
-		if int64(x) != reply {
-			return 0, strconv.ErrRange
-		}
-		return x, nil
-	case uint:
-		n := int(reply)
-		if n < 0 {
-			return 0, strconv.ErrRange
-		}
-		return n, nil
-	case uint8:
-		return int(reply), nil
-	case uint16:
-		return int(reply), nil
-	case uint32:
-		n := int(reply)
-		if n < 0 {
-			return 0, strconv.ErrRange
-		}
-		return n, nil
-	case uint64:
-		n := int(reply)
-		if n < 0 {
-			return 0, strconv.ErrRange
-		}
-		return n, nil
-	case []byte:
-		data := string(reply)
-		if len(data) == 0 {
-			return 0, ErrNil
-		}
-
-		n, err := strconv.ParseInt(data, 10, 0)
-		return int(n), err
-	case string:
-		if len(reply) == 0 {
-			return 0, ErrNil
-		}
-
-		n, err := strconv.ParseInt(reply, 10, 0)
-		return int(n), err
-	case nil:
-		return 0, ErrNil
-	case error:
-		return 0, reply
-	}
-	return 0, fmt.Errorf("redis cluster: unexpected type for Int, got type %T", reply)
-}
-
-func Int64(reply interface{}, err error) (int64, error) {
-	if err != nil {
-		return 0, err
-	}
-	switch reply := reply.(type) {
-	case int:
-		return int64(reply), nil
-	case int8:
-		return int64(reply), nil
-	case int16:
-		return int64(reply), nil
-	case int32:
-		return int64(reply), nil
-	case int64:
-		return reply, nil
-	case uint:
-		n := int64(reply)
-		if n < 0 {
-			return 0, strconv.ErrRange
-		}
-		return n, nil
-	case uint8:
-		return int64(reply), nil
-	case uint16:
-		return int64(reply), nil
-	case uint32:
-		return int64(reply), nil
-	case uint64:
-		n := int64(reply)
-		if n < 0 {
-			return 0, strconv.ErrRange
-		}
-		return n, nil
-	case []byte:
-		data := string(reply)
-		if len(data) == 0 {
-			return 0, ErrNil
-		}
-
-		n, err := strconv.ParseInt(data, 10, 64)
-		return n, err
-	case string:
-		if len(reply) == 0 {
-			return 0, ErrNil
-		}
-
-		n, err := strconv.ParseInt(reply, 10, 64)
-		return n, err
-	case nil:
-		return 0, ErrNil
-	case error:
-		return 0, reply
-	}
-	return 0, fmt.Errorf("redis cluster: unexpected type for Int64, got type %T", reply)
-}
-
-func Uint64(reply interface{}, err error) (uint64, error) {
-	if err != nil {
-		return 0, err
-	}
-	switch reply := reply.(type) {
-	case uint:
-		return uint64(reply), nil
-	case uint8:
-		return uint64(reply), nil
-	case uint16:
-		return uint64(reply), nil
-	case uint32:
-		return uint64(reply), nil
-	case uint64:
-		return reply, nil
-	case int:
-		if reply < 0 {
-			return 0, ErrNegativeInt
-		}
-		return uint64(reply), nil
-	case int8:
-		if reply < 0 {
-			return 0, ErrNegativeInt
-		}
-		return uint64(reply), nil
-	case int16:
-		if reply < 0 {
-			return 0, ErrNegativeInt
-		}
-		return uint64(reply), nil
-	case int32:
-		if reply < 0 {
-			return 0, ErrNegativeInt
-		}
-		return uint64(reply), nil
-	case int64:
-		if reply < 0 {
-			return 0, ErrNegativeInt
-		}
-		return uint64(reply), nil
-	case []byte:
-		data := string(reply)
-		if len(data) == 0 {
-			return 0, ErrNil
-		}
-
-		n, err := strconv.ParseUint(data, 10, 64)
-		return n, err
-	case string:
-		if len(reply) == 0 {
-			return 0, ErrNil
-		}
-
-		n, err := strconv.ParseUint(reply, 10, 64)
-		return n, err
-	case nil:
-		return 0, ErrNil
-	case error:
-		return 0, reply
-	}
-	return 0, fmt.Errorf("redis cluster: unexpected type for Uint64, got type %T", reply)
-}
-
-func Float64(reply interface{}, err error) (float64, error) {
-	if err != nil {
-		return 0, err
-	}
-
-	var value float64
-	err = nil
-	switch v := reply.(type) {
-	case float32:
-		value = float64(v)
-	case float64:
-		value = v
-	case int:
-		value = float64(v)
-	case int8:
-		value = float64(v)
-	case int16:
-		value = float64(v)
-	case int32:
-		value = float64(v)
-	case int64:
-		value = float64(v)
-	case uint:
-		value = float64(v)
-	case uint8:
-		value = float64(v)
-	case uint16:
-		value = float64(v)
-	case uint32:
-		value = float64(v)
-	case uint64:
-		value = float64(v)
-	case []byte:
-		data := string(v)
-		if len(data) == 0 {
-			return 0, ErrNil
-		}
-		value, err = strconv.ParseFloat(string(v), 64)
-	case string:
-		if len(v) == 0 {
-			return 0, ErrNil
-		}
-		value, err = strconv.ParseFloat(v, 64)
-	case nil:
-		err = ErrNil
-	case error:
-		err = v
-	default:
-		err = fmt.Errorf("redis cluster: unexpected type for Float64, got type %T", v)
-	}
-
-	return value, err
-}
-
-func Bool(reply interface{}, err error) (bool, error) {
-	if err != nil {
-		return false, err
-	}
-	switch reply := reply.(type) {
-	case bool:
-		return reply, nil
-	case int64:
-		return reply != 0, nil
-	case []byte:
-		data := string(reply)
-		if len(data) == 0 {
-			return false, ErrNil
-		}
-
-		return strconv.ParseBool(data)
-	case string:
-		if len(reply) == 0 {
-			return false, ErrNil
-		}
-
-		return strconv.ParseBool(reply)
-	case nil:
-		return false, ErrNil
-	case error:
-		return false, reply
-	}
-	return false, fmt.Errorf("redis cluster: unexpected type for Bool, got type %T", reply)
-}
-
-func Bytes(reply interface{}, err error) ([]byte, error) {
-	if err != nil {
-		return nil, err
-	}
-	switch reply := reply.(type) {
-	case []byte:
-		if len(reply) == 0 {
-			return nil, ErrNil
-		}
-		return reply, nil
-	case string:
-		data := []byte(reply)
-		if len(data) == 0 {
-			return nil, ErrNil
-		}
-		return data, nil
-	case nil:
-		return nil, ErrNil
-	case error:
-		return nil, reply
-	}
-	return nil, fmt.Errorf("redis cluster: unexpected type for Bytes, got type %T", reply)
-}
-
-func String(reply interface{}, err error) (string, error) {
-	if err != nil {
-		return "", err
-	}
-
-	value := ""
-	err = nil
-	switch v := reply.(type) {
-	case string:
-		if len(v) == 0 {
-			return "", ErrNil
-		}
-
-		value = v
-	case []byte:
-		if len(v) == 0 {
-			return "", ErrNil
-		}
-
-		value = string(v)
-	case int:
-		value = strconv.FormatInt(int64(v), 10)
-	case int8:
-		value = strconv.FormatInt(int64(v), 10)
-	case int16:
-		value = strconv.FormatInt(int64(v), 10)
-	case int32:
-		value = strconv.FormatInt(int64(v), 10)
-	case int64:
-		value = strconv.FormatInt(v, 10)
-	case uint:
-		value = strconv.FormatUint(uint64(v), 10)
-	case uint8:
-		value = strconv.FormatUint(uint64(v), 10)
-	case uint16:
-		value = strconv.FormatUint(uint64(v), 10)
-	case uint32:
-		value = strconv.FormatUint(uint64(v), 10)
-	case uint64:
-		value = strconv.FormatUint(v, 10)
-	case float32:
-		value = strconv.FormatFloat(float64(v), 'f', -1, 32)
-	case float64:
-		value = strconv.FormatFloat(v, 'f', -1, 64)
-	case bool:
-		value = strconv.FormatBool(v)
-	case nil:
-		err = ErrNil
-	case error:
-		err = v
-	default:
-		err = fmt.Errorf("redis cluster: unexpected type for String, got type %T", v)
-	}
-
-	return value, err
-}
-
-func Strings(reply interface{}, err error) ([]string, error) {
-	if err != nil {
-		return nil, err
-	}
-	switch reply := reply.(type) {
-	case []interface{}:
-		result := make([]string, len(reply))
-		for i := range reply {
-			if reply[i] == nil {
-				continue
-			}
-			switch subReply := reply[i].(type) {
-			case string:
-				result[i] = subReply
-			case []byte:
-				result[i] = string(subReply)
-			default:
-				return nil, fmt.Errorf("redis cluster: unexpected element type for String, got type %T", reply[i])
-			}
-		}
-		return result, nil
-	case []string:
-		return reply, nil
-	case nil:
-		return nil, ErrNil
-	case error:
-		return nil, reply
-	}
-	return nil, fmt.Errorf("redis cluster: unexpected type for Strings, got type %T", reply)
-}
-
-func Values(reply interface{}, err error) ([]interface{}, error) {
-	if err != nil {
-		return nil, err
-	}
-	switch reply := reply.(type) {
-	case []interface{}:
-		return reply, nil
-	case nil:
-		return nil, ErrNil
-	case error:
-		return nil, reply
-	}
-	return nil, fmt.Errorf("redis cluster: unexpected type for Values, got type %T", reply)
-}

utils/cache/redis.go

@@ -1,403 +0,0 @@
-package cache
-
-import (
-	"encoding/json"
-	"errors"
-	"log"
-	"strings"
-	"time"
-
-	redigo "github.com/gomodule/redigo/redis"
-)
-
-// configuration
-type Config struct {
-	Server   string
-	Password string
-	MaxIdle  int // Maximum number of idle connections in the pool.
-
-	// Maximum number of connections allocated by the pool at a given time.
-	// When zero, there is no limit on the number of connections in the pool.
-	MaxActive int
-
-	// Close connections after remaining idle for this duration. If the value
-	// is zero, then idle connections are not closed. Applications should set
-	// the timeout to a value less than the server's timeout.
-	IdleTimeout time.Duration
-
-	// If Wait is true and the pool is at the MaxActive limit, then Get() waits
-	// for a connection to be returned to the pool before returning.
-	Wait           bool
-	KeyPrefix      string // prefix to all keys; example is "dev environment name"
-	KeyDelimiter   string // delimiter to be used while appending keys; example is ":"
-	KeyPlaceholder string // placeholder to be parsed using given arguments to obtain a final key; example is "?"
-}
-
-var pool *redigo.Pool
-var conf *Config
-
-func NewRedis(addr string) {
-	if addr == "" {
-		panic("\nredis connect string cannot be empty\n")
-	}
-	pool = &redigo.Pool{
-		MaxIdle:     redisMaxIdleConn,
-		IdleTimeout: redisIdleTTL,
-		MaxActive:   redisMaxActive,
-		// MaxConnLifetime: redisDialTTL,
-		Wait: true,
-		Dial: func() (redigo.Conn, error) {
-			c, err := redigo.Dial("tcp", addr,
-				redigo.DialConnectTimeout(redisDialTTL),
-				redigo.DialReadTimeout(redisReadTTL),
-				redigo.DialWriteTimeout(redisWriteTTL),
-			)
-			if err != nil {
-				log.Println("Redis Dial failed: ", err)
-				return nil, err
-			}
-			return c, err
-		},
-		TestOnBorrow: func(c redigo.Conn, t time.Time) error {
-			_, err := c.Do("PING")
-			if err != nil {
-				log.Println("Unable to ping to redis server:", err)
-			}
-			return err
-		},
-	}
-	conn := pool.Get()
-	defer conn.Close()
-	if conn.Err() != nil {
-		println("\nredis connect " + addr + " error: " + conn.Err().Error())
-	} else {
-		println("\nredis connect " + addr + " success!\n")
-	}
-}
-
-func Do(cmd string, args ...interface{}) (reply interface{}, err error) {
-	conn := pool.Get()
-	defer conn.Close()
-	return conn.Do(cmd, args...)
-}
-
-func GetPool() *redigo.Pool {
-	return pool
-}
-
-func ParseKey(key string, vars []string) (string, error) {
-	arr := strings.Split(key, conf.KeyPlaceholder)
-	actualKey := ""
-	if len(arr) != len(vars)+1 {
-		return "", errors.New("redis/connection.go: Insufficient arguments to parse key")
-	} else {
-		for index, val := range arr {
-			if index == 0 {
-				actualKey = arr[index]
-			} else {
-				actualKey += vars[index-1] + val
-			}
-		}
-	}
-	return getPrefixedKey(actualKey), nil
-}
-
-func getPrefixedKey(key string) string {
-	return conf.KeyPrefix + conf.KeyDelimiter + key
-}
-func StripEnvKey(key string) string {
-	return strings.TrimLeft(key, conf.KeyPrefix+conf.KeyDelimiter)
-}
-func SplitKey(key string) []string {
-	return strings.Split(key, conf.KeyDelimiter)
-}
-func Expire(key string, ttl int) (interface{}, error) {
-	return Do("EXPIRE", key, ttl)
-}
-func Persist(key string) (interface{}, error) {
-	return Do("PERSIST", key)
-}
-
-func Del(key string) (interface{}, error) {
-	return Do("DEL", key)
-}
-func Set(key string, data interface{}) (interface{}, error) {
-	// set
-	return Do("SET", key, data)
-}
-func SetNX(key string, data interface{}) (interface{}, error) {
-	return Do("SETNX", key, data)
-}
-func SetEx(key string, data interface{}, ttl int) (interface{}, error) {
-	return Do("SETEX", key, ttl, data)
-}
-
-func SetJson(key string, data interface{}, ttl int) bool {
-	c, err := json.Marshal(data)
-	if err != nil {
-		return false
-	}
-	if ttl < 1 {
-		_, err = Set(key, c)
-	} else {
-		_, err = SetEx(key, c, ttl)
-	}
-	if err != nil {
-		return false
-	}
-	return true
-}
-
-func GetJson(key string, dst interface{}) error {
-	b, err := GetBytes(key)
-	if err != nil {
-		return err
-	}
-	if err = json.Unmarshal(b, dst); err != nil {
-		return err
-	}
-	return nil
-}
-
-func Get(key string) (interface{}, error) {
-	// get
-	return Do("GET", key)
-}
-func GetTTL(key string) (time.Duration, error) {
-	ttl, err := redigo.Int64(Do("TTL", key))
-	return time.Duration(ttl) * time.Second, err
-}
-func GetBytes(key string) ([]byte, error) {
-	return redigo.Bytes(Do("GET", key))
-}
-func GetString(key string) (string, error) {
-	return redigo.String(Do("GET", key))
-}
-func GetStringMap(key string) (map[string]string, error) {
-	return redigo.StringMap(Do("GET", key))
-}
-func GetInt(key string) (int, error) {
-	return redigo.Int(Do("GET", key))
-}
-func GetInt64(key string) (int64, error) {
-	return redigo.Int64(Do("GET", key))
-}
-func GetStringLength(key string) (int, error) {
-	return redigo.Int(Do("STRLEN", key))
-}
-func ZAdd(key string, score float64, data interface{}) (interface{}, error) {
-	return Do("ZADD", key, score, data)
-}
-func ZAddNX(key string, score float64, data interface{}) (interface{}, error) {
-	return Do("ZADD", key, "NX", score, data)
-}
-func ZRem(key string, data interface{}) (interface{}, error) {
-	return Do("ZREM", key, data)
-}
-func ZRange(key string, start int, end int, withScores bool) ([]interface{}, error) {
-	if withScores {
-		return redigo.Values(Do("ZRANGE", key, start, end, "WITHSCORES"))
-	}
-	return redigo.Values(Do("ZRANGE", key, start, end))
-}
-func ZRemRangeByScore(key string, start int64, end int64) ([]interface{}, error) {
-	return redigo.Values(Do("ZREMRANGEBYSCORE", key, start, end))
-}
-func ZCard(setName string) (int64, error) {
-	return redigo.Int64(Do("ZCARD", setName))
-}
-func ZScan(setName string) (int64, error) {
-	return redigo.Int64(Do("ZCARD", setName))
-}
-func SAdd(setName string, data interface{}) (interface{}, error) {
-	return Do("SADD", setName, data)
-}
-func SCard(setName string) (int64, error) {
-	return redigo.Int64(Do("SCARD", setName))
-}
-func SIsMember(setName string, data interface{}) (bool, error) {
-	return redigo.Bool(Do("SISMEMBER", setName, data))
-}
-func SMembers(setName string) ([]string, error) {
-	return redigo.Strings(Do("SMEMBERS", setName))
-}
-func SRem(setName string, data interface{}) (interface{}, error) {
-	return Do("SREM", setName, data)
-}
-func HSet(key string, HKey string, data interface{}) (interface{}, error) {
-	return Do("HSET", key, HKey, data)
-}
-
-func HGet(key string, HKey string) (interface{}, error) {
-	return Do("HGET", key, HKey)
-}
-
-func HMGet(key string, hashKeys ...string) ([]interface{}, error) {
-	ret, err := Do("HMGET", key, hashKeys)
-	if err != nil {
-		return nil, err
-	}
-	reta, ok := ret.([]interface{})
-	if !ok {
-		return nil, errors.New("result not an array")
-	}
-	return reta, nil
-}
-
-func HMSet(key string, hashKeys []string, vals []interface{}) (interface{}, error) {
-	if len(hashKeys) == 0 || len(hashKeys) != len(vals) {
-		var ret interface{}
-		return ret, errors.New("bad length")
-	}
-	input := []interface{}{key}
-	for i, v := range hashKeys {
-		input = append(input, v, vals[i])
-	}
-	return Do("HMSET", input...)
-}
-
-func HGetString(key string, HKey string) (string, error) {
-	return redigo.String(Do("HGET", key, HKey))
-}
-func HGetFloat(key string, HKey string) (float64, error) {
-	f, err := redigo.Float64(Do("HGET", key, HKey))
-	return f, err
-}
-func HGetInt(key string, HKey string) (int, error) {
-	return redigo.Int(Do("HGET", key, HKey))
-}
-func HGetInt64(key string, HKey string) (int64, error) {
-	return redigo.Int64(Do("HGET", key, HKey))
-}
-func HGetBool(key string, HKey string) (bool, error) {
-	return redigo.Bool(Do("HGET", key, HKey))
-}
-func HDel(key string, HKey string) (interface{}, error) {
-	return Do("HDEL", key, HKey)
-}
-
-func HGetAll(key string) (map[string]interface{}, error) {
-	vals, err := redigo.Values(Do("HGETALL", key))
-	if err != nil {
-		return nil, err
-	}
-	num := len(vals) / 2
-	result := make(map[string]interface{}, num)
-	for i := 0; i < num; i++ {
-		key, _ := redigo.String(vals[2*i], nil)
-		result[key] = vals[2*i+1]
-	}
-	return result, nil
-}
-
-func FlushAll() bool {
-	res, _ := redigo.String(Do("FLUSHALL"))
-	if res == "" {
-		return false
-	}
-	return true
-}
-
-// NOTE: Use this in production environment with extreme care.
-// Read more here:https://redigo.io/commands/keys
-func Keys(pattern string) ([]string, error) {
-	return redigo.Strings(Do("KEYS", pattern))
-}
-
-func HKeys(key string) ([]string, error) {
-	return redigo.Strings(Do("HKEYS", key))
-}
-
-func Exists(key string) bool {
-	count, err := redigo.Int(Do("EXISTS", key))
-	if count == 0 || err != nil {
-		return false
-	}
-	return true
-}
-
-func Incr(key string) (int64, error) {
-	return redigo.Int64(Do("INCR", key))
-}
-
-func Decr(key string) (int64, error) {
-	return redigo.Int64(Do("DECR", key))
-}
-
-func IncrBy(key string, incBy int64) (int64, error) {
-	return redigo.Int64(Do("INCRBY", key, incBy))
-}
-
-func DecrBy(key string, decrBy int64) (int64, error) {
-	return redigo.Int64(Do("DECRBY", key))
-}
-
-func IncrByFloat(key string, incBy float64) (float64, error) {
-	return redigo.Float64(Do("INCRBYFLOAT", key, incBy))
-}
-
-func DecrByFloat(key string, decrBy float64) (float64, error) {
-	return redigo.Float64(Do("DECRBYFLOAT", key, decrBy))
-}
-
-// use for message queue
-func LPush(key string, data interface{}) (interface{}, error) {
-	// set
-	return Do("LPUSH", key, data)
-}
-
-func LPop(key string) (interface{}, error) {
-	return Do("LPOP", key)
-}
-
-func LPopString(key string) (string, error) {
-	return redigo.String(Do("LPOP", key))
-}
-func LPopFloat(key string) (float64, error) {
-	f, err := redigo.Float64(Do("LPOP", key))
-	return f, err
-}
-func LPopInt(key string) (int, error) {
-	return redigo.Int(Do("LPOP", key))
-}
-func LPopInt64(key string) (int64, error) {
-	return redigo.Int64(Do("LPOP", key))
-}
-
-func RPush(key string, data interface{}) (interface{}, error) {
-	// set
-	return Do("RPUSH", key, data)
-}
-
-func RPop(key string) (interface{}, error) {
-	return Do("RPOP", key)
-}
-
-func RPopString(key string) (string, error) {
-	return redigo.String(Do("RPOP", key))
-}
-func RPopFloat(key string) (float64, error) {
-	f, err := redigo.Float64(Do("RPOP", key))
-	return f, err
-}
-func RPopInt(key string) (int, error) {
-	return redigo.Int(Do("RPOP", key))
-}
-func RPopInt64(key string) (int64, error) {
-	return redigo.Int64(Do("RPOP", key))
-}
-
-func Scan(cursor int64, pattern string, count int64) (int64, []string, error) {
-	var items []string
-	var newCursor int64
-
-	values, err := redigo.Values(Do("SCAN", cursor, "MATCH", pattern, "COUNT", count))
-	if err != nil {
-		return 0, nil, err
-	}
-	values, err = redigo.Scan(values, &newCursor, &items)
-	if err != nil {
-		return 0, nil, err
-	}
-	return newCursor, items, nil
-}

utils/cache/redis_cluster.go

@@ -1,622 +0,0 @@
-package cache
-
-import (
-	"strconv"
-	"time"
-
-	"github.com/go-redis/redis"
-)
-
-var pools *redis.ClusterClient
-
-func NewRedisCluster(addrs []string) error {
-	opt := &redis.ClusterOptions{
-		Addrs:        addrs,
-		PoolSize:     redisPoolSize,
-		PoolTimeout:  redisPoolTTL,
-		IdleTimeout:  redisIdleTTL,
-		DialTimeout:  redisDialTTL,
-		ReadTimeout:  redisReadTTL,
-		WriteTimeout: redisWriteTTL,
-	}
-	pools = redis.NewClusterClient(opt)
-	if err := pools.Ping().Err(); err != nil {
-		return err
-	}
-	return nil
-}
-
-func RCGet(key string) (interface{}, error) {
-	res, err := pools.Get(key).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	return []byte(res), nil
-}
-func RCSet(key string, value interface{}) error {
-	err := pools.Set(key, value, 0).Err()
-	return convertError(err)
-}
-func RCGetSet(key string, value interface{}) (interface{}, error) {
-	res, err := pools.GetSet(key, value).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	return []byte(res), nil
-}
-func RCSetNx(key string, value interface{}) (int64, error) {
-	res, err := pools.SetNX(key, value, 0).Result()
-	if err != nil {
-		return 0, convertError(err)
-	}
-	if res {
-		return 1, nil
-	}
-	return 0, nil
-}
-func RCSetEx(key string, value interface{}, timeout int64) error {
-	_, err := pools.Set(key, value, time.Duration(timeout)*time.Second).Result()
-	if err != nil {
-		return convertError(err)
-	}
-	return nil
-}
-
-// nil表示成功，ErrNil表示数据库内已经存在这个key，其他表示数据库发生错误
-func RCSetNxEx(key string, value interface{}, timeout int64) error {
-	res, err := pools.SetNX(key, value, time.Duration(timeout)*time.Second).Result()
-	if err != nil {
-		return convertError(err)
-	}
-	if res {
-		return nil
-	}
-	return ErrNil
-}
-func RCMGet(keys ...string) ([]interface{}, error) {
-	res, err := pools.MGet(keys...).Result()
-	return res, convertError(err)
-}
-
-// 为确保多个key映射到同一个slot，每个key最好加上hash tag，如:{test}
-func RCMSet(kvs map[string]interface{}) error {
-	pairs := make([]string, 0, len(kvs)*2)
-	for k, v := range kvs {
-		val, err := String(v, nil)
-		if err != nil {
-			return err
-		}
-		pairs = append(pairs, k, val)
-	}
-	return convertError(pools.MSet(pairs).Err())
-}
-
-// 为确保多个key映射到同一个slot，每个key最好加上hash tag，如:{test}
-func RCMSetNX(kvs map[string]interface{}) (bool, error) {
-	pairs := make([]string, 0, len(kvs)*2)
-	for k, v := range kvs {
-		val, err := String(v, nil)
-		if err != nil {
-			return false, err
-		}
-		pairs = append(pairs, k, val)
-	}
-	res, err := pools.MSetNX(pairs).Result()
-	return res, convertError(err)
-}
-func RCExpireAt(key string, timestamp int64) (int64, error) {
-	res, err := pools.ExpireAt(key, time.Unix(timestamp, 0)).Result()
-	if err != nil {
-		return 0, convertError(err)
-	}
-	if res {
-		return 1, nil
-	}
-	return 0, nil
-}
-func RCDel(keys ...string) (int64, error) {
-	args := make([]interface{}, 0, len(keys))
-	for _, key := range keys {
-		args = append(args, key)
-	}
-	res, err := pools.Del(keys...).Result()
-	if err != nil {
-		return res, convertError(err)
-	}
-	return res, nil
-}
-func RCIncr(key string) (int64, error) {
-	res, err := pools.Incr(key).Result()
-	if err != nil {
-		return res, convertError(err)
-	}
-	return res, nil
-}
-func RCIncrBy(key string, delta int64) (int64, error) {
-	res, err := pools.IncrBy(key, delta).Result()
-	if err != nil {
-		return res, convertError(err)
-	}
-	return res, nil
-}
-func RCExpire(key string, duration int64) (int64, error) {
-	res, err := pools.Expire(key, time.Duration(duration)*time.Second).Result()
-	if err != nil {
-		return 0, convertError(err)
-	}
-	if res {
-		return 1, nil
-	}
-	return 0, nil
-}
-func RCExists(key string) (bool, error) {
-	res, err := pools.Exists(key).Result()
-	if err != nil {
-		return false, convertError(err)
-	}
-	if res > 0 {
-		return true, nil
-	}
-	return false, nil
-}
-func RCHGet(key string, field string) (interface{}, error) {
-	res, err := pools.HGet(key, field).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	return []byte(res), nil
-}
-func RCHLen(key string) (int64, error) {
-	res, err := pools.HLen(key).Result()
-	if err != nil {
-		return res, convertError(err)
-	}
-	return res, nil
-}
-func RCHSet(key string, field string, val interface{}) error {
-	value, err := String(val, nil)
-	if err != nil && err != ErrNil {
-		return err
-	}
-	_, err = pools.HSet(key, field, value).Result()
-	if err != nil {
-		return convertError(err)
-	}
-	return nil
-}
-func RCHDel(key string, fields ...string) (int64, error) {
-	args := make([]interface{}, 0, len(fields)+1)
-	args = append(args, key)
-	for _, field := range fields {
-		args = append(args, field)
-	}
-	res, err := pools.HDel(key, fields...).Result()
-	if err != nil {
-		return 0, convertError(err)
-	}
-	return res, nil
-}
-
-func RCHMGet(key string, fields ...string) (interface{}, error) {
-	args := make([]interface{}, 0, len(fields)+1)
-	args = append(args, key)
-	for _, field := range fields {
-		args = append(args, field)
-	}
-	if len(fields) == 0 {
-		return nil, ErrNil
-	}
-	res, err := pools.HMGet(key, fields...).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	return res, nil
-}
-func RCHMSet(key string, kvs ...interface{}) error {
-	if len(kvs) == 0 {
-		return nil
-	}
-	if len(kvs)%2 != 0 {
-		return ErrWrongArgsNum
-	}
-	var err error
-	v := map[string]interface{}{} // todo change
-	v["field"], err = String(kvs[0], nil)
-	if err != nil && err != ErrNil {
-		return err
-	}
-	v["value"], err = String(kvs[1], nil)
-	if err != nil && err != ErrNil {
-		return err
-	}
-	pairs := make([]string, 0, len(kvs)-2)
-	if len(kvs) > 2 {
-		for _, kv := range kvs[2:] {
-			kvString, err := String(kv, nil)
-			if err != nil && err != ErrNil {
-				return err
-			}
-			pairs = append(pairs, kvString)
-		}
-	}
-	v["paris"] = pairs
-	_, err = pools.HMSet(key, v).Result()
-	if err != nil {
-		return convertError(err)
-	}
-	return nil
-}
-
-func RCHKeys(key string) ([]string, error) {
-	res, err := pools.HKeys(key).Result()
-	if err != nil {
-		return res, convertError(err)
-	}
-	return res, nil
-}
-func RCHVals(key string) ([]interface{}, error) {
-	res, err := pools.HVals(key).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	rs := make([]interface{}, 0, len(res))
-	for _, res := range res {
-		rs = append(rs, res)
-	}
-	return rs, nil
-}
-func RCHGetAll(key string) (map[string]string, error) {
-	vals, err := pools.HGetAll(key).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	return vals, nil
-}
-func RCHIncrBy(key, field string, delta int64) (int64, error) {
-	res, err := pools.HIncrBy(key, field, delta).Result()
-	if err != nil {
-		return res, convertError(err)
-	}
-	return res, nil
-}
-func RCZAdd(key string, kvs ...interface{}) (int64, error) {
-	args := make([]interface{}, 0, len(kvs)+1)
-	args = append(args, key)
-	args = append(args, kvs...)
-	if len(kvs) == 0 {
-		return 0, nil
-	}
-	if len(kvs)%2 != 0 {
-		return 0, ErrWrongArgsNum
-	}
-	zs := make([]redis.Z, len(kvs)/2)
-	for i := 0; i < len(kvs); i += 2 {
-		idx := i / 2
-		score, err := Float64(kvs[i], nil)
-		if err != nil && err != ErrNil {
-			return 0, err
-		}
-		zs[idx].Score = score
-		zs[idx].Member = kvs[i+1]
-	}
-	res, err := pools.ZAdd(key, zs...).Result()
-	if err != nil {
-		return res, convertError(err)
-	}
-	return res, nil
-}
-func RCZRem(key string, members ...string) (int64, error) {
-	args := make([]interface{}, 0, len(members))
-	args = append(args, key)
-	for _, member := range members {
-		args = append(args, member)
-	}
-	res, err := pools.ZRem(key, members).Result()
-	if err != nil {
-		return res, convertError(err)
-	}
-	return res, err
-}
-
-func RCZRange(key string, min, max int64, withScores bool) (interface{}, error) {
-	res := make([]interface{}, 0)
-	if withScores {
-		zs, err := pools.ZRangeWithScores(key, min, max).Result()
-		if err != nil {
-			return nil, convertError(err)
-		}
-		for _, z := range zs {
-			res = append(res, z.Member, strconv.FormatFloat(z.Score, 'f', -1, 64))
-		}
-	} else {
-		ms, err := pools.ZRange(key, min, max).Result()
-		if err != nil {
-			return nil, convertError(err)
-		}
-		for _, m := range ms {
-			res = append(res, m)
-		}
-	}
-	return res, nil
-}
-func RCZRangeByScoreWithScore(key string, min, max int64) (map[string]int64, error) {
-	opt := new(redis.ZRangeBy)
-	opt.Min = strconv.FormatInt(int64(min), 10)
-	opt.Max = strconv.FormatInt(int64(max), 10)
-	opt.Count = -1
-	opt.Offset = 0
-	vals, err := pools.ZRangeByScoreWithScores(key, *opt).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	res := make(map[string]int64, len(vals))
-	for _, val := range vals {
-		key, err := String(val.Member, nil)
-		if err != nil && err != ErrNil {
-			return nil, err
-		}
-		res[key] = int64(val.Score)
-	}
-	return res, nil
-}
-func RCLRange(key string, start, stop int64) (interface{}, error) {
-	res, err := pools.LRange(key, start, stop).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	return res, nil
-}
-func RCLSet(key string, index int, value interface{}) error {
-	err := pools.LSet(key, int64(index), value).Err()
-	return convertError(err)
-}
-func RCLLen(key string) (int64, error) {
-	res, err := pools.LLen(key).Result()
-	if err != nil {
-		return res, convertError(err)
-	}
-	return res, nil
-}
-func RCLRem(key string, count int, value interface{}) (int, error) {
-	val, _ := value.(string)
-	res, err := pools.LRem(key, int64(count), val).Result()
-	if err != nil {
-		return int(res), convertError(err)
-	}
-	return int(res), nil
-}
-func RCTTl(key string) (int64, error) {
-	duration, err := pools.TTL(key).Result()
-	if err != nil {
-		return int64(duration.Seconds()), convertError(err)
-	}
-	return int64(duration.Seconds()), nil
-}
-func RCLPop(key string) (interface{}, error) {
-	res, err := pools.LPop(key).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	return res, nil
-}
-func RCRPop(key string) (interface{}, error) {
-	res, err := pools.RPop(key).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	return res, nil
-}
-func RCBLPop(key string, timeout int) (interface{}, error) {
-	res, err := pools.BLPop(time.Duration(timeout)*time.Second, key).Result()
-	if err != nil {
-		// 兼容redis 2.x
-		if err == redis.Nil {
-			return nil, ErrNil
-		}
-		return nil, err
-	}
-	return res[1], nil
-}
-func RCBRPop(key string, timeout int) (interface{}, error) {
-	res, err := pools.BRPop(time.Duration(timeout)*time.Second, key).Result()
-	if err != nil {
-		// 兼容redis 2.x
-		if err == redis.Nil {
-			return nil, ErrNil
-		}
-		return nil, convertError(err)
-	}
-	return res[1], nil
-}
-func RCLPush(key string, value ...interface{}) error {
-	args := make([]interface{}, 0, len(value)+1)
-	args = append(args, key)
-	args = append(args, value...)
-	vals := make([]string, 0, len(value))
-	for _, v := range value {
-		val, err := String(v, nil)
-		if err != nil && err != ErrNil {
-			return err
-		}
-		vals = append(vals, val)
-	}
-	_, err := pools.LPush(key, vals).Result() // todo ...
-	if err != nil {
-		return convertError(err)
-	}
-	return nil
-}
-func RCRPush(key string, value ...interface{}) error {
-	args := make([]interface{}, 0, len(value)+1)
-	args = append(args, key)
-	args = append(args, value...)
-	vals := make([]string, 0, len(value))
-	for _, v := range value {
-		val, err := String(v, nil)
-		if err != nil && err != ErrNil {
-			if err == ErrNil {
-				continue
-			}
-			return err
-		}
-		if val == "" {
-			continue
-		}
-		vals = append(vals, val)
-	}
-	_, err := pools.RPush(key, vals).Result() // todo ...
-	if err != nil {
-		return convertError(err)
-	}
-	return nil
-}
-
-// 为确保srcKey跟destKey映射到同一个slot，srcKey和destKey需要加上hash tag，如:{test}
-func RCBRPopLPush(srcKey string, destKey string, timeout int) (interface{}, error) {
-	res, err := pools.BRPopLPush(srcKey, destKey, time.Duration(timeout)*time.Second).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	return res, nil
-}
-
-// 为确保srcKey跟destKey映射到同一个slot，srcKey和destKey需要加上hash tag，如:{test}
-func RCRPopLPush(srcKey string, destKey string) (interface{}, error) {
-	res, err := pools.RPopLPush(srcKey, destKey).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	return res, nil
-}
-func RCSAdd(key string, members ...interface{}) (int64, error) {
-	args := make([]interface{}, 0, len(members)+1)
-	args = append(args, key)
-	args = append(args, members...)
-	ms := make([]string, 0, len(members))
-	for _, member := range members {
-		m, err := String(member, nil)
-		if err != nil && err != ErrNil {
-			return 0, err
-		}
-		ms = append(ms, m)
-	}
-	res, err := pools.SAdd(key, ms).Result() // todo ...
-	if err != nil {
-		return res, convertError(err)
-	}
-	return res, nil
-}
-func RCSPop(key string) ([]byte, error) {
-	res, err := pools.SPop(key).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	return []byte(res), nil
-}
-func RCSIsMember(key string, member interface{}) (bool, error) {
-	m, _ := member.(string)
-	res, err := pools.SIsMember(key, m).Result()
-	if err != nil {
-		return res, convertError(err)
-	}
-	return res, nil
-}
-func RCSRem(key string, members ...interface{}) (int64, error) {
-	args := make([]interface{}, 0, len(members)+1)
-	args = append(args, key)
-	args = append(args, members...)
-	ms := make([]string, 0, len(members))
-	for _, member := range members {
-		m, err := String(member, nil)
-		if err != nil && err != ErrNil {
-			return 0, err
-		}
-		ms = append(ms, m)
-	}
-	res, err := pools.SRem(key, ms).Result() // todo ...
-	if err != nil {
-		return res, convertError(err)
-	}
-	return res, nil
-}
-func RCSMembers(key string) ([]string, error) {
-	res, err := pools.SMembers(key).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	return res, nil
-}
-func RCScriptLoad(luaScript string) (interface{}, error) {
-	res, err := pools.ScriptLoad(luaScript).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	return res, nil
-}
-func RCEvalSha(sha1 string, numberKeys int, keysArgs ...interface{}) (interface{}, error) {
-	vals := make([]interface{}, 0, len(keysArgs)+2)
-	vals = append(vals, sha1, numberKeys)
-	vals = append(vals, keysArgs...)
-	keys := make([]string, 0, numberKeys)
-	args := make([]string, 0, len(keysArgs)-numberKeys)
-	for i, value := range keysArgs {
-		val, err := String(value, nil)
-		if err != nil && err != ErrNil {
-			return nil, err
-		}
-		if i < numberKeys {
-			keys = append(keys, val)
-		} else {
-			args = append(args, val)
-		}
-	}
-	res, err := pools.EvalSha(sha1, keys, args).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	return res, nil
-}
-func RCEval(luaScript string, numberKeys int, keysArgs ...interface{}) (interface{}, error) {
-	vals := make([]interface{}, 0, len(keysArgs)+2)
-	vals = append(vals, luaScript, numberKeys)
-	vals = append(vals, keysArgs...)
-	keys := make([]string, 0, numberKeys)
-	args := make([]string, 0, len(keysArgs)-numberKeys)
-	for i, value := range keysArgs {
-		val, err := String(value, nil)
-		if err != nil && err != ErrNil {
-			return nil, err
-		}
-		if i < numberKeys {
-			keys = append(keys, val)
-		} else {
-			args = append(args, val)
-		}
-	}
-	res, err := pools.Eval(luaScript, keys, args).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	return res, nil
-}
-func RCGetBit(key string, offset int64) (int64, error) {
-	res, err := pools.GetBit(key, offset).Result()
-	if err != nil {
-		return res, convertError(err)
-	}
-	return res, nil
-}
-func RCSetBit(key string, offset uint32, value int) (int, error) {
-	res, err := pools.SetBit(key, int64(offset), value).Result()
-	return int(res), convertError(err)
-}
-func RCGetClient() *redis.ClusterClient {
-	return pools
-}
-func convertError(err error) error {
-	if err == redis.Nil {
-		// 为了兼容redis 2.x,这里不返回 ErrNil，ErrNil在调用redis_cluster_reply函数时才返回
-		return nil
-	}
-	return err
-}

utils/cache/redis_pool.go

@@ -1,324 +0,0 @@
-package cache
-
-import (
-	"errors"
-	"log"
-	"strings"
-	"time"
-
-	redigo "github.com/gomodule/redigo/redis"
-)
-
-type RedisPool struct {
-	*redigo.Pool
-}
-
-func NewRedisPool(cfg *Config) *RedisPool {
-	return &RedisPool{&redigo.Pool{
-		MaxIdle:     cfg.MaxIdle,
-		IdleTimeout: cfg.IdleTimeout,
-		MaxActive:   cfg.MaxActive,
-		Wait:        cfg.Wait,
-		Dial: func() (redigo.Conn, error) {
-			c, err := redigo.Dial("tcp", cfg.Server)
-			if err != nil {
-				log.Println("Redis Dial failed: ", err)
-				return nil, err
-			}
-			if cfg.Password != "" {
-				if _, err := c.Do("AUTH", cfg.Password); err != nil {
-					c.Close()
-					log.Println("Redis AUTH failed: ", err)
-					return nil, err
-				}
-			}
-			return c, err
-		},
-		TestOnBorrow: func(c redigo.Conn, t time.Time) error {
-			_, err := c.Do("PING")
-			if err != nil {
-				log.Println("Unable to ping to redis server:", err)
-			}
-			return err
-		},
-	}}
-}
-
-func (p *RedisPool) Do(cmd string, args ...interface{}) (reply interface{}, err error) {
-	conn := pool.Get()
-	defer conn.Close()
-	return conn.Do(cmd, args...)
-}
-
-func (p *RedisPool) GetPool() *redigo.Pool {
-	return pool
-}
-
-func (p *RedisPool) ParseKey(key string, vars []string) (string, error) {
-	arr := strings.Split(key, conf.KeyPlaceholder)
-	actualKey := ""
-	if len(arr) != len(vars)+1 {
-		return "", errors.New("redis/connection.go: Insufficient arguments to parse key")
-	} else {
-		for index, val := range arr {
-			if index == 0 {
-				actualKey = arr[index]
-			} else {
-				actualKey += vars[index-1] + val
-			}
-		}
-	}
-	return getPrefixedKey(actualKey), nil
-}
-
-func (p *RedisPool) getPrefixedKey(key string) string {
-	return conf.KeyPrefix + conf.KeyDelimiter + key
-}
-func (p *RedisPool) StripEnvKey(key string) string {
-	return strings.TrimLeft(key, conf.KeyPrefix+conf.KeyDelimiter)
-}
-func (p *RedisPool) SplitKey(key string) []string {
-	return strings.Split(key, conf.KeyDelimiter)
-}
-func (p *RedisPool) Expire(key string, ttl int) (interface{}, error) {
-	return Do("EXPIRE", key, ttl)
-}
-func (p *RedisPool) Persist(key string) (interface{}, error) {
-	return Do("PERSIST", key)
-}
-
-func (p *RedisPool) Del(key string) (interface{}, error) {
-	return Do("DEL", key)
-}
-func (p *RedisPool) Set(key string, data interface{}) (interface{}, error) {
-	// set
-	return Do("SET", key, data)
-}
-func (p *RedisPool) SetNX(key string, data interface{}) (interface{}, error) {
-	return Do("SETNX", key, data)
-}
-func (p *RedisPool) SetEx(key string, data interface{}, ttl int) (interface{}, error) {
-	return Do("SETEX", key, ttl, data)
-}
-func (p *RedisPool) Get(key string) (interface{}, error) {
-	// get
-	return Do("GET", key)
-}
-func (p *RedisPool) GetStringMap(key string) (map[string]string, error) {
-	// get
-	return redigo.StringMap(Do("GET", key))
-}
-
-func (p *RedisPool) GetTTL(key string) (time.Duration, error) {
-	ttl, err := redigo.Int64(Do("TTL", key))
-	return time.Duration(ttl) * time.Second, err
-}
-func (p *RedisPool) GetBytes(key string) ([]byte, error) {
-	return redigo.Bytes(Do("GET", key))
-}
-func (p *RedisPool) GetString(key string) (string, error) {
-	return redigo.String(Do("GET", key))
-}
-func (p *RedisPool) GetInt(key string) (int, error) {
-	return redigo.Int(Do("GET", key))
-}
-func (p *RedisPool) GetStringLength(key string) (int, error) {
-	return redigo.Int(Do("STRLEN", key))
-}
-func (p *RedisPool) ZAdd(key string, score float64, data interface{}) (interface{}, error) {
-	return Do("ZADD", key, score, data)
-}
-func (p *RedisPool) ZRem(key string, data interface{}) (interface{}, error) {
-	return Do("ZREM", key, data)
-}
-func (p *RedisPool) ZRange(key string, start int, end int, withScores bool) ([]interface{}, error) {
-	if withScores {
-		return redigo.Values(Do("ZRANGE", key, start, end, "WITHSCORES"))
-	}
-	return redigo.Values(Do("ZRANGE", key, start, end))
-}
-func (p *RedisPool) SAdd(setName string, data interface{}) (interface{}, error) {
-	return Do("SADD", setName, data)
-}
-func (p *RedisPool) SCard(setName string) (int64, error) {
-	return redigo.Int64(Do("SCARD", setName))
-}
-func (p *RedisPool) SIsMember(setName string, data interface{}) (bool, error) {
-	return redigo.Bool(Do("SISMEMBER", setName, data))
-}
-func (p *RedisPool) SMembers(setName string) ([]string, error) {
-	return redigo.Strings(Do("SMEMBERS", setName))
-}
-func (p *RedisPool) SRem(setName string, data interface{}) (interface{}, error) {
-	return Do("SREM", setName, data)
-}
-func (p *RedisPool) HSet(key string, HKey string, data interface{}) (interface{}, error) {
-	return Do("HSET", key, HKey, data)
-}
-
-func (p *RedisPool) HGet(key string, HKey string) (interface{}, error) {
-	return Do("HGET", key, HKey)
-}
-
-func (p *RedisPool) HMGet(key string, hashKeys ...string) ([]interface{}, error) {
-	ret, err := Do("HMGET", key, hashKeys)
-	if err != nil {
-		return nil, err
-	}
-	reta, ok := ret.([]interface{})
-	if !ok {
-		return nil, errors.New("result not an array")
-	}
-	return reta, nil
-}
-
-func (p *RedisPool) HMSet(key string, hashKeys []string, vals []interface{}) (interface{}, error) {
-	if len(hashKeys) == 0 || len(hashKeys) != len(vals) {
-		var ret interface{}
-		return ret, errors.New("bad length")
-	}
-	input := []interface{}{key}
-	for i, v := range hashKeys {
-		input = append(input, v, vals[i])
-	}
-	return Do("HMSET", input...)
-}
-
-func (p *RedisPool) HGetString(key string, HKey string) (string, error) {
-	return redigo.String(Do("HGET", key, HKey))
-}
-func (p *RedisPool) HGetFloat(key string, HKey string) (float64, error) {
-	f, err := redigo.Float64(Do("HGET", key, HKey))
-	return float64(f), err
-}
-func (p *RedisPool) HGetInt(key string, HKey string) (int, error) {
-	return redigo.Int(Do("HGET", key, HKey))
-}
-func (p *RedisPool) HGetInt64(key string, HKey string) (int64, error) {
-	return redigo.Int64(Do("HGET", key, HKey))
-}
-func (p *RedisPool) HGetBool(key string, HKey string) (bool, error) {
-	return redigo.Bool(Do("HGET", key, HKey))
-}
-func (p *RedisPool) HDel(key string, HKey string) (interface{}, error) {
-	return Do("HDEL", key, HKey)
-}
-func (p *RedisPool) HGetAll(key string) (map[string]interface{}, error) {
-	vals, err := redigo.Values(Do("HGETALL", key))
-	if err != nil {
-		return nil, err
-	}
-	num := len(vals) / 2
-	result := make(map[string]interface{}, num)
-	for i := 0; i < num; i++ {
-		key, _ := redigo.String(vals[2*i], nil)
-		result[key] = vals[2*i+1]
-	}
-	return result, nil
-}
-
-// NOTE: Use this in production environment with extreme care.
-// Read more here:https://redigo.io/commands/keys
-func (p *RedisPool) Keys(pattern string) ([]string, error) {
-	return redigo.Strings(Do("KEYS", pattern))
-}
-
-func (p *RedisPool) HKeys(key string) ([]string, error) {
-	return redigo.Strings(Do("HKEYS", key))
-}
-
-func (p *RedisPool) Exists(key string) (bool, error) {
-	count, err := redigo.Int(Do("EXISTS", key))
-	if count == 0 {
-		return false, err
-	} else {
-		return true, err
-	}
-}
-
-func (p *RedisPool) Incr(key string) (int64, error) {
-	return redigo.Int64(Do("INCR", key))
-}
-
-func (p *RedisPool) Decr(key string) (int64, error) {
-	return redigo.Int64(Do("DECR", key))
-}
-
-func (p *RedisPool) IncrBy(key string, incBy int64) (int64, error) {
-	return redigo.Int64(Do("INCRBY", key, incBy))
-}
-
-func (p *RedisPool) DecrBy(key string, decrBy int64) (int64, error) {
-	return redigo.Int64(Do("DECRBY", key))
-}
-
-func (p *RedisPool) IncrByFloat(key string, incBy float64) (float64, error) {
-	return redigo.Float64(Do("INCRBYFLOAT", key, incBy))
-}
-
-func (p *RedisPool) DecrByFloat(key string, decrBy float64) (float64, error) {
-	return redigo.Float64(Do("DECRBYFLOAT", key, decrBy))
-}
-
-// use for message queue
-func (p *RedisPool) LPush(key string, data interface{}) (interface{}, error) {
-	// set
-	return Do("LPUSH", key, data)
-}
-
-func (p *RedisPool) LPop(key string) (interface{}, error) {
-	return Do("LPOP", key)
-}
-
-func (p *RedisPool) LPopString(key string) (string, error) {
-	return redigo.String(Do("LPOP", key))
-}
-func (p *RedisPool) LPopFloat(key string) (float64, error) {
-	f, err := redigo.Float64(Do("LPOP", key))
-	return float64(f), err
-}
-func (p *RedisPool) LPopInt(key string) (int, error) {
-	return redigo.Int(Do("LPOP", key))
-}
-func (p *RedisPool) LPopInt64(key string) (int64, error) {
-	return redigo.Int64(Do("LPOP", key))
-}
-
-func (p *RedisPool) RPush(key string, data interface{}) (interface{}, error) {
-	// set
-	return Do("RPUSH", key, data)
-}
-
-func (p *RedisPool) RPop(key string) (interface{}, error) {
-	return Do("RPOP", key)
-}
-
-func (p *RedisPool) RPopString(key string) (string, error) {
-	return redigo.String(Do("RPOP", key))
-}
-func (p *RedisPool) RPopFloat(key string) (float64, error) {
-	f, err := redigo.Float64(Do("RPOP", key))
-	return float64(f), err
-}
-func (p *RedisPool) RPopInt(key string) (int, error) {
-	return redigo.Int(Do("RPOP", key))
-}
-func (p *RedisPool) RPopInt64(key string) (int64, error) {
-	return redigo.Int64(Do("RPOP", key))
-}
-
-func (p *RedisPool) Scan(cursor int64, pattern string, count int64) (int64, []string, error) {
-	var items []string
-	var newCursor int64
-
-	values, err := redigo.Values(Do("SCAN", cursor, "MATCH", pattern, "COUNT", count))
-	if err != nil {
-		return 0, nil, err
-	}
-	values, err = redigo.Scan(values, &newCursor, &items)
-	if err != nil {
-		return 0, nil, err
-	}
-
-	return newCursor, items, nil
-}

utils/cache/redis_pool_cluster.go

@@ -1,617 +0,0 @@
-package cache
-
-import (
-	"strconv"
-	"time"
-
-	"github.com/go-redis/redis"
-)
-
-type RedisClusterPool struct {
-	client *redis.ClusterClient
-}
-
-func NewRedisClusterPool(addrs []string) (*RedisClusterPool, error) {
-	opt := &redis.ClusterOptions{
-		Addrs:        addrs,
-		PoolSize:     512,
-		PoolTimeout:  10 * time.Second,
-		IdleTimeout:  10 * time.Second,
-		DialTimeout:  10 * time.Second,
-		ReadTimeout:  3 * time.Second,
-		WriteTimeout: 3 * time.Second,
-	}
-	c := redis.NewClusterClient(opt)
-	if err := c.Ping().Err(); err != nil {
-		return nil, err
-	}
-	return &RedisClusterPool{client: c}, nil
-}
-
-func (p *RedisClusterPool) Get(key string) (interface{}, error) {
-	res, err := p.client.Get(key).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	return []byte(res), nil
-}
-func (p *RedisClusterPool) Set(key string, value interface{}) error {
-	err := p.client.Set(key, value, 0).Err()
-	return convertError(err)
-}
-func (p *RedisClusterPool) GetSet(key string, value interface{}) (interface{}, error) {
-	res, err := p.client.GetSet(key, value).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	return []byte(res), nil
-}
-func (p *RedisClusterPool) SetNx(key string, value interface{}) (int64, error) {
-	res, err := p.client.SetNX(key, value, 0).Result()
-	if err != nil {
-		return 0, convertError(err)
-	}
-	if res {
-		return 1, nil
-	}
-	return 0, nil
-}
-func (p *RedisClusterPool) SetEx(key string, value interface{}, timeout int64) error {
-	_, err := p.client.Set(key, value, time.Duration(timeout)*time.Second).Result()
-	if err != nil {
-		return convertError(err)
-	}
-	return nil
-}
-
-// nil表示成功，ErrNil表示数据库内已经存在这个key，其他表示数据库发生错误
-func (p *RedisClusterPool) SetNxEx(key string, value interface{}, timeout int64) error {
-	res, err := p.client.SetNX(key, value, time.Duration(timeout)*time.Second).Result()
-	if err != nil {
-		return convertError(err)
-	}
-	if res {
-		return nil
-	}
-	return ErrNil
-}
-func (p *RedisClusterPool) MGet(keys ...string) ([]interface{}, error) {
-	res, err := p.client.MGet(keys...).Result()
-	return res, convertError(err)
-}
-
-// 为确保多个key映射到同一个slot，每个key最好加上hash tag，如:{test}
-func (p *RedisClusterPool) MSet(kvs map[string]interface{}) error {
-	pairs := make([]string, 0, len(kvs)*2)
-	for k, v := range kvs {
-		val, err := String(v, nil)
-		if err != nil {
-			return err
-		}
-		pairs = append(pairs, k, val)
-	}
-	return convertError(p.client.MSet(pairs).Err())
-}
-
-// 为确保多个key映射到同一个slot，每个key最好加上hash tag，如:{test}
-func (p *RedisClusterPool) MSetNX(kvs map[string]interface{}) (bool, error) {
-	pairs := make([]string, 0, len(kvs)*2)
-	for k, v := range kvs {
-		val, err := String(v, nil)
-		if err != nil {
-			return false, err
-		}
-		pairs = append(pairs, k, val)
-	}
-	res, err := p.client.MSetNX(pairs).Result()
-	return res, convertError(err)
-}
-func (p *RedisClusterPool) ExpireAt(key string, timestamp int64) (int64, error) {
-	res, err := p.client.ExpireAt(key, time.Unix(timestamp, 0)).Result()
-	if err != nil {
-		return 0, convertError(err)
-	}
-	if res {
-		return 1, nil
-	}
-	return 0, nil
-}
-func (p *RedisClusterPool) Del(keys ...string) (int64, error) {
-	args := make([]interface{}, 0, len(keys))
-	for _, key := range keys {
-		args = append(args, key)
-	}
-	res, err := p.client.Del(keys...).Result()
-	if err != nil {
-		return res, convertError(err)
-	}
-	return res, nil
-}
-func (p *RedisClusterPool) Incr(key string) (int64, error) {
-	res, err := p.client.Incr(key).Result()
-	if err != nil {
-		return res, convertError(err)
-	}
-	return res, nil
-}
-func (p *RedisClusterPool) IncrBy(key string, delta int64) (int64, error) {
-	res, err := p.client.IncrBy(key, delta).Result()
-	if err != nil {
-		return res, convertError(err)
-	}
-	return res, nil
-}
-func (p *RedisClusterPool) Expire(key string, duration int64) (int64, error) {
-	res, err := p.client.Expire(key, time.Duration(duration)*time.Second).Result()
-	if err != nil {
-		return 0, convertError(err)
-	}
-	if res {
-		return 1, nil
-	}
-	return 0, nil
-}
-func (p *RedisClusterPool) Exists(key string) (bool, error) { // todo (bool, error)
-	res, err := p.client.Exists(key).Result()
-	if err != nil {
-		return false, convertError(err)
-	}
-	if res > 0 {
-		return true, nil
-	}
-	return false, nil
-}
-func (p *RedisClusterPool) HGet(key string, field string) (interface{}, error) {
-	res, err := p.client.HGet(key, field).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	return []byte(res), nil
-}
-func (p *RedisClusterPool) HLen(key string) (int64, error) {
-	res, err := p.client.HLen(key).Result()
-	if err != nil {
-		return res, convertError(err)
-	}
-	return res, nil
-}
-func (p *RedisClusterPool) HSet(key string, field string, val interface{}) error {
-	value, err := String(val, nil)
-	if err != nil && err != ErrNil {
-		return err
-	}
-	_, err = p.client.HSet(key, field, value).Result()
-	if err != nil {
-		return convertError(err)
-	}
-	return nil
-}
-func (p *RedisClusterPool) HDel(key string, fields ...string) (int64, error) {
-	args := make([]interface{}, 0, len(fields)+1)
-	args = append(args, key)
-	for _, field := range fields {
-		args = append(args, field)
-	}
-	res, err := p.client.HDel(key, fields...).Result()
-	if err != nil {
-		return 0, convertError(err)
-	}
-	return res, nil
-}
-
-func (p *RedisClusterPool) HMGet(key string, fields ...string) (interface{}, error) {
-	args := make([]interface{}, 0, len(fields)+1)
-	args = append(args, key)
-	for _, field := range fields {
-		args = append(args, field)
-	}
-	if len(fields) == 0 {
-		return nil, ErrNil
-	}
-	res, err := p.client.HMGet(key, fields...).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	return res, nil
-}
-func (p *RedisClusterPool) HMSet(key string, kvs ...interface{}) error {
-	if len(kvs) == 0 {
-		return nil
-	}
-	if len(kvs)%2 != 0 {
-		return ErrWrongArgsNum
-	}
-	var err error
-	v := map[string]interface{}{} // todo change
-	v["field"], err = String(kvs[0], nil)
-	if err != nil && err != ErrNil {
-		return err
-	}
-	v["value"], err = String(kvs[1], nil)
-	if err != nil && err != ErrNil {
-		return err
-	}
-	pairs := make([]string, 0, len(kvs)-2)
-	if len(kvs) > 2 {
-		for _, kv := range kvs[2:] {
-			kvString, err := String(kv, nil)
-			if err != nil && err != ErrNil {
-				return err
-			}
-			pairs = append(pairs, kvString)
-		}
-	}
-	v["paris"] = pairs
-	_, err = p.client.HMSet(key, v).Result()
-	if err != nil {
-		return convertError(err)
-	}
-	return nil
-}
-
-func (p *RedisClusterPool) HKeys(key string) ([]string, error) {
-	res, err := p.client.HKeys(key).Result()
-	if err != nil {
-		return res, convertError(err)
-	}
-	return res, nil
-}
-func (p *RedisClusterPool) HVals(key string) ([]interface{}, error) {
-	res, err := p.client.HVals(key).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	rs := make([]interface{}, 0, len(res))
-	for _, res := range res {
-		rs = append(rs, res)
-	}
-	return rs, nil
-}
-func (p *RedisClusterPool) HGetAll(key string) (map[string]string, error) {
-	vals, err := p.client.HGetAll(key).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	return vals, nil
-}
-func (p *RedisClusterPool) HIncrBy(key, field string, delta int64) (int64, error) {
-	res, err := p.client.HIncrBy(key, field, delta).Result()
-	if err != nil {
-		return res, convertError(err)
-	}
-	return res, nil
-}
-func (p *RedisClusterPool) ZAdd(key string, kvs ...interface{}) (int64, error) {
-	args := make([]interface{}, 0, len(kvs)+1)
-	args = append(args, key)
-	args = append(args, kvs...)
-	if len(kvs) == 0 {
-		return 0, nil
-	}
-	if len(kvs)%2 != 0 {
-		return 0, ErrWrongArgsNum
-	}
-	zs := make([]redis.Z, len(kvs)/2)
-	for i := 0; i < len(kvs); i += 2 {
-		idx := i / 2
-		score, err := Float64(kvs[i], nil)
-		if err != nil && err != ErrNil {
-			return 0, err
-		}
-		zs[idx].Score = score
-		zs[idx].Member = kvs[i+1]
-	}
-	res, err := p.client.ZAdd(key, zs...).Result()
-	if err != nil {
-		return res, convertError(err)
-	}
-	return res, nil
-}
-func (p *RedisClusterPool) ZRem(key string, members ...string) (int64, error) {
-	args := make([]interface{}, 0, len(members))
-	args = append(args, key)
-	for _, member := range members {
-		args = append(args, member)
-	}
-	res, err := p.client.ZRem(key, members).Result()
-	if err != nil {
-		return res, convertError(err)
-	}
-	return res, err
-}
-
-func (p *RedisClusterPool) ZRange(key string, min, max int64, withScores bool) (interface{}, error) {
-	res := make([]interface{}, 0)
-	if withScores {
-		zs, err := p.client.ZRangeWithScores(key, min, max).Result()
-		if err != nil {
-			return nil, convertError(err)
-		}
-		for _, z := range zs {
-			res = append(res, z.Member, strconv.FormatFloat(z.Score, 'f', -1, 64))
-		}
-	} else {
-		ms, err := p.client.ZRange(key, min, max).Result()
-		if err != nil {
-			return nil, convertError(err)
-		}
-		for _, m := range ms {
-			res = append(res, m)
-		}
-	}
-	return res, nil
-}
-func (p *RedisClusterPool) ZRangeByScoreWithScore(key string, min, max int64) (map[string]int64, error) {
-	opt := new(redis.ZRangeBy)
-	opt.Min = strconv.FormatInt(int64(min), 10)
-	opt.Max = strconv.FormatInt(int64(max), 10)
-	opt.Count = -1
-	opt.Offset = 0
-	vals, err := p.client.ZRangeByScoreWithScores(key, *opt).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	res := make(map[string]int64, len(vals))
-	for _, val := range vals {
-		key, err := String(val.Member, nil)
-		if err != nil && err != ErrNil {
-			return nil, err
-		}
-		res[key] = int64(val.Score)
-	}
-	return res, nil
-}
-func (p *RedisClusterPool) LRange(key string, start, stop int64) (interface{}, error) {
-	res, err := p.client.LRange(key, start, stop).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	return res, nil
-}
-func (p *RedisClusterPool) LSet(key string, index int, value interface{}) error {
-	err := p.client.LSet(key, int64(index), value).Err()
-	return convertError(err)
-}
-func (p *RedisClusterPool) LLen(key string) (int64, error) {
-	res, err := p.client.LLen(key).Result()
-	if err != nil {
-		return res, convertError(err)
-	}
-	return res, nil
-}
-func (p *RedisClusterPool) LRem(key string, count int, value interface{}) (int, error) {
-	val, _ := value.(string)
-	res, err := p.client.LRem(key, int64(count), val).Result()
-	if err != nil {
-		return int(res), convertError(err)
-	}
-	return int(res), nil
-}
-func (p *RedisClusterPool) TTl(key string) (int64, error) {
-	duration, err := p.client.TTL(key).Result()
-	if err != nil {
-		return int64(duration.Seconds()), convertError(err)
-	}
-	return int64(duration.Seconds()), nil
-}
-func (p *RedisClusterPool) LPop(key string) (interface{}, error) {
-	res, err := p.client.LPop(key).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	return res, nil
-}
-func (p *RedisClusterPool) RPop(key string) (interface{}, error) {
-	res, err := p.client.RPop(key).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	return res, nil
-}
-func (p *RedisClusterPool) BLPop(key string, timeout int) (interface{}, error) {
-	res, err := p.client.BLPop(time.Duration(timeout)*time.Second, key).Result()
-	if err != nil {
-		// 兼容redis 2.x
-		if err == redis.Nil {
-			return nil, ErrNil
-		}
-		return nil, err
-	}
-	return res[1], nil
-}
-func (p *RedisClusterPool) BRPop(key string, timeout int) (interface{}, error) {
-	res, err := p.client.BRPop(time.Duration(timeout)*time.Second, key).Result()
-	if err != nil {
-		// 兼容redis 2.x
-		if err == redis.Nil {
-			return nil, ErrNil
-		}
-		return nil, convertError(err)
-	}
-	return res[1], nil
-}
-func (p *RedisClusterPool) LPush(key string, value ...interface{}) error {
-	args := make([]interface{}, 0, len(value)+1)
-	args = append(args, key)
-	args = append(args, value...)
-	vals := make([]string, 0, len(value))
-	for _, v := range value {
-		val, err := String(v, nil)
-		if err != nil && err != ErrNil {
-			return err
-		}
-		vals = append(vals, val)
-	}
-	_, err := p.client.LPush(key, vals).Result() // todo ...
-	if err != nil {
-		return convertError(err)
-	}
-	return nil
-}
-func (p *RedisClusterPool) RPush(key string, value ...interface{}) error {
-	args := make([]interface{}, 0, len(value)+1)
-	args = append(args, key)
-	args = append(args, value...)
-	vals := make([]string, 0, len(value))
-	for _, v := range value {
-		val, err := String(v, nil)
-		if err != nil && err != ErrNil {
-			if err == ErrNil {
-				continue
-			}
-			return err
-		}
-		if val == "" {
-			continue
-		}
-		vals = append(vals, val)
-	}
-	_, err := p.client.RPush(key, vals).Result() // todo ...
-	if err != nil {
-		return convertError(err)
-	}
-	return nil
-}
-
-// 为确保srcKey跟destKey映射到同一个slot，srcKey和destKey需要加上hash tag，如:{test}
-func (p *RedisClusterPool) BRPopLPush(srcKey string, destKey string, timeout int) (interface{}, error) {
-	res, err := p.client.BRPopLPush(srcKey, destKey, time.Duration(timeout)*time.Second).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	return res, nil
-}
-
-// 为确保srcKey跟destKey映射到同一个slot，srcKey和destKey需要加上hash tag，如:{test}
-func (p *RedisClusterPool) RPopLPush(srcKey string, destKey string) (interface{}, error) {
-	res, err := p.client.RPopLPush(srcKey, destKey).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	return res, nil
-}
-func (p *RedisClusterPool) SAdd(key string, members ...interface{}) (int64, error) {
-	args := make([]interface{}, 0, len(members)+1)
-	args = append(args, key)
-	args = append(args, members...)
-	ms := make([]string, 0, len(members))
-	for _, member := range members {
-		m, err := String(member, nil)
-		if err != nil && err != ErrNil {
-			return 0, err
-		}
-		ms = append(ms, m)
-	}
-	res, err := p.client.SAdd(key, ms).Result() // todo ...
-	if err != nil {
-		return res, convertError(err)
-	}
-	return res, nil
-}
-func (p *RedisClusterPool) SPop(key string) ([]byte, error) {
-	res, err := p.client.SPop(key).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	return []byte(res), nil
-}
-func (p *RedisClusterPool) SIsMember(key string, member interface{}) (bool, error) {
-	m, _ := member.(string)
-	res, err := p.client.SIsMember(key, m).Result()
-	if err != nil {
-		return res, convertError(err)
-	}
-	return res, nil
-}
-func (p *RedisClusterPool) SRem(key string, members ...interface{}) (int64, error) {
-	args := make([]interface{}, 0, len(members)+1)
-	args = append(args, key)
-	args = append(args, members...)
-	ms := make([]string, 0, len(members))
-	for _, member := range members {
-		m, err := String(member, nil)
-		if err != nil && err != ErrNil {
-			return 0, err
-		}
-		ms = append(ms, m)
-	}
-	res, err := p.client.SRem(key, ms).Result() // todo ...
-	if err != nil {
-		return res, convertError(err)
-	}
-	return res, nil
-}
-func (p *RedisClusterPool) SMembers(key string) ([]string, error) {
-	res, err := p.client.SMembers(key).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	return res, nil
-}
-func (p *RedisClusterPool) ScriptLoad(luaScript string) (interface{}, error) {
-	res, err := p.client.ScriptLoad(luaScript).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	return res, nil
-}
-func (p *RedisClusterPool) EvalSha(sha1 string, numberKeys int, keysArgs ...interface{}) (interface{}, error) {
-	vals := make([]interface{}, 0, len(keysArgs)+2)
-	vals = append(vals, sha1, numberKeys)
-	vals = append(vals, keysArgs...)
-	keys := make([]string, 0, numberKeys)
-	args := make([]string, 0, len(keysArgs)-numberKeys)
-	for i, value := range keysArgs {
-		val, err := String(value, nil)
-		if err != nil && err != ErrNil {
-			return nil, err
-		}
-		if i < numberKeys {
-			keys = append(keys, val)
-		} else {
-			args = append(args, val)
-		}
-	}
-	res, err := p.client.EvalSha(sha1, keys, args).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	return res, nil
-}
-func (p *RedisClusterPool) Eval(luaScript string, numberKeys int, keysArgs ...interface{}) (interface{}, error) {
-	vals := make([]interface{}, 0, len(keysArgs)+2)
-	vals = append(vals, luaScript, numberKeys)
-	vals = append(vals, keysArgs...)
-	keys := make([]string, 0, numberKeys)
-	args := make([]string, 0, len(keysArgs)-numberKeys)
-	for i, value := range keysArgs {
-		val, err := String(value, nil)
-		if err != nil && err != ErrNil {
-			return nil, err
-		}
-		if i < numberKeys {
-			keys = append(keys, val)
-		} else {
-			args = append(args, val)
-		}
-	}
-	res, err := p.client.Eval(luaScript, keys, args).Result()
-	if err != nil {
-		return nil, convertError(err)
-	}
-	return res, nil
-}
-func (p *RedisClusterPool) GetBit(key string, offset int64) (int64, error) {
-	res, err := p.client.GetBit(key, offset).Result()
-	if err != nil {
-		return res, convertError(err)
-	}
-	return res, nil
-}
-func (p *RedisClusterPool) SetBit(key string, offset uint32, value int) (int, error) {
-	res, err := p.client.SetBit(key, int64(offset), value).Result()
-	return int(res), convertError(err)
-}
-func (p *RedisClusterPool) GetClient() *redis.ClusterClient {
-	return pools
-}