summaryrefslogtreecommitdiffstats
path: root/vendor/gopkg.in/redis.v2
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/gopkg.in/redis.v2')
-rw-r--r--vendor/gopkg.in/redis.v2/.travis.yml19
-rw-r--r--vendor/gopkg.in/redis.v2/LICENSE27
-rw-r--r--vendor/gopkg.in/redis.v2/Makefile3
-rw-r--r--vendor/gopkg.in/redis.v2/README.md46
-rw-r--r--vendor/gopkg.in/redis.v2/command.go597
-rw-r--r--vendor/gopkg.in/redis.v2/commands.go1246
-rw-r--r--vendor/gopkg.in/redis.v2/doc.go4
-rw-r--r--vendor/gopkg.in/redis.v2/error.go23
-rw-r--r--vendor/gopkg.in/redis.v2/multi.go138
-rw-r--r--vendor/gopkg.in/redis.v2/parser.go262
-rw-r--r--vendor/gopkg.in/redis.v2/pipeline.go91
-rw-r--r--vendor/gopkg.in/redis.v2/pool.go405
-rw-r--r--vendor/gopkg.in/redis.v2/pubsub.go134
-rw-r--r--vendor/gopkg.in/redis.v2/rate_limit.go53
-rw-r--r--vendor/gopkg.in/redis.v2/redis.go231
-rw-r--r--vendor/gopkg.in/redis.v2/script.go52
-rw-r--r--vendor/gopkg.in/redis.v2/sentinel.go291
17 files changed, 0 insertions, 3622 deletions
diff --git a/vendor/gopkg.in/redis.v2/.travis.yml b/vendor/gopkg.in/redis.v2/.travis.yml
deleted file mode 100644
index c3cf4b8a6e..0000000000
--- a/vendor/gopkg.in/redis.v2/.travis.yml
+++ /dev/null
@@ -1,19 +0,0 @@
-language: go
-
-services:
-- redis-server
-
-go:
- - 1.1
- - 1.2
- - 1.3
- - tip
-
-install:
- - go get gopkg.in/bufio.v1
- - go get gopkg.in/check.v1
- - mkdir -p $HOME/gopath/src/gopkg.in
- - ln -s `pwd` $HOME/gopath/src/gopkg.in/redis.v2
-
-before_script:
- - redis-server testdata/sentinel.conf --sentinel &
diff --git a/vendor/gopkg.in/redis.v2/LICENSE b/vendor/gopkg.in/redis.v2/LICENSE
deleted file mode 100644
index 6855a95feb..0000000000
--- a/vendor/gopkg.in/redis.v2/LICENSE
+++ /dev/null
@@ -1,27 +0,0 @@
-Copyright (c) 2012 The Redis Go Client Authors. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
- * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
- * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/gopkg.in/redis.v2/Makefile b/vendor/gopkg.in/redis.v2/Makefile
deleted file mode 100644
index b250d9bfa9..0000000000
--- a/vendor/gopkg.in/redis.v2/Makefile
+++ /dev/null
@@ -1,3 +0,0 @@
-all:
- go test gopkg.in/redis.v2 -cpu=1,2,4
- go test gopkg.in/redis.v2 -short -race
diff --git a/vendor/gopkg.in/redis.v2/README.md b/vendor/gopkg.in/redis.v2/README.md
deleted file mode 100644
index ddf875f9a1..0000000000
--- a/vendor/gopkg.in/redis.v2/README.md
+++ /dev/null
@@ -1,46 +0,0 @@
-Redis client for Golang [![Build Status](https://travis-ci.org/go-redis/redis.png?branch=master)](https://travis-ci.org/go-redis/redis)
-=======================
-
-Supports:
-
-- Redis 2.8 commands except QUIT, MONITOR, SLOWLOG and SYNC.
-- Pub/sub.
-- Transactions.
-- Pipelining.
-- Connection pool.
-- TLS connections.
-- Thread safety.
-- Timeouts.
-- Redis Sentinel.
-
-API docs: http://godoc.org/gopkg.in/redis.v2.
-Examples: http://godoc.org/gopkg.in/redis.v2#pkg-examples.
-
-Installation
-------------
-
-Install:
-
- go get gopkg.in/redis.v2
-
-Look and feel
--------------
-
-Some corner cases:
-
- SORT list LIMIT 0 2 ASC
- vals, err := client.Sort("list", redis.Sort{Offset: 0, Count: 2, Order: "ASC"}).Result()
-
- ZRANGEBYSCORE zset -inf +inf WITHSCORES LIMIT 0 2
- vals, err := client.ZRangeByScoreWithScores("zset", redis.ZRangeByScore{
- Min: "-inf",
- Max: "+inf",
- Offset: 0,
- Count: 2,
- }).Result()
-
- ZINTERSTORE out 2 zset1 zset2 WEIGHTS 2 3 AGGREGATE SUM
- vals, err := client.ZInterStore("out", redis.ZStore{Weights: []int64{2, 3}}, "zset1", "zset2").Result()
-
- EVAL "return {KEYS[1],ARGV[1]}" 1 "key" "hello"
- vals, err := client.Eval("return {KEYS[1],ARGV[1]}", []string{"key"}, []string{"hello"}).Result()
diff --git a/vendor/gopkg.in/redis.v2/command.go b/vendor/gopkg.in/redis.v2/command.go
deleted file mode 100644
index d7c76cf92a..0000000000
--- a/vendor/gopkg.in/redis.v2/command.go
+++ /dev/null
@@ -1,597 +0,0 @@
-package redis
-
-import (
- "fmt"
- "strconv"
- "strings"
- "time"
-
- "gopkg.in/bufio.v1"
-)
-
-var (
- _ Cmder = (*Cmd)(nil)
- _ Cmder = (*SliceCmd)(nil)
- _ Cmder = (*StatusCmd)(nil)
- _ Cmder = (*IntCmd)(nil)
- _ Cmder = (*DurationCmd)(nil)
- _ Cmder = (*BoolCmd)(nil)
- _ Cmder = (*StringCmd)(nil)
- _ Cmder = (*FloatCmd)(nil)
- _ Cmder = (*StringSliceCmd)(nil)
- _ Cmder = (*BoolSliceCmd)(nil)
- _ Cmder = (*StringStringMapCmd)(nil)
- _ Cmder = (*ZSliceCmd)(nil)
- _ Cmder = (*ScanCmd)(nil)
-)
-
-type Cmder interface {
- args() []string
- parseReply(*bufio.Reader) error
- setErr(error)
-
- writeTimeout() *time.Duration
- readTimeout() *time.Duration
-
- Err() error
- String() string
-}
-
-func setCmdsErr(cmds []Cmder, e error) {
- for _, cmd := range cmds {
- cmd.setErr(e)
- }
-}
-
-func cmdString(cmd Cmder, val interface{}) string {
- s := strings.Join(cmd.args(), " ")
- if err := cmd.Err(); err != nil {
- return s + ": " + err.Error()
- }
- if val != nil {
- return s + ": " + fmt.Sprint(val)
- }
- return s
-
-}
-
-//------------------------------------------------------------------------------
-
-type baseCmd struct {
- _args []string
-
- err error
-
- _writeTimeout, _readTimeout *time.Duration
-}
-
-func newBaseCmd(args ...string) *baseCmd {
- return &baseCmd{
- _args: args,
- }
-}
-
-func (cmd *baseCmd) Err() error {
- if cmd.err != nil {
- return cmd.err
- }
- return nil
-}
-
-func (cmd *baseCmd) args() []string {
- return cmd._args
-}
-
-func (cmd *baseCmd) readTimeout() *time.Duration {
- return cmd._readTimeout
-}
-
-func (cmd *baseCmd) setReadTimeout(d time.Duration) {
- cmd._readTimeout = &d
-}
-
-func (cmd *baseCmd) writeTimeout() *time.Duration {
- return cmd._writeTimeout
-}
-
-func (cmd *baseCmd) setWriteTimeout(d time.Duration) {
- cmd._writeTimeout = &d
-}
-
-func (cmd *baseCmd) setErr(e error) {
- cmd.err = e
-}
-
-//------------------------------------------------------------------------------
-
-type Cmd struct {
- *baseCmd
-
- val interface{}
-}
-
-func NewCmd(args ...string) *Cmd {
- return &Cmd{
- baseCmd: newBaseCmd(args...),
- }
-}
-
-func (cmd *Cmd) Val() interface{} {
- return cmd.val
-}
-
-func (cmd *Cmd) Result() (interface{}, error) {
- return cmd.val, cmd.err
-}
-
-func (cmd *Cmd) String() string {
- return cmdString(cmd, cmd.val)
-}
-
-func (cmd *Cmd) parseReply(rd *bufio.Reader) error {
- cmd.val, cmd.err = parseReply(rd, parseSlice)
- return cmd.err
-}
-
-//------------------------------------------------------------------------------
-
-type SliceCmd struct {
- *baseCmd
-
- val []interface{}
-}
-
-func NewSliceCmd(args ...string) *SliceCmd {
- return &SliceCmd{
- baseCmd: newBaseCmd(args...),
- }
-}
-
-func (cmd *SliceCmd) Val() []interface{} {
- return cmd.val
-}
-
-func (cmd *SliceCmd) Result() ([]interface{}, error) {
- return cmd.val, cmd.err
-}
-
-func (cmd *SliceCmd) String() string {
- return cmdString(cmd, cmd.val)
-}
-
-func (cmd *SliceCmd) parseReply(rd *bufio.Reader) error {
- v, err := parseReply(rd, parseSlice)
- if err != nil {
- cmd.err = err
- return err
- }
- cmd.val = v.([]interface{})
- return nil
-}
-
-//------------------------------------------------------------------------------
-
-type StatusCmd struct {
- *baseCmd
-
- val string
-}
-
-func NewStatusCmd(args ...string) *StatusCmd {
- return &StatusCmd{
- baseCmd: newBaseCmd(args...),
- }
-}
-
-func (cmd *StatusCmd) Val() string {
- return cmd.val
-}
-
-func (cmd *StatusCmd) Result() (string, error) {
- return cmd.val, cmd.err
-}
-
-func (cmd *StatusCmd) String() string {
- return cmdString(cmd, cmd.val)
-}
-
-func (cmd *StatusCmd) parseReply(rd *bufio.Reader) error {
- v, err := parseReply(rd, nil)
- if err != nil {
- cmd.err = err
- return err
- }
- cmd.val = v.(string)
- return nil
-}
-
-//------------------------------------------------------------------------------
-
-type IntCmd struct {
- *baseCmd
-
- val int64
-}
-
-func NewIntCmd(args ...string) *IntCmd {
- return &IntCmd{
- baseCmd: newBaseCmd(args...),
- }
-}
-
-func (cmd *IntCmd) Val() int64 {
- return cmd.val
-}
-
-func (cmd *IntCmd) Result() (int64, error) {
- return cmd.val, cmd.err
-}
-
-func (cmd *IntCmd) String() string {
- return cmdString(cmd, cmd.val)
-}
-
-func (cmd *IntCmd) parseReply(rd *bufio.Reader) error {
- v, err := parseReply(rd, nil)
- if err != nil {
- cmd.err = err
- return err
- }
- cmd.val = v.(int64)
- return nil
-}
-
-//------------------------------------------------------------------------------
-
-type DurationCmd struct {
- *baseCmd
-
- val time.Duration
- precision time.Duration
-}
-
-func NewDurationCmd(precision time.Duration, args ...string) *DurationCmd {
- return &DurationCmd{
- baseCmd: newBaseCmd(args...),
- precision: precision,
- }
-}
-
-func (cmd *DurationCmd) Val() time.Duration {
- return cmd.val
-}
-
-func (cmd *DurationCmd) Result() (time.Duration, error) {
- return cmd.val, cmd.err
-}
-
-func (cmd *DurationCmd) String() string {
- return cmdString(cmd, cmd.val)
-}
-
-func (cmd *DurationCmd) parseReply(rd *bufio.Reader) error {
- v, err := parseReply(rd, nil)
- if err != nil {
- cmd.err = err
- return err
- }
- cmd.val = time.Duration(v.(int64)) * cmd.precision
- return nil
-}
-
-//------------------------------------------------------------------------------
-
-type BoolCmd struct {
- *baseCmd
-
- val bool
-}
-
-func NewBoolCmd(args ...string) *BoolCmd {
- return &BoolCmd{
- baseCmd: newBaseCmd(args...),
- }
-}
-
-func (cmd *BoolCmd) Val() bool {
- return cmd.val
-}
-
-func (cmd *BoolCmd) Result() (bool, error) {
- return cmd.val, cmd.err
-}
-
-func (cmd *BoolCmd) String() string {
- return cmdString(cmd, cmd.val)
-}
-
-func (cmd *BoolCmd) parseReply(rd *bufio.Reader) error {
- v, err := parseReply(rd, nil)
- if err != nil {
- cmd.err = err
- return err
- }
- cmd.val = v.(int64) == 1
- return nil
-}
-
-//------------------------------------------------------------------------------
-
-type StringCmd struct {
- *baseCmd
-
- val string
-}
-
-func NewStringCmd(args ...string) *StringCmd {
- return &StringCmd{
- baseCmd: newBaseCmd(args...),
- }
-}
-
-func (cmd *StringCmd) Val() string {
- return cmd.val
-}
-
-func (cmd *StringCmd) Result() (string, error) {
- return cmd.val, cmd.err
-}
-
-func (cmd *StringCmd) Int64() (int64, error) {
- if cmd.err != nil {
- return 0, cmd.err
- }
- return strconv.ParseInt(cmd.val, 10, 64)
-}
-
-func (cmd *StringCmd) Uint64() (uint64, error) {
- if cmd.err != nil {
- return 0, cmd.err
- }
- return strconv.ParseUint(cmd.val, 10, 64)
-}
-
-func (cmd *StringCmd) Float64() (float64, error) {
- if cmd.err != nil {
- return 0, cmd.err
- }
- return strconv.ParseFloat(cmd.val, 64)
-}
-
-func (cmd *StringCmd) String() string {
- return cmdString(cmd, cmd.val)
-}
-
-func (cmd *StringCmd) parseReply(rd *bufio.Reader) error {
- v, err := parseReply(rd, nil)
- if err != nil {
- cmd.err = err
- return err
- }
- cmd.val = v.(string)
- return nil
-}
-
-//------------------------------------------------------------------------------
-
-type FloatCmd struct {
- *baseCmd
-
- val float64
-}
-
-func NewFloatCmd(args ...string) *FloatCmd {
- return &FloatCmd{
- baseCmd: newBaseCmd(args...),
- }
-}
-
-func (cmd *FloatCmd) Val() float64 {
- return cmd.val
-}
-
-func (cmd *FloatCmd) String() string {
- return cmdString(cmd, cmd.val)
-}
-
-func (cmd *FloatCmd) parseReply(rd *bufio.Reader) error {
- v, err := parseReply(rd, nil)
- if err != nil {
- cmd.err = err
- return err
- }
- cmd.val, cmd.err = strconv.ParseFloat(v.(string), 64)
- return cmd.err
-}
-
-//------------------------------------------------------------------------------
-
-type StringSliceCmd struct {
- *baseCmd
-
- val []string
-}
-
-func NewStringSliceCmd(args ...string) *StringSliceCmd {
- return &StringSliceCmd{
- baseCmd: newBaseCmd(args...),
- }
-}
-
-func (cmd *StringSliceCmd) Val() []string {
- return cmd.val
-}
-
-func (cmd *StringSliceCmd) Result() ([]string, error) {
- return cmd.Val(), cmd.Err()
-}
-
-func (cmd *StringSliceCmd) String() string {
- return cmdString(cmd, cmd.val)
-}
-
-func (cmd *StringSliceCmd) parseReply(rd *bufio.Reader) error {
- v, err := parseReply(rd, parseStringSlice)
- if err != nil {
- cmd.err = err
- return err
- }
- cmd.val = v.([]string)
- return nil
-}
-
-//------------------------------------------------------------------------------
-
-type BoolSliceCmd struct {
- *baseCmd
-
- val []bool
-}
-
-func NewBoolSliceCmd(args ...string) *BoolSliceCmd {
- return &BoolSliceCmd{
- baseCmd: newBaseCmd(args...),
- }
-}
-
-func (cmd *BoolSliceCmd) Val() []bool {
- return cmd.val
-}
-
-func (cmd *BoolSliceCmd) Result() ([]bool, error) {
- return cmd.val, cmd.err
-}
-
-func (cmd *BoolSliceCmd) String() string {
- return cmdString(cmd, cmd.val)
-}
-
-func (cmd *BoolSliceCmd) parseReply(rd *bufio.Reader) error {
- v, err := parseReply(rd, parseBoolSlice)
- if err != nil {
- cmd.err = err
- return err
- }
- cmd.val = v.([]bool)
- return nil
-}
-
-//------------------------------------------------------------------------------
-
-type StringStringMapCmd struct {
- *baseCmd
-
- val map[string]string
-}
-
-func NewStringStringMapCmd(args ...string) *StringStringMapCmd {
- return &StringStringMapCmd{
- baseCmd: newBaseCmd(args...),
- }
-}
-
-func (cmd *StringStringMapCmd) Val() map[string]string {
- return cmd.val
-}
-
-func (cmd *StringStringMapCmd) Result() (map[string]string, error) {
- return cmd.val, cmd.err
-}
-
-func (cmd *StringStringMapCmd) String() string {
- return cmdString(cmd, cmd.val)
-}
-
-func (cmd *StringStringMapCmd) parseReply(rd *bufio.Reader) error {
- v, err := parseReply(rd, parseStringStringMap)
- if err != nil {
- cmd.err = err
- return err
- }
- cmd.val = v.(map[string]string)
- return nil
-}
-
-//------------------------------------------------------------------------------
-
-type ZSliceCmd struct {
- *baseCmd
-
- val []Z
-}
-
-func NewZSliceCmd(args ...string) *ZSliceCmd {
- return &ZSliceCmd{
- baseCmd: newBaseCmd(args...),
- }
-}
-
-func (cmd *ZSliceCmd) Val() []Z {
- return cmd.val
-}
-
-func (cmd *ZSliceCmd) Result() ([]Z, error) {
- return cmd.val, cmd.err
-}
-
-func (cmd *ZSliceCmd) String() string {
- return cmdString(cmd, cmd.val)
-}
-
-func (cmd *ZSliceCmd) parseReply(rd *bufio.Reader) error {
- v, err := parseReply(rd, parseZSlice)
- if err != nil {
- cmd.err = err
- return err
- }
- cmd.val = v.([]Z)
- return nil
-}
-
-//------------------------------------------------------------------------------
-
-type ScanCmd struct {
- *baseCmd
-
- cursor int64
- keys []string
-}
-
-func NewScanCmd(args ...string) *ScanCmd {
- return &ScanCmd{
- baseCmd: newBaseCmd(args...),
- }
-}
-
-func (cmd *ScanCmd) Val() (int64, []string) {
- return cmd.cursor, cmd.keys
-}
-
-func (cmd *ScanCmd) Result() (int64, []string, error) {
- return cmd.cursor, cmd.keys, cmd.err
-}
-
-func (cmd *ScanCmd) String() string {
- return cmdString(cmd, cmd.keys)
-}
-
-func (cmd *ScanCmd) parseReply(rd *bufio.Reader) error {
- vi, err := parseReply(rd, parseSlice)
- if err != nil {
- cmd.err = err
- return cmd.err
- }
- v := vi.([]interface{})
-
- cmd.cursor, cmd.err = strconv.ParseInt(v[0].(string), 10, 64)
- if cmd.err != nil {
- return cmd.err
- }
-
- keys := v[1].([]interface{})
- for _, keyi := range keys {
- cmd.keys = append(cmd.keys, keyi.(string))
- }
-
- return nil
-}
diff --git a/vendor/gopkg.in/redis.v2/commands.go b/vendor/gopkg.in/redis.v2/commands.go
deleted file mode 100644
index 6068bab17e..0000000000
--- a/vendor/gopkg.in/redis.v2/commands.go
+++ /dev/null
@@ -1,1246 +0,0 @@
-package redis
-
-import (
- "io"
- "strconv"
- "time"
-)
-
-func formatFloat(f float64) string {
- return strconv.FormatFloat(f, 'f', -1, 64)
-}
-
-func readTimeout(sec int64) time.Duration {
- if sec == 0 {
- return 0
- }
- return time.Duration(sec+1) * time.Second
-}
-
-//------------------------------------------------------------------------------
-
-func (c *Client) Auth(password string) *StatusCmd {
- cmd := NewStatusCmd("AUTH", password)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) Echo(message string) *StringCmd {
- cmd := NewStringCmd("ECHO", message)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) Ping() *StatusCmd {
- cmd := NewStatusCmd("PING")
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) Quit() *StatusCmd {
- panic("not implemented")
-}
-
-func (c *Client) Select(index int64) *StatusCmd {
- cmd := NewStatusCmd("SELECT", strconv.FormatInt(index, 10))
- c.Process(cmd)
- return cmd
-}
-
-//------------------------------------------------------------------------------
-
-func (c *Client) Del(keys ...string) *IntCmd {
- args := append([]string{"DEL"}, keys...)
- cmd := NewIntCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) Dump(key string) *StringCmd {
- cmd := NewStringCmd("DUMP", key)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) Exists(key string) *BoolCmd {
- cmd := NewBoolCmd("EXISTS", key)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) Expire(key string, dur time.Duration) *BoolCmd {
- cmd := NewBoolCmd("EXPIRE", key, strconv.FormatInt(int64(dur/time.Second), 10))
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) ExpireAt(key string, tm time.Time) *BoolCmd {
- cmd := NewBoolCmd("EXPIREAT", key, strconv.FormatInt(tm.Unix(), 10))
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) Keys(pattern string) *StringSliceCmd {
- cmd := NewStringSliceCmd("KEYS", pattern)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) Migrate(host, port, key string, db, timeout int64) *StatusCmd {
- cmd := NewStatusCmd(
- "MIGRATE",
- host,
- port,
- key,
- strconv.FormatInt(db, 10),
- strconv.FormatInt(timeout, 10),
- )
- cmd.setReadTimeout(readTimeout(timeout))
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) Move(key string, db int64) *BoolCmd {
- cmd := NewBoolCmd("MOVE", key, strconv.FormatInt(db, 10))
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) ObjectRefCount(keys ...string) *IntCmd {
- args := append([]string{"OBJECT", "REFCOUNT"}, keys...)
- cmd := NewIntCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) ObjectEncoding(keys ...string) *StringCmd {
- args := append([]string{"OBJECT", "ENCODING"}, keys...)
- cmd := NewStringCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) ObjectIdleTime(keys ...string) *DurationCmd {
- args := append([]string{"OBJECT", "IDLETIME"}, keys...)
- cmd := NewDurationCmd(time.Second, args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) Persist(key string) *BoolCmd {
- cmd := NewBoolCmd("PERSIST", key)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) PExpire(key string, dur time.Duration) *BoolCmd {
- cmd := NewBoolCmd("PEXPIRE", key, strconv.FormatInt(int64(dur/time.Millisecond), 10))
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) PExpireAt(key string, tm time.Time) *BoolCmd {
- cmd := NewBoolCmd(
- "PEXPIREAT",
- key,
- strconv.FormatInt(tm.UnixNano()/int64(time.Millisecond), 10),
- )
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) PTTL(key string) *DurationCmd {
- cmd := NewDurationCmd(time.Millisecond, "PTTL", key)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) RandomKey() *StringCmd {
- cmd := NewStringCmd("RANDOMKEY")
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) Rename(key, newkey string) *StatusCmd {
- cmd := NewStatusCmd("RENAME", key, newkey)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) RenameNX(key, newkey string) *BoolCmd {
- cmd := NewBoolCmd("RENAMENX", key, newkey)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) Restore(key string, ttl int64, value string) *StatusCmd {
- cmd := NewStatusCmd(
- "RESTORE",
- key,
- strconv.FormatInt(ttl, 10),
- value,
- )
- c.Process(cmd)
- return cmd
-}
-
-type Sort struct {
- By string
- Offset, Count float64
- Get []string
- Order string
- IsAlpha bool
- Store string
-}
-
-func (c *Client) Sort(key string, sort Sort) *StringSliceCmd {
- args := []string{"SORT", key}
- if sort.By != "" {
- args = append(args, "BY", sort.By)
- }
- if sort.Offset != 0 || sort.Count != 0 {
- args = append(args, "LIMIT", formatFloat(sort.Offset), formatFloat(sort.Count))
- }
- for _, get := range sort.Get {
- args = append(args, "GET", get)
- }
- if sort.Order != "" {
- args = append(args, sort.Order)
- }
- if sort.IsAlpha {
- args = append(args, "ALPHA")
- }
- if sort.Store != "" {
- args = append(args, "STORE", sort.Store)
- }
- cmd := NewStringSliceCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) TTL(key string) *DurationCmd {
- cmd := NewDurationCmd(time.Second, "TTL", key)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) Type(key string) *StatusCmd {
- cmd := NewStatusCmd("TYPE", key)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) Scan(cursor int64, match string, count int64) *ScanCmd {
- args := []string{"SCAN", strconv.FormatInt(cursor, 10)}
- if match != "" {
- args = append(args, "MATCH", match)
- }
- if count > 0 {
- args = append(args, "COUNT", strconv.FormatInt(count, 10))
- }
- cmd := NewScanCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) SScan(key string, cursor int64, match string, count int64) *ScanCmd {
- args := []string{"SSCAN", key, strconv.FormatInt(cursor, 10)}
- if match != "" {
- args = append(args, "MATCH", match)
- }
- if count > 0 {
- args = append(args, "COUNT", strconv.FormatInt(count, 10))
- }
- cmd := NewScanCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) HScan(key string, cursor int64, match string, count int64) *ScanCmd {
- args := []string{"HSCAN", key, strconv.FormatInt(cursor, 10)}
- if match != "" {
- args = append(args, "MATCH", match)
- }
- if count > 0 {
- args = append(args, "COUNT", strconv.FormatInt(count, 10))
- }
- cmd := NewScanCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) ZScan(key string, cursor int64, match string, count int64) *ScanCmd {
- args := []string{"ZSCAN", key, strconv.FormatInt(cursor, 10)}
- if match != "" {
- args = append(args, "MATCH", match)
- }
- if count > 0 {
- args = append(args, "COUNT", strconv.FormatInt(count, 10))
- }
- cmd := NewScanCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-//------------------------------------------------------------------------------
-
-func (c *Client) Append(key, value string) *IntCmd {
- cmd := NewIntCmd("APPEND", key, value)
- c.Process(cmd)
- return cmd
-}
-
-type BitCount struct {
- Start, End int64
-}
-
-func (c *Client) BitCount(key string, bitCount *BitCount) *IntCmd {
- args := []string{"BITCOUNT", key}
- if bitCount != nil {
- args = append(
- args,
- strconv.FormatInt(bitCount.Start, 10),
- strconv.FormatInt(bitCount.End, 10),
- )
- }
- cmd := NewIntCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) bitOp(op, destKey string, keys ...string) *IntCmd {
- args := []string{"BITOP", op, destKey}
- args = append(args, keys...)
- cmd := NewIntCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) BitOpAnd(destKey string, keys ...string) *IntCmd {
- return c.bitOp("AND", destKey, keys...)
-}
-
-func (c *Client) BitOpOr(destKey string, keys ...string) *IntCmd {
- return c.bitOp("OR", destKey, keys...)
-}
-
-func (c *Client) BitOpXor(destKey string, keys ...string) *IntCmd {
- return c.bitOp("XOR", destKey, keys...)
-}
-
-func (c *Client) BitOpNot(destKey string, key string) *IntCmd {
- return c.bitOp("NOT", destKey, key)
-}
-
-func (c *Client) Decr(key string) *IntCmd {
- cmd := NewIntCmd("DECR", key)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) DecrBy(key string, decrement int64) *IntCmd {
- cmd := NewIntCmd("DECRBY", key, strconv.FormatInt(decrement, 10))
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) Get(key string) *StringCmd {
- cmd := NewStringCmd("GET", key)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) GetBit(key string, offset int64) *IntCmd {
- cmd := NewIntCmd("GETBIT", key, strconv.FormatInt(offset, 10))
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) GetRange(key string, start, end int64) *StringCmd {
- cmd := NewStringCmd(
- "GETRANGE",
- key,
- strconv.FormatInt(start, 10),
- strconv.FormatInt(end, 10),
- )
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) GetSet(key, value string) *StringCmd {
- cmd := NewStringCmd("GETSET", key, value)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) Incr(key string) *IntCmd {
- cmd := NewIntCmd("INCR", key)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) IncrBy(key string, value int64) *IntCmd {
- cmd := NewIntCmd("INCRBY", key, strconv.FormatInt(value, 10))
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) IncrByFloat(key string, value float64) *FloatCmd {
- cmd := NewFloatCmd("INCRBYFLOAT", key, formatFloat(value))
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) MGet(keys ...string) *SliceCmd {
- args := append([]string{"MGET"}, keys...)
- cmd := NewSliceCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) MSet(pairs ...string) *StatusCmd {
- args := append([]string{"MSET"}, pairs...)
- cmd := NewStatusCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) MSetNX(pairs ...string) *BoolCmd {
- args := append([]string{"MSETNX"}, pairs...)
- cmd := NewBoolCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) PSetEx(key string, dur time.Duration, value string) *StatusCmd {
- cmd := NewStatusCmd(
- "PSETEX",
- key,
- strconv.FormatInt(int64(dur/time.Millisecond), 10),
- value,
- )
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) Set(key, value string) *StatusCmd {
- cmd := NewStatusCmd("SET", key, value)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) SetBit(key string, offset int64, value int) *IntCmd {
- cmd := NewIntCmd(
- "SETBIT",
- key,
- strconv.FormatInt(offset, 10),
- strconv.FormatInt(int64(value), 10),
- )
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) SetEx(key string, dur time.Duration, value string) *StatusCmd {
- cmd := NewStatusCmd("SETEX", key, strconv.FormatInt(int64(dur/time.Second), 10), value)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) SetNX(key, value string) *BoolCmd {
- cmd := NewBoolCmd("SETNX", key, value)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) SetRange(key string, offset int64, value string) *IntCmd {
- cmd := NewIntCmd("SETRANGE", key, strconv.FormatInt(offset, 10), value)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) StrLen(key string) *IntCmd {
- cmd := NewIntCmd("STRLEN", key)
- c.Process(cmd)
- return cmd
-}
-
-//------------------------------------------------------------------------------
-
-func (c *Client) HDel(key string, fields ...string) *IntCmd {
- args := append([]string{"HDEL", key}, fields...)
- cmd := NewIntCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) HExists(key, field string) *BoolCmd {
- cmd := NewBoolCmd("HEXISTS", key, field)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) HGet(key, field string) *StringCmd {
- cmd := NewStringCmd("HGET", key, field)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) HGetAll(key string) *StringSliceCmd {
- cmd := NewStringSliceCmd("HGETALL", key)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) HGetAllMap(key string) *StringStringMapCmd {
- cmd := NewStringStringMapCmd("HGETALL", key)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) HIncrBy(key, field string, incr int64) *IntCmd {
- cmd := NewIntCmd("HINCRBY", key, field, strconv.FormatInt(incr, 10))
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) HIncrByFloat(key, field string, incr float64) *FloatCmd {
- cmd := NewFloatCmd("HINCRBYFLOAT", key, field, formatFloat(incr))
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) HKeys(key string) *StringSliceCmd {
- cmd := NewStringSliceCmd("HKEYS", key)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) HLen(key string) *IntCmd {
- cmd := NewIntCmd("HLEN", key)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) HMGet(key string, fields ...string) *SliceCmd {
- args := append([]string{"HMGET", key}, fields...)
- cmd := NewSliceCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) HMSet(key, field, value string, pairs ...string) *StatusCmd {
- args := append([]string{"HMSET", key, field, value}, pairs...)
- cmd := NewStatusCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) HSet(key, field, value string) *BoolCmd {
- cmd := NewBoolCmd("HSET", key, field, value)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) HSetNX(key, field, value string) *BoolCmd {
- cmd := NewBoolCmd("HSETNX", key, field, value)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) HVals(key string) *StringSliceCmd {
- cmd := NewStringSliceCmd("HVALS", key)
- c.Process(cmd)
- return cmd
-}
-
-//------------------------------------------------------------------------------
-
-func (c *Client) BLPop(timeout int64, keys ...string) *StringSliceCmd {
- args := append([]string{"BLPOP"}, keys...)
- args = append(args, strconv.FormatInt(timeout, 10))
- cmd := NewStringSliceCmd(args...)
- cmd.setReadTimeout(readTimeout(timeout))
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) BRPop(timeout int64, keys ...string) *StringSliceCmd {
- args := append([]string{"BRPOP"}, keys...)
- args = append(args, strconv.FormatInt(timeout, 10))
- cmd := NewStringSliceCmd(args...)
- cmd.setReadTimeout(readTimeout(timeout))
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) BRPopLPush(source, destination string, timeout int64) *StringCmd {
- cmd := NewStringCmd(
- "BRPOPLPUSH",
- source,
- destination,
- strconv.FormatInt(timeout, 10),
- )
- cmd.setReadTimeout(readTimeout(timeout))
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) LIndex(key string, index int64) *StringCmd {
- cmd := NewStringCmd("LINDEX", key, strconv.FormatInt(index, 10))
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) LInsert(key, op, pivot, value string) *IntCmd {
- cmd := NewIntCmd("LINSERT", key, op, pivot, value)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) LLen(key string) *IntCmd {
- cmd := NewIntCmd("LLEN", key)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) LPop(key string) *StringCmd {
- cmd := NewStringCmd("LPOP", key)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) LPush(key string, values ...string) *IntCmd {
- args := append([]string{"LPUSH", key}, values...)
- cmd := NewIntCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) LPushX(key, value string) *IntCmd {
- cmd := NewIntCmd("LPUSHX", key, value)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) LRange(key string, start, stop int64) *StringSliceCmd {
- cmd := NewStringSliceCmd(
- "LRANGE",
- key,
- strconv.FormatInt(start, 10),
- strconv.FormatInt(stop, 10),
- )
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) LRem(key string, count int64, value string) *IntCmd {
- cmd := NewIntCmd("LREM", key, strconv.FormatInt(count, 10), value)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) LSet(key string, index int64, value string) *StatusCmd {
- cmd := NewStatusCmd("LSET", key, strconv.FormatInt(index, 10), value)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) LTrim(key string, start, stop int64) *StatusCmd {
- cmd := NewStatusCmd(
- "LTRIM",
- key,
- strconv.FormatInt(start, 10),
- strconv.FormatInt(stop, 10),
- )
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) RPop(key string) *StringCmd {
- cmd := NewStringCmd("RPOP", key)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) RPopLPush(source, destination string) *StringCmd {
- cmd := NewStringCmd("RPOPLPUSH", source, destination)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) RPush(key string, values ...string) *IntCmd {
- args := append([]string{"RPUSH", key}, values...)
- cmd := NewIntCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) RPushX(key string, value string) *IntCmd {
- cmd := NewIntCmd("RPUSHX", key, value)
- c.Process(cmd)
- return cmd
-}
-
-//------------------------------------------------------------------------------
-
-func (c *Client) SAdd(key string, members ...string) *IntCmd {
- args := append([]string{"SADD", key}, members...)
- cmd := NewIntCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) SCard(key string) *IntCmd {
- cmd := NewIntCmd("SCARD", key)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) SDiff(keys ...string) *StringSliceCmd {
- args := append([]string{"SDIFF"}, keys...)
- cmd := NewStringSliceCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) SDiffStore(destination string, keys ...string) *IntCmd {
- args := append([]string{"SDIFFSTORE", destination}, keys...)
- cmd := NewIntCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) SInter(keys ...string) *StringSliceCmd {
- args := append([]string{"SINTER"}, keys...)
- cmd := NewStringSliceCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) SInterStore(destination string, keys ...string) *IntCmd {
- args := append([]string{"SINTERSTORE", destination}, keys...)
- cmd := NewIntCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) SIsMember(key, member string) *BoolCmd {
- cmd := NewBoolCmd("SISMEMBER", key, member)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) SMembers(key string) *StringSliceCmd {
- cmd := NewStringSliceCmd("SMEMBERS", key)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) SMove(source, destination, member string) *BoolCmd {
- cmd := NewBoolCmd("SMOVE", source, destination, member)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) SPop(key string) *StringCmd {
- cmd := NewStringCmd("SPOP", key)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) SRandMember(key string) *StringCmd {
- cmd := NewStringCmd("SRANDMEMBER", key)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) SRem(key string, members ...string) *IntCmd {
- args := append([]string{"SREM", key}, members...)
- cmd := NewIntCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) SUnion(keys ...string) *StringSliceCmd {
- args := append([]string{"SUNION"}, keys...)
- cmd := NewStringSliceCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) SUnionStore(destination string, keys ...string) *IntCmd {
- args := append([]string{"SUNIONSTORE", destination}, keys...)
- cmd := NewIntCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-//------------------------------------------------------------------------------
-
-type Z struct {
- Score float64
- Member string
-}
-
-type ZStore struct {
- Weights []int64
- Aggregate string
-}
-
-func (c *Client) ZAdd(key string, members ...Z) *IntCmd {
- args := []string{"ZADD", key}
- for _, m := range members {
- args = append(args, formatFloat(m.Score), m.Member)
- }
- cmd := NewIntCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) ZCard(key string) *IntCmd {
- cmd := NewIntCmd("ZCARD", key)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) ZCount(key, min, max string) *IntCmd {
- cmd := NewIntCmd("ZCOUNT", key, min, max)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) ZIncrBy(key string, increment float64, member string) *FloatCmd {
- cmd := NewFloatCmd("ZINCRBY", key, formatFloat(increment), member)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) ZInterStore(
- destination string,
- store ZStore,
- keys ...string,
-) *IntCmd {
- args := []string{"ZINTERSTORE", destination, strconv.FormatInt(int64(len(keys)), 10)}
- args = append(args, keys...)
- if len(store.Weights) > 0 {
- args = append(args, "WEIGHTS")
- for _, weight := range store.Weights {
- args = append(args, strconv.FormatInt(weight, 10))
- }
- }
- if store.Aggregate != "" {
- args = append(args, "AGGREGATE", store.Aggregate)
- }
- cmd := NewIntCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) zRange(key string, start, stop int64, withScores bool) *StringSliceCmd {
- args := []string{
- "ZRANGE",
- key,
- strconv.FormatInt(start, 10),
- strconv.FormatInt(stop, 10),
- }
- if withScores {
- args = append(args, "WITHSCORES")
- }
- cmd := NewStringSliceCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) ZRange(key string, start, stop int64) *StringSliceCmd {
- return c.zRange(key, start, stop, false)
-}
-
-func (c *Client) ZRangeWithScores(key string, start, stop int64) *ZSliceCmd {
- args := []string{
- "ZRANGE",
- key,
- strconv.FormatInt(start, 10),
- strconv.FormatInt(stop, 10),
- "WITHSCORES",
- }
- cmd := NewZSliceCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-type ZRangeByScore struct {
- Min, Max string
-
- Offset, Count int64
-}
-
-func (c *Client) zRangeByScore(key string, opt ZRangeByScore, withScores bool) *StringSliceCmd {
- args := []string{"ZRANGEBYSCORE", key, opt.Min, opt.Max}
- if withScores {
- args = append(args, "WITHSCORES")
- }
- if opt.Offset != 0 || opt.Count != 0 {
- args = append(
- args,
- "LIMIT",
- strconv.FormatInt(opt.Offset, 10),
- strconv.FormatInt(opt.Count, 10),
- )
- }
- cmd := NewStringSliceCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) ZRangeByScore(key string, opt ZRangeByScore) *StringSliceCmd {
- return c.zRangeByScore(key, opt, false)
-}
-
-func (c *Client) ZRangeByScoreWithScores(key string, opt ZRangeByScore) *ZSliceCmd {
- args := []string{"ZRANGEBYSCORE", key, opt.Min, opt.Max, "WITHSCORES"}
- if opt.Offset != 0 || opt.Count != 0 {
- args = append(
- args,
- "LIMIT",
- strconv.FormatInt(opt.Offset, 10),
- strconv.FormatInt(opt.Count, 10),
- )
- }
- cmd := NewZSliceCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) ZRank(key, member string) *IntCmd {
- cmd := NewIntCmd("ZRANK", key, member)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) ZRem(key string, members ...string) *IntCmd {
- args := append([]string{"ZREM", key}, members...)
- cmd := NewIntCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) ZRemRangeByRank(key string, start, stop int64) *IntCmd {
- cmd := NewIntCmd(
- "ZREMRANGEBYRANK",
- key,
- strconv.FormatInt(start, 10),
- strconv.FormatInt(stop, 10),
- )
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) ZRemRangeByScore(key, min, max string) *IntCmd {
- cmd := NewIntCmd("ZREMRANGEBYSCORE", key, min, max)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) zRevRange(key, start, stop string, withScores bool) *StringSliceCmd {
- args := []string{"ZREVRANGE", key, start, stop}
- if withScores {
- args = append(args, "WITHSCORES")
- }
- cmd := NewStringSliceCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) ZRevRange(key, start, stop string) *StringSliceCmd {
- return c.zRevRange(key, start, stop, false)
-}
-
-func (c *Client) ZRevRangeWithScores(key, start, stop string) *ZSliceCmd {
- args := []string{"ZREVRANGE", key, start, stop, "WITHSCORES"}
- cmd := NewZSliceCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) zRevRangeByScore(key string, opt ZRangeByScore, withScores bool) *StringSliceCmd {
- args := []string{"ZREVRANGEBYSCORE", key, opt.Max, opt.Min}
- if withScores {
- args = append(args, "WITHSCORES")
- }
- if opt.Offset != 0 || opt.Count != 0 {
- args = append(
- args,
- "LIMIT",
- strconv.FormatInt(opt.Offset, 10),
- strconv.FormatInt(opt.Count, 10),
- )
- }
- cmd := NewStringSliceCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) ZRevRangeByScore(key string, opt ZRangeByScore) *StringSliceCmd {
- return c.zRevRangeByScore(key, opt, false)
-}
-
-func (c *Client) ZRevRangeByScoreWithScores(key string, opt ZRangeByScore) *ZSliceCmd {
- args := []string{"ZREVRANGEBYSCORE", key, opt.Max, opt.Min, "WITHSCORES"}
- if opt.Offset != 0 || opt.Count != 0 {
- args = append(
- args,
- "LIMIT",
- strconv.FormatInt(opt.Offset, 10),
- strconv.FormatInt(opt.Count, 10),
- )
- }
- cmd := NewZSliceCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) ZRevRank(key, member string) *IntCmd {
- cmd := NewIntCmd("ZREVRANK", key, member)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) ZScore(key, member string) *FloatCmd {
- cmd := NewFloatCmd("ZSCORE", key, member)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) ZUnionStore(
- destination string,
- store ZStore,
- keys ...string,
-) *IntCmd {
- args := []string{"ZUNIONSTORE", destination, strconv.FormatInt(int64(len(keys)), 10)}
- args = append(args, keys...)
- if len(store.Weights) > 0 {
- args = append(args, "WEIGHTS")
- for _, weight := range store.Weights {
- args = append(args, strconv.FormatInt(weight, 10))
- }
- }
- if store.Aggregate != "" {
- args = append(args, "AGGREGATE", store.Aggregate)
- }
- cmd := NewIntCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-//------------------------------------------------------------------------------
-
-func (c *Client) BgRewriteAOF() *StatusCmd {
- cmd := NewStatusCmd("BGREWRITEAOF")
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) BgSave() *StatusCmd {
- cmd := NewStatusCmd("BGSAVE")
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) ClientKill(ipPort string) *StatusCmd {
- cmd := NewStatusCmd("CLIENT", "KILL", ipPort)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) ClientList() *StringCmd {
- cmd := NewStringCmd("CLIENT", "LIST")
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) ConfigGet(parameter string) *SliceCmd {
- cmd := NewSliceCmd("CONFIG", "GET", parameter)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) ConfigResetStat() *StatusCmd {
- cmd := NewStatusCmd("CONFIG", "RESETSTAT")
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) ConfigSet(parameter, value string) *StatusCmd {
- cmd := NewStatusCmd("CONFIG", "SET", parameter, value)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) DbSize() *IntCmd {
- cmd := NewIntCmd("DBSIZE")
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) FlushAll() *StatusCmd {
- cmd := NewStatusCmd("FLUSHALL")
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) FlushDb() *StatusCmd {
- cmd := NewStatusCmd("FLUSHDB")
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) Info() *StringCmd {
- cmd := NewStringCmd("INFO")
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) LastSave() *IntCmd {
- cmd := NewIntCmd("LASTSAVE")
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) Save() *StatusCmd {
- cmd := NewStatusCmd("SAVE")
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) shutdown(modifier string) *StatusCmd {
- var args []string
- if modifier == "" {
- args = []string{"SHUTDOWN"}
- } else {
- args = []string{"SHUTDOWN", modifier}
- }
- cmd := NewStatusCmd(args...)
- c.Process(cmd)
- if err := cmd.Err(); err != nil {
- if err == io.EOF {
- // Server quit as expected.
- cmd.err = nil
- }
- } else {
- // Server did not quit. String reply contains the reason.
- cmd.err = errorf(cmd.val)
- cmd.val = ""
- }
- return cmd
-}
-
-func (c *Client) Shutdown() *StatusCmd {
- return c.shutdown("")
-}
-
-func (c *Client) ShutdownSave() *StatusCmd {
- return c.shutdown("SAVE")
-}
-
-func (c *Client) ShutdownNoSave() *StatusCmd {
- return c.shutdown("NOSAVE")
-}
-
-func (c *Client) SlaveOf(host, port string) *StatusCmd {
- cmd := NewStatusCmd("SLAVEOF", host, port)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) SlowLog() {
- panic("not implemented")
-}
-
-func (c *Client) Sync() {
- panic("not implemented")
-}
-
-func (c *Client) Time() *StringSliceCmd {
- cmd := NewStringSliceCmd("TIME")
- c.Process(cmd)
- return cmd
-}
-
-//------------------------------------------------------------------------------
-
-func (c *Client) Eval(script string, keys []string, args []string) *Cmd {
- cmdArgs := []string{"EVAL", script, strconv.FormatInt(int64(len(keys)), 10)}
- cmdArgs = append(cmdArgs, keys...)
- cmdArgs = append(cmdArgs, args...)
- cmd := NewCmd(cmdArgs...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) EvalSha(sha1 string, keys []string, args []string) *Cmd {
- cmdArgs := []string{"EVALSHA", sha1, strconv.FormatInt(int64(len(keys)), 10)}
- cmdArgs = append(cmdArgs, keys...)
- cmdArgs = append(cmdArgs, args...)
- cmd := NewCmd(cmdArgs...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) ScriptExists(scripts ...string) *BoolSliceCmd {
- args := append([]string{"SCRIPT", "EXISTS"}, scripts...)
- cmd := NewBoolSliceCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) ScriptFlush() *StatusCmd {
- cmd := NewStatusCmd("SCRIPT", "FLUSH")
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) ScriptKill() *StatusCmd {
- cmd := NewStatusCmd("SCRIPT", "KILL")
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) ScriptLoad(script string) *StringCmd {
- cmd := NewStringCmd("SCRIPT", "LOAD", script)
- c.Process(cmd)
- return cmd
-}
-
-//------------------------------------------------------------------------------
-
-func (c *Client) DebugObject(key string) *StringCmd {
- cmd := NewStringCmd("DEBUG", "OBJECT", key)
- c.Process(cmd)
- return cmd
-}
-
-//------------------------------------------------------------------------------
-
-func (c *Client) PubSubChannels(pattern string) *StringSliceCmd {
- args := []string{"PUBSUB", "CHANNELS"}
- if pattern != "*" {
- args = append(args, pattern)
- }
- cmd := NewStringSliceCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) PubSubNumSub(channels ...string) *SliceCmd {
- args := []string{"PUBSUB", "NUMSUB"}
- args = append(args, channels...)
- cmd := NewSliceCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Client) PubSubNumPat() *IntCmd {
- cmd := NewIntCmd("PUBSUB", "NUMPAT")
- c.Process(cmd)
- return cmd
-}
diff --git a/vendor/gopkg.in/redis.v2/doc.go b/vendor/gopkg.in/redis.v2/doc.go
deleted file mode 100644
index 55262533a6..0000000000
--- a/vendor/gopkg.in/redis.v2/doc.go
+++ /dev/null
@@ -1,4 +0,0 @@
-/*
-Package redis implements a Redis client.
-*/
-package redis
diff --git a/vendor/gopkg.in/redis.v2/error.go b/vendor/gopkg.in/redis.v2/error.go
deleted file mode 100644
index 667fffdc68..0000000000
--- a/vendor/gopkg.in/redis.v2/error.go
+++ /dev/null
@@ -1,23 +0,0 @@
-package redis
-
-import (
- "fmt"
-)
-
-// Redis nil reply.
-var Nil = errorf("redis: nil")
-
-// Redis transaction failed.
-var TxFailedErr = errorf("redis: transaction failed")
-
-type redisError struct {
- s string
-}
-
-func errorf(s string, args ...interface{}) redisError {
- return redisError{s: fmt.Sprintf(s, args...)}
-}
-
-func (err redisError) Error() string {
- return err.s
-}
diff --git a/vendor/gopkg.in/redis.v2/multi.go b/vendor/gopkg.in/redis.v2/multi.go
deleted file mode 100644
index bff38dfaaa..0000000000
--- a/vendor/gopkg.in/redis.v2/multi.go
+++ /dev/null
@@ -1,138 +0,0 @@
-package redis
-
-import (
- "errors"
- "fmt"
-)
-
-var errDiscard = errors.New("redis: Discard can be used only inside Exec")
-
-// Not thread-safe.
-type Multi struct {
- *Client
-}
-
-func (c *Client) Multi() *Multi {
- return &Multi{
- Client: &Client{
- baseClient: &baseClient{
- opt: c.opt,
- connPool: newSingleConnPool(c.connPool, true),
- },
- },
- }
-}
-
-func (c *Multi) Close() error {
- if err := c.Unwatch().Err(); err != nil {
- return err
- }
- return c.Client.Close()
-}
-
-func (c *Multi) Watch(keys ...string) *StatusCmd {
- args := append([]string{"WATCH"}, keys...)
- cmd := NewStatusCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Multi) Unwatch(keys ...string) *StatusCmd {
- args := append([]string{"UNWATCH"}, keys...)
- cmd := NewStatusCmd(args...)
- c.Process(cmd)
- return cmd
-}
-
-func (c *Multi) Discard() error {
- if c.cmds == nil {
- return errDiscard
- }
- c.cmds = c.cmds[:1]
- return nil
-}
-
-// Exec always returns list of commands. If transaction fails
-// TxFailedErr is returned. Otherwise Exec returns error of the first
-// failed command or nil.
-func (c *Multi) Exec(f func() error) ([]Cmder, error) {
- c.cmds = []Cmder{NewStatusCmd("MULTI")}
- if err := f(); err != nil {
- return nil, err
- }
- c.cmds = append(c.cmds, NewSliceCmd("EXEC"))
-
- cmds := c.cmds
- c.cmds = nil
-
- if len(cmds) == 2 {
- return []Cmder{}, nil
- }
-
- cn, err := c.conn()
- if err != nil {
- setCmdsErr(cmds[1:len(cmds)-1], err)
- return cmds[1 : len(cmds)-1], err
- }
-
- err = c.execCmds(cn, cmds)
- if err != nil {
- c.freeConn(cn, err)
- return cmds[1 : len(cmds)-1], err
- }
-
- c.putConn(cn)
- return cmds[1 : len(cmds)-1], nil
-}
-
-func (c *Multi) execCmds(cn *conn, cmds []Cmder) error {
- err := c.writeCmd(cn, cmds...)
- if err != nil {
- setCmdsErr(cmds[1:len(cmds)-1], err)
- return err
- }
-
- statusCmd := NewStatusCmd()
-
- // Omit last command (EXEC).
- cmdsLen := len(cmds) - 1
-
- // Parse queued replies.
- for i := 0; i < cmdsLen; i++ {
- if err := statusCmd.parseReply(cn.rd); err != nil {
- setCmdsErr(cmds[1:len(cmds)-1], err)
- return err
- }
- }
-
- // Parse number of replies.
- line, err := readLine(cn.rd)
- if err != nil {
- setCmdsErr(cmds[1:len(cmds)-1], err)
- return err
- }
- if line[0] != '*' {
- err := fmt.Errorf("redis: expected '*', but got line %q", line)
- setCmdsErr(cmds[1:len(cmds)-1], err)
- return err
- }
- if len(line) == 3 && line[1] == '-' && line[2] == '1' {
- setCmdsErr(cmds[1:len(cmds)-1], TxFailedErr)
- return TxFailedErr
- }
-
- var firstCmdErr error
-
- // Parse replies.
- // Loop starts from 1 to omit MULTI cmd.
- for i := 1; i < cmdsLen; i++ {
- cmd := cmds[i]
- if err := cmd.parseReply(cn.rd); err != nil {
- if firstCmdErr == nil {
- firstCmdErr = err
- }
- }
- }
-
- return firstCmdErr
-}
diff --git a/vendor/gopkg.in/redis.v2/parser.go b/vendor/gopkg.in/redis.v2/parser.go
deleted file mode 100644
index b4c380c764..0000000000
--- a/vendor/gopkg.in/redis.v2/parser.go
+++ /dev/null
@@ -1,262 +0,0 @@
-package redis
-
-import (
- "errors"
- "fmt"
- "strconv"
-
- "gopkg.in/bufio.v1"
-)
-
-type multiBulkParser func(rd *bufio.Reader, n int64) (interface{}, error)
-
-var (
- errReaderTooSmall = errors.New("redis: reader is too small")
-)
-
-//------------------------------------------------------------------------------
-
-func appendArgs(buf []byte, args []string) []byte {
- buf = append(buf, '*')
- buf = strconv.AppendUint(buf, uint64(len(args)), 10)
- buf = append(buf, '\r', '\n')
- for _, arg := range args {
- buf = append(buf, '$')
- buf = strconv.AppendUint(buf, uint64(len(arg)), 10)
- buf = append(buf, '\r', '\n')
- buf = append(buf, arg...)
- buf = append(buf, '\r', '\n')
- }
- return buf
-}
-
-//------------------------------------------------------------------------------
-
-func readLine(rd *bufio.Reader) ([]byte, error) {
- line, isPrefix, err := rd.ReadLine()
- if err != nil {
- return line, err
- }
- if isPrefix {
- return line, errReaderTooSmall
- }
- return line, nil
-}
-
-func readN(rd *bufio.Reader, n int) ([]byte, error) {
- b, err := rd.ReadN(n)
- if err == bufio.ErrBufferFull {
- tmp := make([]byte, n)
- r := copy(tmp, b)
- b = tmp
-
- for {
- nn, err := rd.Read(b[r:])
- r += nn
- if r >= n {
- // Ignore error if we read enough.
- break
- }
- if err != nil {
- return nil, err
- }
- }
- } else if err != nil {
- return nil, err
- }
- return b, nil
-}
-
-//------------------------------------------------------------------------------
-
-func parseReq(rd *bufio.Reader) ([]string, error) {
- line, err := readLine(rd)
- if err != nil {
- return nil, err
- }
-
- if line[0] != '*' {
- return []string{string(line)}, nil
- }
- numReplies, err := strconv.ParseInt(string(line[1:]), 10, 64)
- if err != nil {
- return nil, err
- }
-
- args := make([]string, 0, numReplies)
- for i := int64(0); i < numReplies; i++ {
- line, err = readLine(rd)
- if err != nil {
- return nil, err
- }
- if line[0] != '$' {
- return nil, fmt.Errorf("redis: expected '$', but got %q", line)
- }
-
- argLen, err := strconv.ParseInt(string(line[1:]), 10, 32)
- if err != nil {
- return nil, err
- }
-
- arg, err := readN(rd, int(argLen)+2)
- if err != nil {
- return nil, err
- }
- args = append(args, string(arg[:argLen]))
- }
- return args, nil
-}
-
-//------------------------------------------------------------------------------
-
-func parseReply(rd *bufio.Reader, p multiBulkParser) (interface{}, error) {
- line, err := readLine(rd)
- if err != nil {
- return nil, err
- }
-
- switch line[0] {
- case '-':
- return nil, errorf(string(line[1:]))
- case '+':
- return string(line[1:]), nil
- case ':':
- v, err := strconv.ParseInt(string(line[1:]), 10, 64)
- if err != nil {
- return nil, err
- }
- return v, nil
- case '$':
- if len(line) == 3 && line[1] == '-' && line[2] == '1' {
- return nil, Nil
- }
-
- replyLen, err := strconv.Atoi(string(line[1:]))
- if err != nil {
- return nil, err
- }
-
- b, err := readN(rd, replyLen+2)
- if err != nil {
- return nil, err
- }
- return string(b[:replyLen]), nil
- case '*':
- if len(line) == 3 && line[1] == '-' && line[2] == '1' {
- return nil, Nil
- }
-
- repliesNum, err := strconv.ParseInt(string(line[1:]), 10, 64)
- if err != nil {
- return nil, err
- }
-
- return p(rd, repliesNum)
- }
- return nil, fmt.Errorf("redis: can't parse %q", line)
-}
-
-func parseSlice(rd *bufio.Reader, n int64) (interface{}, error) {
- vals := make([]interface{}, 0, n)
- for i := int64(0); i < n; i++ {
- v, err := parseReply(rd, parseSlice)
- if err == Nil {
- vals = append(vals, nil)
- } else if err != nil {
- return nil, err
- } else {
- vals = append(vals, v)
- }
- }
- return vals, nil
-}
-
-func parseStringSlice(rd *bufio.Reader, n int64) (interface{}, error) {
- vals := make([]string, 0, n)
- for i := int64(0); i < n; i++ {
- viface, err := parseReply(rd, nil)
- if err != nil {
- return nil, err
- }
- v, ok := viface.(string)
- if !ok {
- return nil, fmt.Errorf("got %T, expected string", viface)
- }
- vals = append(vals, v)
- }
- return vals, nil
-}
-
-func parseBoolSlice(rd *bufio.Reader, n int64) (interface{}, error) {
- vals := make([]bool, 0, n)
- for i := int64(0); i < n; i++ {
- viface, err := parseReply(rd, nil)
- if err != nil {
- return nil, err
- }
- v, ok := viface.(int64)
- if !ok {
- return nil, fmt.Errorf("got %T, expected int64", viface)
- }
- vals = append(vals, v == 1)
- }
- return vals, nil
-}
-
-func parseStringStringMap(rd *bufio.Reader, n int64) (interface{}, error) {
- m := make(map[string]string, n/2)
- for i := int64(0); i < n; i += 2 {
- keyiface, err := parseReply(rd, nil)
- if err != nil {
- return nil, err
- }
- key, ok := keyiface.(string)
- if !ok {
- return nil, fmt.Errorf("got %T, expected string", keyiface)
- }
-
- valueiface, err := parseReply(rd, nil)
- if err != nil {
- return nil, err
- }
- value, ok := valueiface.(string)
- if !ok {
- return nil, fmt.Errorf("got %T, expected string", valueiface)
- }
-
- m[key] = value
- }
- return m, nil
-}
-
-func parseZSlice(rd *bufio.Reader, n int64) (interface{}, error) {
- zz := make([]Z, n/2)
- for i := int64(0); i < n; i += 2 {
- z := &zz[i/2]
-
- memberiface, err := parseReply(rd, nil)
- if err != nil {
- return nil, err
- }
- member, ok := memberiface.(string)
- if !ok {
- return nil, fmt.Errorf("got %T, expected string", memberiface)
- }
- z.Member = member
-
- scoreiface, err := parseReply(rd, nil)
- if err != nil {
- return nil, err
- }
- scorestr, ok := scoreiface.(string)
- if !ok {
- return nil, fmt.Errorf("got %T, expected string", scoreiface)
- }
- score, err := strconv.ParseFloat(scorestr, 64)
- if err != nil {
- return nil, err
- }
- z.Score = score
- }
- return zz, nil
-}
diff --git a/vendor/gopkg.in/redis.v2/pipeline.go b/vendor/gopkg.in/redis.v2/pipeline.go
deleted file mode 100644
index 540d6c51d9..0000000000
--- a/vendor/gopkg.in/redis.v2/pipeline.go
+++ /dev/null
@@ -1,91 +0,0 @@
-package redis
-
-// Not thread-safe.
-type Pipeline struct {
- *Client
-
- closed bool
-}
-
-func (c *Client) Pipeline() *Pipeline {
- return &Pipeline{
- Client: &Client{
- baseClient: &baseClient{
- opt: c.opt,
- connPool: c.connPool,
-
- cmds: make([]Cmder, 0),
- },
- },
- }
-}
-
-func (c *Client) Pipelined(f func(*Pipeline) error) ([]Cmder, error) {
- pc := c.Pipeline()
- if err := f(pc); err != nil {
- return nil, err
- }
- cmds, err := pc.Exec()
- pc.Close()
- return cmds, err
-}
-
-func (c *Pipeline) Close() error {
- c.closed = true
- return nil
-}
-
-func (c *Pipeline) Discard() error {
- if c.closed {
- return errClosed
- }
- c.cmds = c.cmds[:0]
- return nil
-}
-
-// Exec always returns list of commands and error of the first failed
-// command if any.
-func (c *Pipeline) Exec() ([]Cmder, error) {
- if c.closed {
- return nil, errClosed
- }
-
- cmds := c.cmds
- c.cmds = make([]Cmder, 0)
-
- if len(cmds) == 0 {
- return []Cmder{}, nil
- }
-
- cn, err := c.conn()
- if err != nil {
- setCmdsErr(cmds, err)
- return cmds, err
- }
-
- if err := c.execCmds(cn, cmds); err != nil {
- c.freeConn(cn, err)
- return cmds, err
- }
-
- c.putConn(cn)
- return cmds, nil
-}
-
-func (c *Pipeline) execCmds(cn *conn, cmds []Cmder) error {
- if err := c.writeCmd(cn, cmds...); err != nil {
- setCmdsErr(cmds, err)
- return err
- }
-
- var firstCmdErr error
- for _, cmd := range cmds {
- if err := cmd.parseReply(cn.rd); err != nil {
- if firstCmdErr == nil {
- firstCmdErr = err
- }
- }
- }
-
- return firstCmdErr
-}
diff --git a/vendor/gopkg.in/redis.v2/pool.go b/vendor/gopkg.in/redis.v2/pool.go
deleted file mode 100644
index bca4d19633..0000000000
--- a/vendor/gopkg.in/redis.v2/pool.go
+++ /dev/null
@@ -1,405 +0,0 @@
-package redis
-
-import (
- "container/list"
- "errors"
- "log"
- "net"
- "sync"
- "time"
-
- "gopkg.in/bufio.v1"
-)
-
-var (
- errClosed = errors.New("redis: client is closed")
- errRateLimited = errors.New("redis: you open connections too fast")
-)
-
-var (
- zeroTime = time.Time{}
-)
-
-type pool interface {
- Get() (*conn, bool, error)
- Put(*conn) error
- Remove(*conn) error
- Len() int
- Size() int
- Close() error
- Filter(func(*conn) bool)
-}
-
-//------------------------------------------------------------------------------
-
-type conn struct {
- netcn net.Conn
- rd *bufio.Reader
- buf []byte
-
- inUse bool
- usedAt time.Time
-
- readTimeout time.Duration
- writeTimeout time.Duration
-
- elem *list.Element
-}
-
-func newConnFunc(dial func() (net.Conn, error)) func() (*conn, error) {
- return func() (*conn, error) {
- netcn, err := dial()
- if err != nil {
- return nil, err
- }
- cn := &conn{
- netcn: netcn,
- buf: make([]byte, 0, 64),
- }
- cn.rd = bufio.NewReader(cn)
- return cn, nil
- }
-}
-
-func (cn *conn) Read(b []byte) (int, error) {
- if cn.readTimeout != 0 {
- cn.netcn.SetReadDeadline(time.Now().Add(cn.readTimeout))
- } else {
- cn.netcn.SetReadDeadline(zeroTime)
- }
- return cn.netcn.Read(b)
-}
-
-func (cn *conn) Write(b []byte) (int, error) {
- if cn.writeTimeout != 0 {
- cn.netcn.SetWriteDeadline(time.Now().Add(cn.writeTimeout))
- } else {
- cn.netcn.SetWriteDeadline(zeroTime)
- }
- return cn.netcn.Write(b)
-}
-
-func (cn *conn) RemoteAddr() net.Addr {
- return cn.netcn.RemoteAddr()
-}
-
-func (cn *conn) Close() error {
- return cn.netcn.Close()
-}
-
-//------------------------------------------------------------------------------
-
-type connPool struct {
- dial func() (*conn, error)
- rl *rateLimiter
-
- opt *options
-
- cond *sync.Cond
- conns *list.List
-
- idleNum int
- closed bool
-}
-
-func newConnPool(dial func() (*conn, error), opt *options) *connPool {
- return &connPool{
- dial: dial,
- rl: newRateLimiter(time.Second, 2*opt.PoolSize),
-
- opt: opt,
-
- cond: sync.NewCond(&sync.Mutex{}),
- conns: list.New(),
- }
-}
-
-func (p *connPool) new() (*conn, error) {
- if !p.rl.Check() {
- return nil, errRateLimited
- }
- return p.dial()
-}
-
-func (p *connPool) Get() (*conn, bool, error) {
- p.cond.L.Lock()
-
- if p.closed {
- p.cond.L.Unlock()
- return nil, false, errClosed
- }
-
- if p.opt.IdleTimeout > 0 {
- for el := p.conns.Front(); el != nil; el = el.Next() {
- cn := el.Value.(*conn)
- if cn.inUse {
- break
- }
- if time.Since(cn.usedAt) > p.opt.IdleTimeout {
- if err := p.remove(cn); err != nil {
- log.Printf("remove failed: %s", err)
- }
- }
- }
- }
-
- for p.conns.Len() >= p.opt.PoolSize && p.idleNum == 0 {
- p.cond.Wait()
- }
-
- if p.idleNum > 0 {
- elem := p.conns.Front()
- cn := elem.Value.(*conn)
- if cn.inUse {
- panic("pool: precondition failed")
- }
- cn.inUse = true
- p.conns.MoveToBack(elem)
- p.idleNum--
-
- p.cond.L.Unlock()
- return cn, false, nil
- }
-
- if p.conns.Len() < p.opt.PoolSize {
- cn, err := p.new()
- if err != nil {
- p.cond.L.Unlock()
- return nil, false, err
- }
-
- cn.inUse = true
- cn.elem = p.conns.PushBack(cn)
-
- p.cond.L.Unlock()
- return cn, true, nil
- }
-
- panic("not reached")
-}
-
-func (p *connPool) Put(cn *conn) error {
- if cn.rd.Buffered() != 0 {
- b, _ := cn.rd.ReadN(cn.rd.Buffered())
- log.Printf("redis: connection has unread data: %q", b)
- return p.Remove(cn)
- }
-
- if p.opt.IdleTimeout > 0 {
- cn.usedAt = time.Now()
- }
-
- p.cond.L.Lock()
- if p.closed {
- p.cond.L.Unlock()
- return errClosed
- }
- cn.inUse = false
- p.conns.MoveToFront(cn.elem)
- p.idleNum++
- p.cond.Signal()
- p.cond.L.Unlock()
-
- return nil
-}
-
-func (p *connPool) Remove(cn *conn) error {
- p.cond.L.Lock()
- if p.closed {
- // Noop, connection is already closed.
- p.cond.L.Unlock()
- return nil
- }
- err := p.remove(cn)
- p.cond.Signal()
- p.cond.L.Unlock()
- return err
-}
-
-func (p *connPool) remove(cn *conn) error {
- p.conns.Remove(cn.elem)
- cn.elem = nil
- if !cn.inUse {
- p.idleNum--
- }
- return cn.Close()
-}
-
-// Len returns number of idle connections.
-func (p *connPool) Len() int {
- defer p.cond.L.Unlock()
- p.cond.L.Lock()
- return p.idleNum
-}
-
-// Size returns number of connections in the pool.
-func (p *connPool) Size() int {
- defer p.cond.L.Unlock()
- p.cond.L.Lock()
- return p.conns.Len()
-}
-
-func (p *connPool) Filter(f func(*conn) bool) {
- p.cond.L.Lock()
- for el, next := p.conns.Front(), p.conns.Front(); el != nil; el = next {
- next = el.Next()
- cn := el.Value.(*conn)
- if !f(cn) {
- p.remove(cn)
- }
- }
- p.cond.L.Unlock()
-}
-
-func (p *connPool) Close() error {
- defer p.cond.L.Unlock()
- p.cond.L.Lock()
- if p.closed {
- return nil
- }
- p.closed = true
- p.rl.Close()
- var retErr error
- for {
- e := p.conns.Front()
- if e == nil {
- break
- }
- if err := p.remove(e.Value.(*conn)); err != nil {
- log.Printf("cn.Close failed: %s", err)
- retErr = err
- }
- }
- return retErr
-}
-
-//------------------------------------------------------------------------------
-
-type singleConnPool struct {
- pool pool
-
- cnMtx sync.Mutex
- cn *conn
-
- reusable bool
-
- closed bool
-}
-
-func newSingleConnPool(pool pool, reusable bool) *singleConnPool {
- return &singleConnPool{
- pool: pool,
- reusable: reusable,
- }
-}
-
-func (p *singleConnPool) SetConn(cn *conn) {
- p.cnMtx.Lock()
- p.cn = cn
- p.cnMtx.Unlock()
-}
-
-func (p *singleConnPool) Get() (*conn, bool, error) {
- defer p.cnMtx.Unlock()
- p.cnMtx.Lock()
-
- if p.closed {
- return nil, false, errClosed
- }
- if p.cn != nil {
- return p.cn, false, nil
- }
-
- cn, isNew, err := p.pool.Get()
- if err != nil {
- return nil, false, err
- }
- p.cn = cn
-
- return p.cn, isNew, nil
-}
-
-func (p *singleConnPool) Put(cn *conn) error {
- defer p.cnMtx.Unlock()
- p.cnMtx.Lock()
- if p.cn != cn {
- panic("p.cn != cn")
- }
- if p.closed {
- return errClosed
- }
- return nil
-}
-
-func (p *singleConnPool) put() error {
- err := p.pool.Put(p.cn)
- p.cn = nil
- return err
-}
-
-func (p *singleConnPool) Remove(cn *conn) error {
- defer p.cnMtx.Unlock()
- p.cnMtx.Lock()
- if p.cn == nil {
- panic("p.cn == nil")
- }
- if p.cn != cn {
- panic("p.cn != cn")
- }
- if p.closed {
- return errClosed
- }
- return p.remove()
-}
-
-func (p *singleConnPool) remove() error {
- err := p.pool.Remove(p.cn)
- p.cn = nil
- return err
-}
-
-func (p *singleConnPool) Len() int {
- defer p.cnMtx.Unlock()
- p.cnMtx.Lock()
- if p.cn == nil {
- return 0
- }
- return 1
-}
-
-func (p *singleConnPool) Size() int {
- defer p.cnMtx.Unlock()
- p.cnMtx.Lock()
- if p.cn == nil {
- return 0
- }
- return 1
-}
-
-func (p *singleConnPool) Filter(f func(*conn) bool) {
- p.cnMtx.Lock()
- if p.cn != nil {
- if !f(p.cn) {
- p.remove()
- }
- }
- p.cnMtx.Unlock()
-}
-
-func (p *singleConnPool) Close() error {
- defer p.cnMtx.Unlock()
- p.cnMtx.Lock()
- if p.closed {
- return nil
- }
- p.closed = true
- var err error
- if p.cn != nil {
- if p.reusable {
- err = p.put()
- } else {
- err = p.remove()
- }
- }
- return err
-}
diff --git a/vendor/gopkg.in/redis.v2/pubsub.go b/vendor/gopkg.in/redis.v2/pubsub.go
deleted file mode 100644
index 6ac130bac4..0000000000
--- a/vendor/gopkg.in/redis.v2/pubsub.go
+++ /dev/null
@@ -1,134 +0,0 @@
-package redis
-
-import (
- "fmt"
- "time"
-)
-
-// Not thread-safe.
-type PubSub struct {
- *baseClient
-}
-
-func (c *Client) PubSub() *PubSub {
- return &PubSub{
- baseClient: &baseClient{
- opt: c.opt,
- connPool: newSingleConnPool(c.connPool, false),
- },
- }
-}
-
-func (c *Client) Publish(channel, message string) *IntCmd {
- req := NewIntCmd("PUBLISH", channel, message)
- c.Process(req)
- return req
-}
-
-type Message struct {
- Channel string
- Payload string
-}
-
-func (m *Message) String() string {
- return fmt.Sprintf("Message<%s: %s>", m.Channel, m.Payload)
-}
-
-type PMessage struct {
- Channel string
- Pattern string
- Payload string
-}
-
-func (m *PMessage) String() string {
- return fmt.Sprintf("PMessage<%s: %s>", m.Channel, m.Payload)
-}
-
-type Subscription struct {
- Kind string
- Channel string
- Count int
-}
-
-func (m *Subscription) String() string {
- return fmt.Sprintf("%s: %s", m.Kind, m.Channel)
-}
-
-func (c *PubSub) Receive() (interface{}, error) {
- return c.ReceiveTimeout(0)
-}
-
-func (c *PubSub) ReceiveTimeout(timeout time.Duration) (interface{}, error) {
- cn, err := c.conn()
- if err != nil {
- return nil, err
- }
- cn.readTimeout = timeout
-
- cmd := NewSliceCmd()
- if err := cmd.parseReply(cn.rd); err != nil {
- return nil, err
- }
-
- reply := cmd.Val()
-
- msgName := reply[0].(string)
- switch msgName {
- case "subscribe", "unsubscribe", "psubscribe", "punsubscribe":
- return &Subscription{
- Kind: msgName,
- Channel: reply[1].(string),
- Count: int(reply[2].(int64)),
- }, nil
- case "message":
- return &Message{
- Channel: reply[1].(string),
- Payload: reply[2].(string),
- }, nil
- case "pmessage":
- return &PMessage{
- Pattern: reply[1].(string),
- Channel: reply[2].(string),
- Payload: reply[3].(string),
- }, nil
- }
- return nil, fmt.Errorf("redis: unsupported message name: %q", msgName)
-}
-
-func (c *PubSub) subscribe(cmd string, channels ...string) error {
- cn, err := c.conn()
- if err != nil {
- return err
- }
-
- args := append([]string{cmd}, channels...)
- req := NewSliceCmd(args...)
- return c.writeCmd(cn, req)
-}
-
-func (c *PubSub) Subscribe(channels ...string) error {
- return c.subscribe("SUBSCRIBE", channels...)
-}
-
-func (c *PubSub) PSubscribe(patterns ...string) error {
- return c.subscribe("PSUBSCRIBE", patterns...)
-}
-
-func (c *PubSub) unsubscribe(cmd string, channels ...string) error {
- cn, err := c.conn()
- if err != nil {
- return err
- }
-
- args := append([]string{cmd}, channels...)
- req := NewSliceCmd(args...)
- return c.writeCmd(cn, req)
-}
-
-func (c *PubSub) Unsubscribe(channels ...string) error {
- return c.unsubscribe("UNSUBSCRIBE", channels...)
-}
-
-func (c *PubSub) PUnsubscribe(patterns ...string) error {
- return c.unsubscribe("PUNSUBSCRIBE", patterns...)
-}
diff --git a/vendor/gopkg.in/redis.v2/rate_limit.go b/vendor/gopkg.in/redis.v2/rate_limit.go
deleted file mode 100644
index 20d8512707..0000000000
--- a/vendor/gopkg.in/redis.v2/rate_limit.go
+++ /dev/null
@@ -1,53 +0,0 @@
-package redis
-
-import (
- "sync/atomic"
- "time"
-)
-
-type rateLimiter struct {
- v int64
-
- _closed int64
-}
-
-func newRateLimiter(limit time.Duration, bucketSize int) *rateLimiter {
- rl := &rateLimiter{
- v: int64(bucketSize),
- }
- go rl.loop(limit, int64(bucketSize))
- return rl
-}
-
-func (rl *rateLimiter) loop(limit time.Duration, bucketSize int64) {
- for {
- if rl.closed() {
- break
- }
- if v := atomic.LoadInt64(&rl.v); v < bucketSize {
- atomic.AddInt64(&rl.v, 1)
- }
- time.Sleep(limit)
- }
-}
-
-func (rl *rateLimiter) Check() bool {
- for {
- if v := atomic.LoadInt64(&rl.v); v > 0 {
- if atomic.CompareAndSwapInt64(&rl.v, v, v-1) {
- return true
- }
- } else {
- return false
- }
- }
-}
-
-func (rl *rateLimiter) Close() error {
- atomic.StoreInt64(&rl._closed, 1)
- return nil
-}
-
-func (rl *rateLimiter) closed() bool {
- return atomic.LoadInt64(&rl._closed) == 1
-}
diff --git a/vendor/gopkg.in/redis.v2/redis.go b/vendor/gopkg.in/redis.v2/redis.go
deleted file mode 100644
index 0d15dc8f85..0000000000
--- a/vendor/gopkg.in/redis.v2/redis.go
+++ /dev/null
@@ -1,231 +0,0 @@
-package redis
-
-import (
- "log"
- "net"
- "time"
-)
-
-type baseClient struct {
- connPool pool
- opt *options
- cmds []Cmder
-}
-
-func (c *baseClient) writeCmd(cn *conn, cmds ...Cmder) error {
- buf := cn.buf[:0]
- for _, cmd := range cmds {
- buf = appendArgs(buf, cmd.args())
- }
-
- _, err := cn.Write(buf)
- return err
-}
-
-func (c *baseClient) conn() (*conn, error) {
- cn, isNew, err := c.connPool.Get()
- if err != nil {
- return nil, err
- }
-
- if isNew {
- if err := c.initConn(cn); err != nil {
- c.removeConn(cn)
- return nil, err
- }
- }
-
- return cn, nil
-}
-
-func (c *baseClient) initConn(cn *conn) error {
- if c.opt.Password == "" && c.opt.DB == 0 {
- return nil
- }
-
- pool := newSingleConnPool(c.connPool, false)
- pool.SetConn(cn)
-
- // Client is not closed because we want to reuse underlying connection.
- client := &Client{
- baseClient: &baseClient{
- opt: c.opt,
- connPool: pool,
- },
- }
-
- if c.opt.Password != "" {
- if err := client.Auth(c.opt.Password).Err(); err != nil {
- return err
- }
- }
-
- if c.opt.DB > 0 {
- if err := client.Select(c.opt.DB).Err(); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-func (c *baseClient) freeConn(cn *conn, ei error) error {
- if cn.rd.Buffered() > 0 {
- return c.connPool.Remove(cn)
- }
- if _, ok := ei.(redisError); ok {
- return c.connPool.Put(cn)
- }
- return c.connPool.Remove(cn)
-}
-
-func (c *baseClient) removeConn(cn *conn) {
- if err := c.connPool.Remove(cn); err != nil {
- log.Printf("pool.Remove failed: %s", err)
- }
-}
-
-func (c *baseClient) putConn(cn *conn) {
- if err := c.connPool.Put(cn); err != nil {
- log.Printf("pool.Put failed: %s", err)
- }
-}
-
-func (c *baseClient) Process(cmd Cmder) {
- if c.cmds == nil {
- c.run(cmd)
- } else {
- c.cmds = append(c.cmds, cmd)
- }
-}
-
-func (c *baseClient) run(cmd Cmder) {
- cn, err := c.conn()
- if err != nil {
- cmd.setErr(err)
- return
- }
-
- if timeout := cmd.writeTimeout(); timeout != nil {
- cn.writeTimeout = *timeout
- } else {
- cn.writeTimeout = c.opt.WriteTimeout
- }
-
- if timeout := cmd.readTimeout(); timeout != nil {
- cn.readTimeout = *timeout
- } else {
- cn.readTimeout = c.opt.ReadTimeout
- }
-
- if err := c.writeCmd(cn, cmd); err != nil {
- c.freeConn(cn, err)
- cmd.setErr(err)
- return
- }
-
- if err := cmd.parseReply(cn.rd); err != nil {
- c.freeConn(cn, err)
- return
- }
-
- c.putConn(cn)
-}
-
-// Close closes the client, releasing any open resources.
-func (c *baseClient) Close() error {
- return c.connPool.Close()
-}
-
-//------------------------------------------------------------------------------
-
-type options struct {
- Password string
- DB int64
-
- DialTimeout time.Duration
- ReadTimeout time.Duration
- WriteTimeout time.Duration
-
- PoolSize int
- IdleTimeout time.Duration
-}
-
-type Options struct {
- Network string
- Addr string
-
- // Dialer creates new network connection and has priority over
- // Network and Addr options.
- Dialer func() (net.Conn, error)
-
- Password string
- DB int64
-
- DialTimeout time.Duration
- ReadTimeout time.Duration
- WriteTimeout time.Duration
-
- PoolSize int
- IdleTimeout time.Duration
-}
-
-func (opt *Options) getPoolSize() int {
- if opt.PoolSize == 0 {
- return 10
- }
- return opt.PoolSize
-}
-
-func (opt *Options) getDialTimeout() time.Duration {
- if opt.DialTimeout == 0 {
- return 5 * time.Second
- }
- return opt.DialTimeout
-}
-
-func (opt *Options) options() *options {
- return &options{
- DB: opt.DB,
- Password: opt.Password,
-
- DialTimeout: opt.getDialTimeout(),
- ReadTimeout: opt.ReadTimeout,
- WriteTimeout: opt.WriteTimeout,
-
- PoolSize: opt.getPoolSize(),
- IdleTimeout: opt.IdleTimeout,
- }
-}
-
-type Client struct {
- *baseClient
-}
-
-func NewClient(clOpt *Options) *Client {
- opt := clOpt.options()
- dialer := clOpt.Dialer
- if dialer == nil {
- dialer = func() (net.Conn, error) {
- return net.DialTimeout(clOpt.Network, clOpt.Addr, opt.DialTimeout)
- }
- }
- return &Client{
- baseClient: &baseClient{
- opt: opt,
- connPool: newConnPool(newConnFunc(dialer), opt),
- },
- }
-}
-
-// Deprecated. Use NewClient instead.
-func NewTCPClient(opt *Options) *Client {
- opt.Network = "tcp"
- return NewClient(opt)
-}
-
-// Deprecated. Use NewClient instead.
-func NewUnixClient(opt *Options) *Client {
- opt.Network = "unix"
- return NewClient(opt)
-}
diff --git a/vendor/gopkg.in/redis.v2/script.go b/vendor/gopkg.in/redis.v2/script.go
deleted file mode 100644
index 96c35f5149..0000000000
--- a/vendor/gopkg.in/redis.v2/script.go
+++ /dev/null
@@ -1,52 +0,0 @@
-package redis
-
-import (
- "crypto/sha1"
- "encoding/hex"
- "io"
- "strings"
-)
-
-type scripter interface {
- Eval(script string, keys []string, args []string) *Cmd
- EvalSha(sha1 string, keys []string, args []string) *Cmd
- ScriptExists(scripts ...string) *BoolSliceCmd
- ScriptLoad(script string) *StringCmd
-}
-
-type Script struct {
- src, hash string
-}
-
-func NewScript(src string) *Script {
- h := sha1.New()
- io.WriteString(h, src)
- return &Script{
- src: src,
- hash: hex.EncodeToString(h.Sum(nil)),
- }
-}
-
-func (s *Script) Load(c scripter) *StringCmd {
- return c.ScriptLoad(s.src)
-}
-
-func (s *Script) Exists(c scripter) *BoolSliceCmd {
- return c.ScriptExists(s.src)
-}
-
-func (s *Script) Eval(c scripter, keys []string, args []string) *Cmd {
- return c.Eval(s.src, keys, args)
-}
-
-func (s *Script) EvalSha(c scripter, keys []string, args []string) *Cmd {
- return c.EvalSha(s.hash, keys, args)
-}
-
-func (s *Script) Run(c *Client, keys []string, args []string) *Cmd {
- r := s.EvalSha(c, keys, args)
- if err := r.Err(); err != nil && strings.HasPrefix(err.Error(), "NOSCRIPT ") {
- return s.Eval(c, keys, args)
- }
- return r
-}
diff --git a/vendor/gopkg.in/redis.v2/sentinel.go b/vendor/gopkg.in/redis.v2/sentinel.go
deleted file mode 100644
index d3ffeca9a5..0000000000
--- a/vendor/gopkg.in/redis.v2/sentinel.go
+++ /dev/null
@@ -1,291 +0,0 @@
-package redis
-
-import (
- "errors"
- "log"
- "net"
- "strings"
- "sync"
- "time"
-)
-
-//------------------------------------------------------------------------------
-
-type FailoverOptions struct {
- MasterName string
- SentinelAddrs []string
-
- Password string
- DB int64
-
- PoolSize int
-
- DialTimeout time.Duration
- ReadTimeout time.Duration
- WriteTimeout time.Duration
- IdleTimeout time.Duration
-}
-
-func (opt *FailoverOptions) getPoolSize() int {
- if opt.PoolSize == 0 {
- return 10
- }
- return opt.PoolSize
-}
-
-func (opt *FailoverOptions) getDialTimeout() time.Duration {
- if opt.DialTimeout == 0 {
- return 5 * time.Second
- }
- return opt.DialTimeout
-}
-
-func (opt *FailoverOptions) options() *options {
- return &options{
- DB: opt.DB,
- Password: opt.Password,
-
- DialTimeout: opt.getDialTimeout(),
- ReadTimeout: opt.ReadTimeout,
- WriteTimeout: opt.WriteTimeout,
-
- PoolSize: opt.getPoolSize(),
- IdleTimeout: opt.IdleTimeout,
- }
-}
-
-func NewFailoverClient(failoverOpt *FailoverOptions) *Client {
- opt := failoverOpt.options()
- failover := &sentinelFailover{
- masterName: failoverOpt.MasterName,
- sentinelAddrs: failoverOpt.SentinelAddrs,
-
- opt: opt,
- }
- return &Client{
- baseClient: &baseClient{
- opt: opt,
- connPool: failover.Pool(),
- },
- }
-}
-
-//------------------------------------------------------------------------------
-
-type sentinelClient struct {
- *baseClient
-}
-
-func newSentinel(clOpt *Options) *sentinelClient {
- opt := clOpt.options()
- opt.Password = ""
- opt.DB = 0
- dialer := func() (net.Conn, error) {
- return net.DialTimeout("tcp", clOpt.Addr, opt.DialTimeout)
- }
- return &sentinelClient{
- baseClient: &baseClient{
- opt: opt,
- connPool: newConnPool(newConnFunc(dialer), opt),
- },
- }
-}
-
-func (c *sentinelClient) PubSub() *PubSub {
- return &PubSub{
- baseClient: &baseClient{
- opt: c.opt,
- connPool: newSingleConnPool(c.connPool, false),
- },
- }
-}
-
-func (c *sentinelClient) GetMasterAddrByName(name string) *StringSliceCmd {
- cmd := NewStringSliceCmd("SENTINEL", "get-master-addr-by-name", name)
- c.Process(cmd)
- return cmd
-}
-
-func (c *sentinelClient) Sentinels(name string) *SliceCmd {
- cmd := NewSliceCmd("SENTINEL", "sentinels", name)
- c.Process(cmd)
- return cmd
-}
-
-type sentinelFailover struct {
- masterName string
- sentinelAddrs []string
-
- opt *options
-
- pool pool
- poolOnce sync.Once
-
- lock sync.RWMutex
- _sentinel *sentinelClient
-}
-
-func (d *sentinelFailover) dial() (net.Conn, error) {
- addr, err := d.MasterAddr()
- if err != nil {
- return nil, err
- }
- return net.DialTimeout("tcp", addr, d.opt.DialTimeout)
-}
-
-func (d *sentinelFailover) Pool() pool {
- d.poolOnce.Do(func() {
- d.pool = newConnPool(newConnFunc(d.dial), d.opt)
- })
- return d.pool
-}
-
-func (d *sentinelFailover) MasterAddr() (string, error) {
- defer d.lock.Unlock()
- d.lock.Lock()
-
- // Try last working sentinel.
- if d._sentinel != nil {
- addr, err := d._sentinel.GetMasterAddrByName(d.masterName).Result()
- if err != nil {
- log.Printf("redis-sentinel: GetMasterAddrByName %q failed: %s", d.masterName, err)
- d.resetSentinel()
- } else {
- addr := net.JoinHostPort(addr[0], addr[1])
- log.Printf("redis-sentinel: %q addr is %s", d.masterName, addr)
- return addr, nil
- }
- }
-
- for i, sentinelAddr := range d.sentinelAddrs {
- sentinel := newSentinel(&Options{
- Addr: sentinelAddr,
-
- DB: d.opt.DB,
- Password: d.opt.Password,
-
- DialTimeout: d.opt.DialTimeout,
- ReadTimeout: d.opt.ReadTimeout,
- WriteTimeout: d.opt.WriteTimeout,
-
- PoolSize: d.opt.PoolSize,
- IdleTimeout: d.opt.IdleTimeout,
- })
- masterAddr, err := sentinel.GetMasterAddrByName(d.masterName).Result()
- if err != nil {
- log.Printf("redis-sentinel: GetMasterAddrByName %q failed: %s", d.masterName, err)
- sentinel.Close()
- continue
- }
-
- // Push working sentinel to the top.
- d.sentinelAddrs[0], d.sentinelAddrs[i] = d.sentinelAddrs[i], d.sentinelAddrs[0]
-
- d.setSentinel(sentinel)
- addr := net.JoinHostPort(masterAddr[0], masterAddr[1])
- log.Printf("redis-sentinel: %q addr is %s", d.masterName, addr)
- return addr, nil
- }
-
- return "", errors.New("redis: all sentinels are unreachable")
-}
-
-func (d *sentinelFailover) setSentinel(sentinel *sentinelClient) {
- d.discoverSentinels(sentinel)
- d._sentinel = sentinel
- go d.listen()
-}
-
-func (d *sentinelFailover) discoverSentinels(sentinel *sentinelClient) {
- sentinels, err := sentinel.Sentinels(d.masterName).Result()
- if err != nil {
- log.Printf("redis-sentinel: Sentinels %q failed: %s", d.masterName, err)
- return
- }
- for _, sentinel := range sentinels {
- vals := sentinel.([]interface{})
- for i := 0; i < len(vals); i += 2 {
- key := vals[i].(string)
- if key == "name" {
- sentinelAddr := vals[i+1].(string)
- if !contains(d.sentinelAddrs, sentinelAddr) {
- log.Printf(
- "redis-sentinel: discovered new %q sentinel: %s",
- d.masterName, sentinelAddr,
- )
- d.sentinelAddrs = append(d.sentinelAddrs, sentinelAddr)
- }
- }
- }
- }
-}
-
-func (d *sentinelFailover) listen() {
- var pubsub *PubSub
- for {
- if pubsub == nil {
- pubsub = d._sentinel.PubSub()
- if err := pubsub.Subscribe("+switch-master"); err != nil {
- log.Printf("redis-sentinel: Subscribe failed: %s", err)
- d.lock.Lock()
- d.resetSentinel()
- d.lock.Unlock()
- return
- }
- }
-
- msgIface, err := pubsub.Receive()
- if err != nil {
- log.Printf("redis-sentinel: Receive failed: %s", err)
- pubsub.Close()
- return
- }
-
- switch msg := msgIface.(type) {
- case *Message:
- switch msg.Channel {
- case "+switch-master":
- parts := strings.Split(msg.Payload, " ")
- if parts[0] != d.masterName {
- log.Printf("redis-sentinel: ignore new %s addr", parts[0])
- continue
- }
- addr := net.JoinHostPort(parts[3], parts[4])
- log.Printf(
- "redis-sentinel: new %q addr is %s",
- d.masterName, addr,
- )
- d.pool.Filter(func(cn *conn) bool {
- if cn.RemoteAddr().String() != addr {
- log.Printf(
- "redis-sentinel: closing connection to old master %s",
- cn.RemoteAddr(),
- )
- return false
- }
- return true
- })
- default:
- log.Printf("redis-sentinel: unsupported message: %s", msg)
- }
- case *Subscription:
- // Ignore.
- default:
- log.Printf("redis-sentinel: unsupported message: %s", msgIface)
- }
- }
-}
-
-func (d *sentinelFailover) resetSentinel() {
- d._sentinel.Close()
- d._sentinel = nil
-}
-
-func contains(slice []string, str string) bool {
- for _, s := range slice {
- if s == str {
- return true
- }
- }
- return false
-}
generated by cgit v1.2.3 (git 2.39.1) at 2025-01-19 15:03:15 +0000