mirror of
https://github.com/ipfs/kubo.git
synced 2025-06-28 08:47:42 +08:00
Merge pull request #1427 from ipfs/unused-cleanup
cleanup unused packages
This commit is contained in:
Juan Batiz-Benet
5
Godeps/Godeps.json
generated
5
Godeps/Godeps.json
generated
@ -87,11 +87,6 @@
|
|||||||
"ImportPath": "github.com/fd/go-nat",
|
"ImportPath": "github.com/fd/go-nat",
|
||||||
"Rev": "50e7633d5f27d81490026a13e5b92d2e42d8c6bb"
|
"Rev": "50e7633d5f27d81490026a13e5b92d2e42d8c6bb"
|
||||||
},
|
},
|
||||||
{
|
|
||||||
"ImportPath": "github.com/fzzy/radix/redis",
|
|
||||||
"Comment": "v0.5.1",
|
|
||||||
"Rev": "27a863cdffdb0998d13e1e11992b18489aeeaa25"
|
|
||||||
},
|
|
||||||
{
|
{
|
||||||
"ImportPath": "github.com/gogo/protobuf/io",
|
"ImportPath": "github.com/gogo/protobuf/io",
|
||||||
"Rev": "0ac967c269268f1af7d9bcc7927ccc9a589b2b36"
|
"Rev": "0ac967c269268f1af7d9bcc7927ccc9a589b2b36"
|
||||||
|
|||||||
244
Godeps/_workspace/src/github.com/fzzy/radix/redis/client.go
generated
vendored
244
Godeps/_workspace/src/github.com/fzzy/radix/redis/client.go
generated
vendored
@ -1,244 +0,0 @@
|
|||||||
package redis
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bufio"
|
|
||||||
"errors"
|
|
||||||
"net"
|
|
||||||
"strings"
|
|
||||||
"time"
|
|
||||||
|
|
||||||
"github.com/ipfs/go-ipfs/Godeps/_workspace/src/github.com/fzzy/radix/redis/resp"
|
|
||||||
)
|
|
||||||
|
|
||||||
const (
|
|
||||||
bufSize int = 4096
|
|
||||||
)
|
|
||||||
|
|
||||||
//* Common errors
|
|
||||||
|
|
||||||
var LoadingError error = errors.New("server is busy loading dataset in memory")
|
|
||||||
var PipelineQueueEmptyError error = errors.New("pipeline queue empty")
|
|
||||||
|
|
||||||
//* Client
|
|
||||||
|
|
||||||
// Client describes a Redis client.
|
|
||||||
type Client struct {
|
|
||||||
// The connection the client talks to redis over. Don't touch this unless
|
|
||||||
// you know what you're doing.
|
|
||||||
Conn net.Conn
|
|
||||||
timeout time.Duration
|
|
||||||
reader *bufio.Reader
|
|
||||||
pending []*request
|
|
||||||
completed []*Reply
|
|
||||||
}
|
|
||||||
|
|
||||||
// request describes a client's request to the redis server
|
|
||||||
type request struct {
|
|
||||||
cmd string
|
|
||||||
args []interface{}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Dial connects to the given Redis server with the given timeout, which will be
|
|
||||||
// used as the read/write timeout when communicating with redis
|
|
||||||
func DialTimeout(network, addr string, timeout time.Duration) (*Client, error) {
|
|
||||||
// establish a connection
|
|
||||||
conn, err := net.Dial(network, addr)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
c := new(Client)
|
|
||||||
c.Conn = conn
|
|
||||||
c.timeout = timeout
|
|
||||||
c.reader = bufio.NewReaderSize(conn, bufSize)
|
|
||||||
return c, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Dial connects to the given Redis server.
|
|
||||||
func Dial(network, addr string) (*Client, error) {
|
|
||||||
return DialTimeout(network, addr, time.Duration(0))
|
|
||||||
}
|
|
||||||
|
|
||||||
//* Public methods
|
|
||||||
|
|
||||||
// Close closes the connection.
|
|
||||||
func (c *Client) Close() error {
|
|
||||||
return c.Conn.Close()
|
|
||||||
}
|
|
||||||
|
|
||||||
// Cmd calls the given Redis command.
|
|
||||||
func (c *Client) Cmd(cmd string, args ...interface{}) *Reply {
|
|
||||||
err := c.writeRequest(&request{cmd, args})
|
|
||||||
if err != nil {
|
|
||||||
return &Reply{Type: ErrorReply, Err: err}
|
|
||||||
}
|
|
||||||
return c.ReadReply()
|
|
||||||
}
|
|
||||||
|
|
||||||
// Append adds the given call to the pipeline queue.
|
|
||||||
// Use GetReply() to read the reply.
|
|
||||||
func (c *Client) Append(cmd string, args ...interface{}) {
|
|
||||||
c.pending = append(c.pending, &request{cmd, args})
|
|
||||||
}
|
|
||||||
|
|
||||||
// GetReply returns the reply for the next request in the pipeline queue.
|
|
||||||
// Error reply with PipelineQueueEmptyError is returned,
|
|
||||||
// if the pipeline queue is empty.
|
|
||||||
func (c *Client) GetReply() *Reply {
|
|
||||||
if len(c.completed) > 0 {
|
|
||||||
r := c.completed[0]
|
|
||||||
c.completed = c.completed[1:]
|
|
||||||
return r
|
|
||||||
}
|
|
||||||
c.completed = nil
|
|
||||||
|
|
||||||
if len(c.pending) == 0 {
|
|
||||||
return &Reply{Type: ErrorReply, Err: PipelineQueueEmptyError}
|
|
||||||
}
|
|
||||||
|
|
||||||
nreqs := len(c.pending)
|
|
||||||
err := c.writeRequest(c.pending...)
|
|
||||||
c.pending = nil
|
|
||||||
if err != nil {
|
|
||||||
return &Reply{Type: ErrorReply, Err: err}
|
|
||||||
}
|
|
||||||
r := c.ReadReply()
|
|
||||||
c.completed = make([]*Reply, nreqs-1)
|
|
||||||
for i := 0; i < nreqs-1; i++ {
|
|
||||||
c.completed[i] = c.ReadReply()
|
|
||||||
}
|
|
||||||
|
|
||||||
return r
|
|
||||||
}
|
|
||||||
|
|
||||||
//* Private methods
|
|
||||||
|
|
||||||
func (c *Client) setReadTimeout() {
|
|
||||||
if c.timeout != 0 {
|
|
||||||
c.Conn.SetReadDeadline(time.Now().Add(c.timeout))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *Client) setWriteTimeout() {
|
|
||||||
if c.timeout != 0 {
|
|
||||||
c.Conn.SetWriteDeadline(time.Now().Add(c.timeout))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// This will read a redis reply off of the connection without sending anything
|
|
||||||
// first (useful after you've sent a SUSBSCRIBE command). This will block until
|
|
||||||
// a reply is received or the timeout is reached. On timeout an ErrorReply will
|
|
||||||
// be returned, you can check if it's a timeout like so:
|
|
||||||
//
|
|
||||||
// r := conn.ReadReply()
|
|
||||||
// if r.Err != nil {
|
|
||||||
// if t, ok := r.Err.(*net.OpError); ok && t.Timeout() {
|
|
||||||
// // Is timeout
|
|
||||||
// } else {
|
|
||||||
// // Not timeout
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// Note: this is a more low-level function, you really shouldn't have to
|
|
||||||
// actually use it unless you're writing your own pub/sub code
|
|
||||||
func (c *Client) ReadReply() *Reply {
|
|
||||||
c.setReadTimeout()
|
|
||||||
return c.parse()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *Client) writeRequest(requests ...*request) error {
|
|
||||||
c.setWriteTimeout()
|
|
||||||
for i := range requests {
|
|
||||||
req := make([]interface{}, 0, len(requests[i].args)+1)
|
|
||||||
req = append(req, requests[i].cmd)
|
|
||||||
req = append(req, requests[i].args...)
|
|
||||||
err := resp.WriteArbitraryAsFlattenedStrings(c.Conn, req)
|
|
||||||
if err != nil {
|
|
||||||
c.Close()
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *Client) parse() *Reply {
|
|
||||||
m, err := resp.ReadMessage(c.reader)
|
|
||||||
if err != nil {
|
|
||||||
if t, ok := err.(*net.OpError); !ok || !t.Timeout() {
|
|
||||||
// close connection except timeout
|
|
||||||
c.Close()
|
|
||||||
}
|
|
||||||
return &Reply{Type: ErrorReply, Err: err}
|
|
||||||
}
|
|
||||||
r, err := messageToReply(m)
|
|
||||||
if err != nil {
|
|
||||||
return &Reply{Type: ErrorReply, Err: err}
|
|
||||||
}
|
|
||||||
return r
|
|
||||||
}
|
|
||||||
|
|
||||||
// The error return parameter is for bubbling up parse errors and the like, if
|
|
||||||
// the error is sent by redis itself as an Err message type, then it will be
|
|
||||||
// sent back as an actual Reply (wrapped in a CmdError)
|
|
||||||
func messageToReply(m *resp.Message) (*Reply, error) {
|
|
||||||
r := &Reply{}
|
|
||||||
|
|
||||||
switch m.Type {
|
|
||||||
case resp.Err:
|
|
||||||
errMsg, err := m.Err()
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
if strings.HasPrefix(errMsg.Error(), "LOADING") {
|
|
||||||
err = LoadingError
|
|
||||||
} else {
|
|
||||||
err = &CmdError{errMsg}
|
|
||||||
}
|
|
||||||
r.Type = ErrorReply
|
|
||||||
r.Err = err
|
|
||||||
|
|
||||||
case resp.SimpleStr:
|
|
||||||
status, err := m.Bytes()
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
r.Type = StatusReply
|
|
||||||
r.buf = status
|
|
||||||
|
|
||||||
case resp.Int:
|
|
||||||
i, err := m.Int()
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
r.Type = IntegerReply
|
|
||||||
r.int = i
|
|
||||||
|
|
||||||
case resp.BulkStr:
|
|
||||||
b, err := m.Bytes()
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
r.Type = BulkReply
|
|
||||||
r.buf = b
|
|
||||||
|
|
||||||
case resp.Nil:
|
|
||||||
r.Type = NilReply
|
|
||||||
|
|
||||||
case resp.Array:
|
|
||||||
ms, err := m.Array()
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
r.Type = MultiReply
|
|
||||||
r.Elems = make([]*Reply, len(ms))
|
|
||||||
for i := range ms {
|
|
||||||
r.Elems[i], err = messageToReply(ms[i])
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return r, nil
|
|
||||||
|
|
||||||
}
|
|
||||||
106
Godeps/_workspace/src/github.com/fzzy/radix/redis/client_test.go
generated
vendored
106
Godeps/_workspace/src/github.com/fzzy/radix/redis/client_test.go
generated
vendored
@ -1,106 +0,0 @@
|
|||||||
package redis
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bufio"
|
|
||||||
"bytes"
|
|
||||||
"github.com/stretchr/testify/assert"
|
|
||||||
. "testing"
|
|
||||||
"time"
|
|
||||||
)
|
|
||||||
|
|
||||||
func dial(t *T) *Client {
|
|
||||||
client, err := DialTimeout("tcp", "127.0.0.1:6379", 10*time.Second)
|
|
||||||
assert.Nil(t, err)
|
|
||||||
return client
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestCmd(t *T) {
|
|
||||||
c := dial(t)
|
|
||||||
v, _ := c.Cmd("echo", "Hello, World!").Str()
|
|
||||||
assert.Equal(t, "Hello, World!", v)
|
|
||||||
|
|
||||||
// Test that a bad command properly returns a *CmdError
|
|
||||||
err := c.Cmd("non-existant-cmd").Err
|
|
||||||
assert.NotEqual(t, "", err.(*CmdError).Error())
|
|
||||||
|
|
||||||
// Test that application level errors propagate correctly
|
|
||||||
c.Cmd("sadd", "foo", "bar")
|
|
||||||
_, err = c.Cmd("get", "foo").Str()
|
|
||||||
assert.NotEqual(t, "", err.(*CmdError).Error())
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestPipeline(t *T) {
|
|
||||||
c := dial(t)
|
|
||||||
c.Append("echo", "foo")
|
|
||||||
c.Append("echo", "bar")
|
|
||||||
c.Append("echo", "zot")
|
|
||||||
|
|
||||||
v, _ := c.GetReply().Str()
|
|
||||||
assert.Equal(t, "foo", v)
|
|
||||||
|
|
||||||
v, _ = c.GetReply().Str()
|
|
||||||
assert.Equal(t, "bar", v)
|
|
||||||
|
|
||||||
v, _ = c.GetReply().Str()
|
|
||||||
assert.Equal(t, "zot", v)
|
|
||||||
|
|
||||||
r := c.GetReply()
|
|
||||||
assert.Equal(t, ErrorReply, r.Type)
|
|
||||||
assert.Equal(t, PipelineQueueEmptyError, r.Err)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParse(t *T) {
|
|
||||||
c := dial(t)
|
|
||||||
|
|
||||||
parseString := func(b string) *Reply {
|
|
||||||
c.reader = bufio.NewReader(bytes.NewBufferString(b))
|
|
||||||
return c.parse()
|
|
||||||
}
|
|
||||||
|
|
||||||
// missing \n trailing
|
|
||||||
r := parseString("foo")
|
|
||||||
assert.Equal(t, ErrorReply, r.Type)
|
|
||||||
assert.NotNil(t, r.Err)
|
|
||||||
|
|
||||||
// error reply
|
|
||||||
r = parseString("-ERR unknown command 'foobar'\r\n")
|
|
||||||
assert.Equal(t, ErrorReply, r.Type)
|
|
||||||
assert.Equal(t, "ERR unknown command 'foobar'", r.Err.Error())
|
|
||||||
|
|
||||||
// LOADING error
|
|
||||||
r = parseString("-LOADING Redis is loading the dataset in memory\r\n")
|
|
||||||
assert.Equal(t, ErrorReply, r.Type)
|
|
||||||
assert.Equal(t, LoadingError, r.Err)
|
|
||||||
|
|
||||||
// status reply
|
|
||||||
r = parseString("+OK\r\n")
|
|
||||||
assert.Equal(t, StatusReply, r.Type)
|
|
||||||
assert.Equal(t, []byte("OK"), r.buf)
|
|
||||||
|
|
||||||
// integer reply
|
|
||||||
r = parseString(":1337\r\n")
|
|
||||||
assert.Equal(t, IntegerReply, r.Type)
|
|
||||||
assert.Equal(t, int64(1337), r.int)
|
|
||||||
|
|
||||||
// null bulk reply
|
|
||||||
r = parseString("$-1\r\n")
|
|
||||||
assert.Equal(t, NilReply, r.Type)
|
|
||||||
|
|
||||||
// bulk reply
|
|
||||||
r = parseString("$6\r\nfoobar\r\n")
|
|
||||||
assert.Equal(t, BulkReply, r.Type)
|
|
||||||
assert.Equal(t, []byte("foobar"), r.buf)
|
|
||||||
|
|
||||||
// null multi bulk reply
|
|
||||||
r = parseString("*-1\r\n")
|
|
||||||
assert.Equal(t, NilReply, r.Type)
|
|
||||||
|
|
||||||
// multi bulk reply
|
|
||||||
r = parseString("*5\r\n:0\r\n:1\r\n:2\r\n:3\r\n$6\r\nfoobar\r\n")
|
|
||||||
assert.Equal(t, MultiReply, r.Type)
|
|
||||||
assert.Equal(t, 5, len(r.Elems))
|
|
||||||
for i := 0; i < 4; i++ {
|
|
||||||
assert.Equal(t, int64(i), r.Elems[i].int)
|
|
||||||
}
|
|
||||||
assert.Equal(t, []byte("foobar"), r.Elems[4].buf)
|
|
||||||
}
|
|
||||||
87
Godeps/_workspace/src/github.com/fzzy/radix/redis/doc.go
generated
vendored
87
Godeps/_workspace/src/github.com/fzzy/radix/redis/doc.go
generated
vendored
@ -1,87 +0,0 @@
|
|||||||
// A simple client for connecting and interacting with redis.
|
|
||||||
//
|
|
||||||
// To import inside your package do:
|
|
||||||
//
|
|
||||||
// import "github.com/fzzy/radix/redis"
|
|
||||||
//
|
|
||||||
// Connecting
|
|
||||||
//
|
|
||||||
// Use either Dial or DialTimeout:
|
|
||||||
//
|
|
||||||
// client, err := redis.Dial("tcp", "localhost:6379")
|
|
||||||
// if err != nil {
|
|
||||||
// // handle err
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// Make sure to call Close on the client if you want to clean it up before the
|
|
||||||
// end of the program.
|
|
||||||
//
|
|
||||||
// Cmd and Reply
|
|
||||||
//
|
|
||||||
// The Cmd method returns a Reply, which has methods for converting to various
|
|
||||||
// types. Each of these methods returns an error which can either be a
|
|
||||||
// connection error (e.g. timeout), an application error (e.g. key is wrong
|
|
||||||
// type), or a conversion error (e.g. cannot convert to integer). You can also
|
|
||||||
// directly check the error using the Err field:
|
|
||||||
//
|
|
||||||
// foo, err := client.Cmd("GET", "foo").Str()
|
|
||||||
// if err != nil {
|
|
||||||
// // handle err
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// // Checking Err field directly
|
|
||||||
//
|
|
||||||
// err = client.Cmd("PING").Err
|
|
||||||
// if err != nil {
|
|
||||||
// // handle err
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// Multi Replies
|
|
||||||
//
|
|
||||||
// The elements to Multi replies can be accessed as strings using List or
|
|
||||||
// ListBytes, or you can use the Elems field for more low-level access:
|
|
||||||
//
|
|
||||||
// r := client.Cmd("MGET", "foo", "bar", "baz")
|
|
||||||
//
|
|
||||||
// // This:
|
|
||||||
// for _, elemStr := range r.List() {
|
|
||||||
// fmt.Println(elemStr)
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// // is equivalent to this:
|
|
||||||
// for i := range r.Elems {
|
|
||||||
// elemStr, _ := r.Elems[i].Str()
|
|
||||||
// fmt.Println(elemStr)
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// Pipelining
|
|
||||||
//
|
|
||||||
// Pipelining is when the client sends a bunch of commands to the server at
|
|
||||||
// once, and only once all the commands have been sent does it start reading the
|
|
||||||
// replies off the socket. This is supported using the Append and GetReply
|
|
||||||
// methods. Append will simply append the command to a buffer without sending
|
|
||||||
// it, the first time GetReply is called it will send all the commands in the
|
|
||||||
// buffer and return the Reply for the first command that was sent. Subsequent
|
|
||||||
// calls to GetReply return Replys for subsequent commands:
|
|
||||||
//
|
|
||||||
// client.Append("GET", "foo")
|
|
||||||
// client.Append("SET", "bar", "foo")
|
|
||||||
// client.Append("DEL", "baz")
|
|
||||||
//
|
|
||||||
// // Read GET foo reply
|
|
||||||
// foo, err := client.GetReply().Str()
|
|
||||||
// if err != nil {
|
|
||||||
// // handle err
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// // Read SET bar foo reply
|
|
||||||
// if err := client.GetReply().Err; err != nil {
|
|
||||||
// // handle err
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// // Read DEL baz reply
|
|
||||||
// if err := client.GetReply().Err; err != nil {
|
|
||||||
// // handle err
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
package redis
|
|
||||||
275
Godeps/_workspace/src/github.com/fzzy/radix/redis/reply.go
generated
vendored
275
Godeps/_workspace/src/github.com/fzzy/radix/redis/reply.go
generated
vendored
@ -1,275 +0,0 @@
|
|||||||
package redis
|
|
||||||
|
|
||||||
import (
|
|
||||||
"errors"
|
|
||||||
"strconv"
|
|
||||||
"strings"
|
|
||||||
)
|
|
||||||
|
|
||||||
// A CmdError implements the error interface and is what is returned when the
|
|
||||||
// server returns an error on the application level (e.g. key doesn't exist or
|
|
||||||
// is the wrong type), as opposed to a connection/transport error.
|
|
||||||
//
|
|
||||||
// You can test if a reply is a CmdError like so:
|
|
||||||
//
|
|
||||||
// r := conn.Cmd("GET", "key-which-isnt-a-string")
|
|
||||||
// if r.Err != nil {
|
|
||||||
// if cerr, ok := r.Err.(*redis.CmdError); ok {
|
|
||||||
// // Is CmdError
|
|
||||||
// } else {
|
|
||||||
// // Is other error
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
type CmdError struct {
|
|
||||||
Err error
|
|
||||||
}
|
|
||||||
|
|
||||||
func (cerr *CmdError) Error() string {
|
|
||||||
return cerr.Err.Error()
|
|
||||||
}
|
|
||||||
|
|
||||||
// Returns true if error returned was due to the redis server being read only
|
|
||||||
func (cerr *CmdError) Readonly() bool {
|
|
||||||
return strings.HasPrefix(cerr.Err.Error(), "READONLY")
|
|
||||||
}
|
|
||||||
|
|
||||||
//* Reply
|
|
||||||
|
|
||||||
/*
|
|
||||||
ReplyType describes type of a reply.
|
|
||||||
|
|
||||||
Possible values are:
|
|
||||||
|
|
||||||
StatusReply -- status reply
|
|
||||||
ErrorReply -- error reply
|
|
||||||
IntegerReply -- integer reply
|
|
||||||
NilReply -- nil reply
|
|
||||||
BulkReply -- bulk reply
|
|
||||||
MultiReply -- multi bulk reply
|
|
||||||
*/
|
|
||||||
type ReplyType uint8
|
|
||||||
|
|
||||||
const (
|
|
||||||
StatusReply ReplyType = iota
|
|
||||||
ErrorReply
|
|
||||||
IntegerReply
|
|
||||||
NilReply
|
|
||||||
BulkReply
|
|
||||||
MultiReply
|
|
||||||
)
|
|
||||||
|
|
||||||
// Reply holds a Redis reply.
|
|
||||||
type Reply struct {
|
|
||||||
Type ReplyType // Reply type
|
|
||||||
Elems []*Reply // Sub-replies
|
|
||||||
Err error // Reply error
|
|
||||||
buf []byte
|
|
||||||
int int64
|
|
||||||
}
|
|
||||||
|
|
||||||
// Bytes returns the reply value as a byte string or
|
|
||||||
// an error, if the reply type is not StatusReply or BulkReply.
|
|
||||||
func (r *Reply) Bytes() ([]byte, error) {
|
|
||||||
if r.Type == ErrorReply {
|
|
||||||
return nil, r.Err
|
|
||||||
}
|
|
||||||
if !(r.Type == StatusReply || r.Type == BulkReply) {
|
|
||||||
return nil, errors.New("string value is not available for this reply type")
|
|
||||||
}
|
|
||||||
|
|
||||||
return r.buf, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Str is a convenience method for calling Reply.Bytes() and converting it to string
|
|
||||||
func (r *Reply) Str() (string, error) {
|
|
||||||
b, err := r.Bytes()
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
|
|
||||||
return string(b), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Int64 returns the reply value as a int64 or an error,
|
|
||||||
// if the reply type is not IntegerReply or the reply type
|
|
||||||
// BulkReply could not be parsed to an int64.
|
|
||||||
func (r *Reply) Int64() (int64, error) {
|
|
||||||
if r.Type == ErrorReply {
|
|
||||||
return 0, r.Err
|
|
||||||
}
|
|
||||||
if r.Type != IntegerReply {
|
|
||||||
s, err := r.Str()
|
|
||||||
if err == nil {
|
|
||||||
i64, err := strconv.ParseInt(s, 10, 64)
|
|
||||||
if err != nil {
|
|
||||||
return 0, errors.New("failed to parse integer value from string value")
|
|
||||||
} else {
|
|
||||||
return i64, nil
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return 0, errors.New("integer value is not available for this reply type")
|
|
||||||
}
|
|
||||||
|
|
||||||
return r.int, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Int is a convenience method for calling Reply.Int64() and converting it to int.
|
|
||||||
func (r *Reply) Int() (int, error) {
|
|
||||||
i64, err := r.Int64()
|
|
||||||
if err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
|
|
||||||
return int(i64), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Bool returns false, if the reply value equals to 0 or "0", otherwise true; or
|
|
||||||
// an error, if the reply type is not IntegerReply or BulkReply.
|
|
||||||
func (r *Reply) Bool() (bool, error) {
|
|
||||||
if r.Type == ErrorReply {
|
|
||||||
return false, r.Err
|
|
||||||
}
|
|
||||||
i, err := r.Int()
|
|
||||||
if err == nil {
|
|
||||||
if i == 0 {
|
|
||||||
return false, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
return true, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
s, err := r.Str()
|
|
||||||
if err == nil {
|
|
||||||
if s == "0" {
|
|
||||||
return false, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
return true, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
return false, errors.New("boolean value is not available for this reply type")
|
|
||||||
}
|
|
||||||
|
|
||||||
// List returns a multi bulk reply as a slice of strings or an error.
|
|
||||||
// The reply type must be MultiReply and its elements' types must all be either BulkReply or NilReply.
|
|
||||||
// Nil elements are returned as empty strings.
|
|
||||||
// Useful for list commands.
|
|
||||||
func (r *Reply) List() ([]string, error) {
|
|
||||||
// Doing all this in two places instead of just calling ListBytes() so we don't have
|
|
||||||
// to iterate twice
|
|
||||||
if r.Type == ErrorReply {
|
|
||||||
return nil, r.Err
|
|
||||||
}
|
|
||||||
if r.Type != MultiReply {
|
|
||||||
return nil, errors.New("reply type is not MultiReply")
|
|
||||||
}
|
|
||||||
|
|
||||||
strings := make([]string, len(r.Elems))
|
|
||||||
for i, v := range r.Elems {
|
|
||||||
if v.Type == BulkReply {
|
|
||||||
strings[i] = string(v.buf)
|
|
||||||
} else if v.Type == NilReply {
|
|
||||||
strings[i] = ""
|
|
||||||
} else {
|
|
||||||
return nil, errors.New("element type is not BulkReply or NilReply")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return strings, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// ListBytes returns a multi bulk reply as a slice of bytes slices or an error.
|
|
||||||
// The reply type must be MultiReply and its elements' types must all be either BulkReply or NilReply.
|
|
||||||
// Nil elements are returned as nil.
|
|
||||||
// Useful for list commands.
|
|
||||||
func (r *Reply) ListBytes() ([][]byte, error) {
|
|
||||||
if r.Type == ErrorReply {
|
|
||||||
return nil, r.Err
|
|
||||||
}
|
|
||||||
if r.Type != MultiReply {
|
|
||||||
return nil, errors.New("reply type is not MultiReply")
|
|
||||||
}
|
|
||||||
|
|
||||||
bufs := make([][]byte, len(r.Elems))
|
|
||||||
for i, v := range r.Elems {
|
|
||||||
if v.Type == BulkReply {
|
|
||||||
bufs[i] = v.buf
|
|
||||||
} else if v.Type == NilReply {
|
|
||||||
bufs[i] = nil
|
|
||||||
} else {
|
|
||||||
return nil, errors.New("element type is not BulkReply or NilReply")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return bufs, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Hash returns a multi bulk reply as a map[string]string or an error.
|
|
||||||
// The reply type must be MultiReply,
|
|
||||||
// it must have an even number of elements,
|
|
||||||
// they must be in a "key value key value..." order and
|
|
||||||
// values must all be either BulkReply or NilReply.
|
|
||||||
// Nil values are returned as empty strings.
|
|
||||||
// Useful for hash commands.
|
|
||||||
func (r *Reply) Hash() (map[string]string, error) {
|
|
||||||
if r.Type == ErrorReply {
|
|
||||||
return nil, r.Err
|
|
||||||
}
|
|
||||||
rmap := map[string]string{}
|
|
||||||
|
|
||||||
if r.Type != MultiReply {
|
|
||||||
return nil, errors.New("reply type is not MultiReply")
|
|
||||||
}
|
|
||||||
|
|
||||||
if len(r.Elems)%2 != 0 {
|
|
||||||
return nil, errors.New("reply has odd number of elements")
|
|
||||||
}
|
|
||||||
|
|
||||||
for i := 0; i < len(r.Elems)/2; i++ {
|
|
||||||
var val string
|
|
||||||
|
|
||||||
key, err := r.Elems[i*2].Str()
|
|
||||||
if err != nil {
|
|
||||||
return nil, errors.New("key element has no string reply")
|
|
||||||
}
|
|
||||||
|
|
||||||
v := r.Elems[i*2+1]
|
|
||||||
if v.Type == BulkReply {
|
|
||||||
val = string(v.buf)
|
|
||||||
rmap[key] = val
|
|
||||||
} else if v.Type == NilReply {
|
|
||||||
} else {
|
|
||||||
return nil, errors.New("value element type is not BulkReply or NilReply")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return rmap, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// String returns a string representation of the reply and its sub-replies.
|
|
||||||
// This method is for debugging.
|
|
||||||
// Use method Reply.Str() for reading string reply.
|
|
||||||
func (r *Reply) String() string {
|
|
||||||
switch r.Type {
|
|
||||||
case ErrorReply:
|
|
||||||
return r.Err.Error()
|
|
||||||
case StatusReply:
|
|
||||||
fallthrough
|
|
||||||
case BulkReply:
|
|
||||||
return string(r.buf)
|
|
||||||
case IntegerReply:
|
|
||||||
return strconv.FormatInt(r.int, 10)
|
|
||||||
case NilReply:
|
|
||||||
return "<nil>"
|
|
||||||
case MultiReply:
|
|
||||||
s := "[ "
|
|
||||||
for _, e := range r.Elems {
|
|
||||||
s = s + e.String() + " "
|
|
||||||
}
|
|
||||||
return s + "]"
|
|
||||||
}
|
|
||||||
|
|
||||||
// This should never execute
|
|
||||||
return ""
|
|
||||||
}
|
|
||||||
125
Godeps/_workspace/src/github.com/fzzy/radix/redis/reply_test.go
generated
vendored
125
Godeps/_workspace/src/github.com/fzzy/radix/redis/reply_test.go
generated
vendored
@ -1,125 +0,0 @@
|
|||||||
package redis
|
|
||||||
|
|
||||||
import (
|
|
||||||
"github.com/stretchr/testify/assert"
|
|
||||||
. "testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestStr(t *T) {
|
|
||||||
r := &Reply{Type: ErrorReply, Err: LoadingError}
|
|
||||||
_, err := r.Str()
|
|
||||||
assert.Equal(t, LoadingError, err)
|
|
||||||
|
|
||||||
r = &Reply{Type: IntegerReply}
|
|
||||||
_, err = r.Str()
|
|
||||||
assert.NotNil(t, err)
|
|
||||||
|
|
||||||
r = &Reply{Type: StatusReply, buf: []byte("foo")}
|
|
||||||
b, err := r.Str()
|
|
||||||
assert.Nil(t, err)
|
|
||||||
assert.Equal(t, "foo", b)
|
|
||||||
|
|
||||||
r = &Reply{Type: BulkReply, buf: []byte("foo")}
|
|
||||||
b, err = r.Str()
|
|
||||||
assert.Nil(t, err)
|
|
||||||
assert.Equal(t, "foo", b)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestBytes(t *T) {
|
|
||||||
r := &Reply{Type: BulkReply, buf: []byte("foo")}
|
|
||||||
b, err := r.Bytes()
|
|
||||||
assert.Nil(t, err)
|
|
||||||
assert.Equal(t, []byte("foo"), b)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestInt64(t *T) {
|
|
||||||
r := &Reply{Type: ErrorReply, Err: LoadingError}
|
|
||||||
_, err := r.Int64()
|
|
||||||
assert.Equal(t, LoadingError, err)
|
|
||||||
|
|
||||||
r = &Reply{Type: IntegerReply, int: 5}
|
|
||||||
b, err := r.Int64()
|
|
||||||
assert.Nil(t, err)
|
|
||||||
assert.Equal(t, int64(5), b)
|
|
||||||
|
|
||||||
r = &Reply{Type: BulkReply, buf: []byte("5")}
|
|
||||||
b, err = r.Int64()
|
|
||||||
assert.Nil(t, err)
|
|
||||||
assert.Equal(t, int64(5), b)
|
|
||||||
|
|
||||||
r = &Reply{Type: BulkReply, buf: []byte("foo")}
|
|
||||||
_, err = r.Int64()
|
|
||||||
assert.NotNil(t, err)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestInt(t *T) {
|
|
||||||
r := &Reply{Type: IntegerReply, int: 5}
|
|
||||||
b, err := r.Int()
|
|
||||||
assert.Nil(t, err)
|
|
||||||
assert.Equal(t, 5, b)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestBool(t *T) {
|
|
||||||
r := &Reply{Type: IntegerReply, int: 0}
|
|
||||||
b, err := r.Bool()
|
|
||||||
assert.Nil(t, err)
|
|
||||||
assert.Equal(t, false, b)
|
|
||||||
|
|
||||||
r = &Reply{Type: StatusReply, buf: []byte("0")}
|
|
||||||
b, err = r.Bool()
|
|
||||||
assert.Nil(t, err)
|
|
||||||
assert.Equal(t, false, b)
|
|
||||||
|
|
||||||
r = &Reply{Type: IntegerReply, int: 2}
|
|
||||||
b, err = r.Bool()
|
|
||||||
assert.Nil(t, err)
|
|
||||||
assert.Equal(t, true, b)
|
|
||||||
|
|
||||||
r = &Reply{Type: NilReply}
|
|
||||||
_, err = r.Bool()
|
|
||||||
assert.NotNil(t, err)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestList(t *T) {
|
|
||||||
r := &Reply{Type: MultiReply}
|
|
||||||
r.Elems = make([]*Reply, 3)
|
|
||||||
r.Elems[0] = &Reply{Type: BulkReply, buf: []byte("0")}
|
|
||||||
r.Elems[1] = &Reply{Type: NilReply}
|
|
||||||
r.Elems[2] = &Reply{Type: BulkReply, buf: []byte("2")}
|
|
||||||
l, err := r.List()
|
|
||||||
assert.Nil(t, err)
|
|
||||||
assert.Equal(t, 3, len(l))
|
|
||||||
assert.Equal(t, "0", l[0])
|
|
||||||
assert.Equal(t, "", l[1])
|
|
||||||
assert.Equal(t, "2", l[2])
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestBytesList(t *T) {
|
|
||||||
r := &Reply{Type: MultiReply}
|
|
||||||
r.Elems = make([]*Reply, 3)
|
|
||||||
r.Elems[0] = &Reply{Type: BulkReply, buf: []byte("0")}
|
|
||||||
r.Elems[1] = &Reply{Type: NilReply}
|
|
||||||
r.Elems[2] = &Reply{Type: BulkReply, buf: []byte("2")}
|
|
||||||
l, err := r.ListBytes()
|
|
||||||
assert.Nil(t, err)
|
|
||||||
assert.Equal(t, 3, len(l))
|
|
||||||
assert.Equal(t, []byte("0"), l[0])
|
|
||||||
assert.Nil(t, l[1])
|
|
||||||
assert.Equal(t, []byte("2"), l[2])
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestHash(t *T) {
|
|
||||||
r := &Reply{Type: MultiReply}
|
|
||||||
r.Elems = make([]*Reply, 6)
|
|
||||||
r.Elems[0] = &Reply{Type: BulkReply, buf: []byte("a")}
|
|
||||||
r.Elems[1] = &Reply{Type: BulkReply, buf: []byte("0")}
|
|
||||||
r.Elems[2] = &Reply{Type: BulkReply, buf: []byte("b")}
|
|
||||||
r.Elems[3] = &Reply{Type: NilReply}
|
|
||||||
r.Elems[4] = &Reply{Type: BulkReply, buf: []byte("c")}
|
|
||||||
r.Elems[5] = &Reply{Type: BulkReply, buf: []byte("2")}
|
|
||||||
h, err := r.Hash()
|
|
||||||
assert.Nil(t, err)
|
|
||||||
assert.Equal(t, "0", h["a"])
|
|
||||||
assert.Equal(t, "", h["b"])
|
|
||||||
assert.Equal(t, "2", h["c"])
|
|
||||||
}
|
|
||||||
466
Godeps/_workspace/src/github.com/fzzy/radix/redis/resp/resp.go
generated
vendored
466
Godeps/_workspace/src/github.com/fzzy/radix/redis/resp/resp.go
generated
vendored
@ -1,466 +0,0 @@
|
|||||||
// This package provides an easy to use interface for creating and parsing
|
|
||||||
// messages encoded in the REdis Serialization Protocol (RESP). You can check
|
|
||||||
// out more details about the protocol here: http://redis.io/topics/protocol
|
|
||||||
package resp
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bufio"
|
|
||||||
"bytes"
|
|
||||||
"errors"
|
|
||||||
"fmt"
|
|
||||||
"io"
|
|
||||||
"reflect"
|
|
||||||
"strconv"
|
|
||||||
)
|
|
||||||
|
|
||||||
var (
|
|
||||||
delim = []byte{'\r', '\n'}
|
|
||||||
delimEnd = delim[len(delim)-1]
|
|
||||||
)
|
|
||||||
|
|
||||||
type Type int
|
|
||||||
|
|
||||||
const (
|
|
||||||
SimpleStr Type = iota
|
|
||||||
Err
|
|
||||||
Int
|
|
||||||
BulkStr
|
|
||||||
Array
|
|
||||||
Nil
|
|
||||||
)
|
|
||||||
|
|
||||||
const (
|
|
||||||
simpleStrPrefix = '+'
|
|
||||||
errPrefix = '-'
|
|
||||||
intPrefix = ':'
|
|
||||||
bulkStrPrefix = '$'
|
|
||||||
arrayPrefix = '*'
|
|
||||||
)
|
|
||||||
|
|
||||||
// Parse errors
|
|
||||||
var (
|
|
||||||
badType = errors.New("wrong type")
|
|
||||||
parseErr = errors.New("parse error")
|
|
||||||
)
|
|
||||||
|
|
||||||
type Message struct {
|
|
||||||
Type
|
|
||||||
val interface{}
|
|
||||||
raw []byte
|
|
||||||
}
|
|
||||||
|
|
||||||
// NewMessagePParses the given raw message and returns a Message struct
|
|
||||||
// representing it
|
|
||||||
func NewMessage(b []byte) (*Message, error) {
|
|
||||||
return ReadMessage(bytes.NewReader(b))
|
|
||||||
}
|
|
||||||
|
|
||||||
// Can be used when writing to a resp stream to write a simple-string-style
|
|
||||||
// stream (e.g. +OK\r\n) instead of the default bulk-string-style strings.
|
|
||||||
//
|
|
||||||
// foo := NewSimpleString("foo")
|
|
||||||
// bar := NewSimpleString("bar")
|
|
||||||
// baz := NewSimpleString("baz")
|
|
||||||
// resp.WriteArbitrary(w, foo)
|
|
||||||
// resp.WriteArbitrary(w, []interface{}{bar, baz})
|
|
||||||
//
|
|
||||||
func NewSimpleString(s string) *Message {
|
|
||||||
b := append(make([]byte, 0, len(s) + 3), '+')
|
|
||||||
b = append(b, []byte(s)...)
|
|
||||||
b = append(b, '\r', '\n')
|
|
||||||
return &Message{
|
|
||||||
Type: SimpleStr,
|
|
||||||
val: s,
|
|
||||||
raw: b,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// ReadMessage attempts to read a message object from the given io.Reader, parse
|
|
||||||
// it, and return a Message struct representing it
|
|
||||||
func ReadMessage(reader io.Reader) (*Message, error) {
|
|
||||||
r := bufio.NewReader(reader)
|
|
||||||
return bufioReadMessage(r)
|
|
||||||
}
|
|
||||||
|
|
||||||
func bufioReadMessage(r *bufio.Reader) (*Message, error) {
|
|
||||||
b, err := r.Peek(1)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
switch b[0] {
|
|
||||||
case simpleStrPrefix:
|
|
||||||
return readSimpleStr(r)
|
|
||||||
case errPrefix:
|
|
||||||
return readError(r)
|
|
||||||
case intPrefix:
|
|
||||||
return readInt(r)
|
|
||||||
case bulkStrPrefix:
|
|
||||||
return readBulkStr(r)
|
|
||||||
case arrayPrefix:
|
|
||||||
return readArray(r)
|
|
||||||
default:
|
|
||||||
return nil, badType
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func readSimpleStr(r *bufio.Reader) (*Message, error) {
|
|
||||||
b, err := r.ReadBytes(delimEnd)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
return &Message{Type: SimpleStr, val: b[1 : len(b)-2], raw: b}, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func readError(r *bufio.Reader) (*Message, error) {
|
|
||||||
b, err := r.ReadBytes(delimEnd)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
return &Message{Type: Err, val: b[1 : len(b)-2], raw: b}, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func readInt(r *bufio.Reader) (*Message, error) {
|
|
||||||
b, err := r.ReadBytes(delimEnd)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
i, err := strconv.ParseInt(string(b[1:len(b)-2]), 10, 64)
|
|
||||||
if err != nil {
|
|
||||||
return nil, parseErr
|
|
||||||
}
|
|
||||||
return &Message{Type: Int, val: i, raw: b}, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func readBulkStr(r *bufio.Reader) (*Message, error) {
|
|
||||||
b, err := r.ReadBytes(delimEnd)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
size, err := strconv.ParseInt(string(b[1:len(b)-2]), 10, 64)
|
|
||||||
if err != nil {
|
|
||||||
return nil, parseErr
|
|
||||||
}
|
|
||||||
if size < 0 {
|
|
||||||
return &Message{Type: Nil, raw: b}, nil
|
|
||||||
}
|
|
||||||
total := make([]byte, size)
|
|
||||||
b2 := total
|
|
||||||
var n int
|
|
||||||
for len(b2) > 0 {
|
|
||||||
n, err = r.Read(b2)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
b2 = b2[n:]
|
|
||||||
}
|
|
||||||
|
|
||||||
// There's a hanging \r\n there, gotta read past it
|
|
||||||
trail := make([]byte, 2)
|
|
||||||
for i := 0; i < 2; i++ {
|
|
||||||
if c, err := r.ReadByte(); err != nil {
|
|
||||||
return nil, err
|
|
||||||
} else {
|
|
||||||
trail[i] = c
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
blens := len(b) + len(total)
|
|
||||||
raw := make([]byte, 0, blens+2)
|
|
||||||
raw = append(raw, b...)
|
|
||||||
raw = append(raw, total...)
|
|
||||||
raw = append(raw, trail...)
|
|
||||||
return &Message{Type: BulkStr, val: total, raw: raw}, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func readArray(r *bufio.Reader) (*Message, error) {
|
|
||||||
b, err := r.ReadBytes(delimEnd)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
size, err := strconv.ParseInt(string(b[1:len(b)-2]), 10, 64)
|
|
||||||
if err != nil {
|
|
||||||
return nil, parseErr
|
|
||||||
}
|
|
||||||
if size < 0 {
|
|
||||||
return &Message{Type: Nil, raw: b}, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
arr := make([]*Message, size)
|
|
||||||
for i := range arr {
|
|
||||||
m, err := bufioReadMessage(r)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
arr[i] = m
|
|
||||||
b = append(b, m.raw...)
|
|
||||||
}
|
|
||||||
return &Message{Type: Array, val: arr, raw: b}, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Bytes returns a byte slice representing the value of the Message. Only valid
|
|
||||||
// for a Message of type SimpleStr, Err, and BulkStr. Others will return an
|
|
||||||
// error
|
|
||||||
func (m *Message) Bytes() ([]byte, error) {
|
|
||||||
if b, ok := m.val.([]byte); ok {
|
|
||||||
return b, nil
|
|
||||||
}
|
|
||||||
return nil, badType
|
|
||||||
}
|
|
||||||
|
|
||||||
// Str is a Convenience method around Bytes which converts the output to a
|
|
||||||
// string
|
|
||||||
func (m *Message) Str() (string, error) {
|
|
||||||
b, err := m.Bytes()
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
return string(b), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Int returns an int64 representing the value of the Message. Only valid for
|
|
||||||
// Int messages
|
|
||||||
func (m *Message) Int() (int64, error) {
|
|
||||||
if i, ok := m.val.(int64); ok {
|
|
||||||
return i, nil
|
|
||||||
}
|
|
||||||
return 0, badType
|
|
||||||
}
|
|
||||||
|
|
||||||
// Err returns an error representing the value of the Message. Only valid for
|
|
||||||
// Err messages
|
|
||||||
func (m *Message) Err() (error, error) {
|
|
||||||
if m.Type != Err {
|
|
||||||
return nil, badType
|
|
||||||
}
|
|
||||||
s, err := m.Str()
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
return errors.New(s), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Array returns the Message slice encompassed by this Messsage, assuming the
|
|
||||||
// Message is of type Array
|
|
||||||
func (m *Message) Array() ([]*Message, error) {
|
|
||||||
if a, ok := m.val.([]*Message); ok {
|
|
||||||
return a, nil
|
|
||||||
}
|
|
||||||
return nil, badType
|
|
||||||
}
|
|
||||||
|
|
||||||
// WriteMessage takes in the given Message and writes its encoded form to the
|
|
||||||
// given io.Writer
|
|
||||||
func WriteMessage(w io.Writer, m *Message) error {
|
|
||||||
_, err := w.Write(m.raw)
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
// WriteArbitrary takes in any primitive golang value, or Message, and writes
|
|
||||||
// its encoded form to the given io.Writer, inferring types where appropriate.
|
|
||||||
func WriteArbitrary(w io.Writer, m interface{}) error {
|
|
||||||
b := format(m, false)
|
|
||||||
_, err := w.Write(b)
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
// WriteArbitraryAsString is similar to WriteArbitraryAsFlattenedString except
|
|
||||||
// that it won't flatten any embedded arrays.
|
|
||||||
func WriteArbitraryAsString(w io.Writer, m interface{}) error {
|
|
||||||
b := format(m, true)
|
|
||||||
_, err := w.Write(b)
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
// WriteArbitraryAsFlattenedStrings is similar to WriteArbitrary except that it
|
|
||||||
// will encode all types except Array as a BulkStr, converting the argument into
|
|
||||||
// a string first as necessary. It will also flatten any embedded arrays into a
|
|
||||||
// single long array. This is useful because commands to a redis server must be
|
|
||||||
// given as an array of bulk strings. If the argument isn't already in a slice
|
|
||||||
// or map it will be wrapped so that it is written as an Array of size one.
|
|
||||||
//
|
|
||||||
// Note that if a Message type is found it will *not* be encoded to a BulkStr,
|
|
||||||
// but will simply be passed through as whatever type it already represents.
|
|
||||||
func WriteArbitraryAsFlattenedStrings(w io.Writer, m interface{}) error {
|
|
||||||
fm := flatten(m)
|
|
||||||
return WriteArbitraryAsString(w, fm)
|
|
||||||
}
|
|
||||||
|
|
||||||
func format(m interface{}, forceString bool) []byte {
|
|
||||||
switch mt := m.(type) {
|
|
||||||
case []byte:
|
|
||||||
return formatStr(mt)
|
|
||||||
case string:
|
|
||||||
return formatStr([]byte(mt))
|
|
||||||
case bool:
|
|
||||||
if mt {
|
|
||||||
return formatStr([]byte("1"))
|
|
||||||
} else {
|
|
||||||
return formatStr([]byte("0"))
|
|
||||||
}
|
|
||||||
case nil:
|
|
||||||
if forceString {
|
|
||||||
return formatStr([]byte{})
|
|
||||||
} else {
|
|
||||||
return formatNil()
|
|
||||||
}
|
|
||||||
case int:
|
|
||||||
return formatInt(int64(mt), forceString)
|
|
||||||
case int8:
|
|
||||||
return formatInt(int64(mt), forceString)
|
|
||||||
case int16:
|
|
||||||
return formatInt(int64(mt), forceString)
|
|
||||||
case int32:
|
|
||||||
return formatInt(int64(mt), forceString)
|
|
||||||
case int64:
|
|
||||||
return formatInt(mt, forceString)
|
|
||||||
case uint:
|
|
||||||
return formatInt(int64(mt), forceString)
|
|
||||||
case uint8:
|
|
||||||
return formatInt(int64(mt), forceString)
|
|
||||||
case uint16:
|
|
||||||
return formatInt(int64(mt), forceString)
|
|
||||||
case uint32:
|
|
||||||
return formatInt(int64(mt), forceString)
|
|
||||||
case uint64:
|
|
||||||
return formatInt(int64(mt), forceString)
|
|
||||||
case float32:
|
|
||||||
ft := strconv.FormatFloat(float64(mt), 'f', -1, 32)
|
|
||||||
return formatStr([]byte(ft))
|
|
||||||
case float64:
|
|
||||||
ft := strconv.FormatFloat(mt, 'f', -1, 64)
|
|
||||||
return formatStr([]byte(ft))
|
|
||||||
case error:
|
|
||||||
if forceString {
|
|
||||||
return formatStr([]byte(mt.Error()))
|
|
||||||
} else {
|
|
||||||
return formatErr(mt)
|
|
||||||
}
|
|
||||||
|
|
||||||
// We duplicate the below code here a bit, since this is the common case and
|
|
||||||
// it'd be better to not get the reflect package involved here
|
|
||||||
case []interface{}:
|
|
||||||
l := len(mt)
|
|
||||||
b := make([]byte, 0, l*1024)
|
|
||||||
b = append(b, '*')
|
|
||||||
b = append(b, []byte(strconv.Itoa(l))...)
|
|
||||||
b = append(b, []byte("\r\n")...)
|
|
||||||
for i := 0; i < l; i++ {
|
|
||||||
b = append(b, format(mt[i], forceString)...)
|
|
||||||
}
|
|
||||||
return b
|
|
||||||
|
|
||||||
case *Message:
|
|
||||||
return mt.raw
|
|
||||||
|
|
||||||
default:
|
|
||||||
// Fallback to reflect-based.
|
|
||||||
switch reflect.TypeOf(m).Kind() {
|
|
||||||
case reflect.Slice:
|
|
||||||
rm := reflect.ValueOf(mt)
|
|
||||||
l := rm.Len()
|
|
||||||
b := make([]byte, 0, l*1024)
|
|
||||||
b = append(b, '*')
|
|
||||||
b = append(b, []byte(strconv.Itoa(l))...)
|
|
||||||
b = append(b, []byte("\r\n")...)
|
|
||||||
for i := 0; i < l; i++ {
|
|
||||||
vv := rm.Index(i).Interface()
|
|
||||||
b = append(b, format(vv, forceString)...)
|
|
||||||
}
|
|
||||||
|
|
||||||
return b
|
|
||||||
case reflect.Map:
|
|
||||||
rm := reflect.ValueOf(mt)
|
|
||||||
l := rm.Len() * 2
|
|
||||||
b := make([]byte, 0, l*1024)
|
|
||||||
b = append(b, '*')
|
|
||||||
b = append(b, []byte(strconv.Itoa(l))...)
|
|
||||||
b = append(b, []byte("\r\n")...)
|
|
||||||
keys := rm.MapKeys()
|
|
||||||
for _, k := range keys {
|
|
||||||
kv := k.Interface()
|
|
||||||
vv := rm.MapIndex(k).Interface()
|
|
||||||
b = append(b, format(kv, forceString)...)
|
|
||||||
b = append(b, format(vv, forceString)...)
|
|
||||||
}
|
|
||||||
return b
|
|
||||||
default:
|
|
||||||
return formatStr([]byte(fmt.Sprint(m)))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
var typeOfBytes = reflect.TypeOf([]byte(nil))
|
|
||||||
|
|
||||||
func flatten(m interface{}) []interface{} {
|
|
||||||
t := reflect.TypeOf(m)
|
|
||||||
|
|
||||||
// If it's a byte-slice we don't want to flatten
|
|
||||||
if t == typeOfBytes {
|
|
||||||
return []interface{}{m}
|
|
||||||
}
|
|
||||||
|
|
||||||
switch t.Kind() {
|
|
||||||
case reflect.Slice:
|
|
||||||
rm := reflect.ValueOf(m)
|
|
||||||
l := rm.Len()
|
|
||||||
ret := make([]interface{}, 0, l)
|
|
||||||
for i := 0; i < l; i++ {
|
|
||||||
ret = append(ret, flatten(rm.Index(i).Interface())...)
|
|
||||||
}
|
|
||||||
return ret
|
|
||||||
|
|
||||||
case reflect.Map:
|
|
||||||
rm := reflect.ValueOf(m)
|
|
||||||
l := rm.Len() * 2
|
|
||||||
keys := rm.MapKeys()
|
|
||||||
ret := make([]interface{}, 0, l)
|
|
||||||
for _, k := range keys {
|
|
||||||
kv := k.Interface()
|
|
||||||
vv := rm.MapIndex(k).Interface()
|
|
||||||
ret = append(ret, flatten(kv)...)
|
|
||||||
ret = append(ret, flatten(vv)...)
|
|
||||||
}
|
|
||||||
return ret
|
|
||||||
|
|
||||||
default:
|
|
||||||
return []interface{}{m}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func formatStr(b []byte) []byte {
|
|
||||||
l := strconv.Itoa(len(b))
|
|
||||||
bs := make([]byte, 0, len(l)+len(b)+5)
|
|
||||||
bs = append(bs, bulkStrPrefix)
|
|
||||||
bs = append(bs, []byte(l)...)
|
|
||||||
bs = append(bs, delim...)
|
|
||||||
bs = append(bs, b...)
|
|
||||||
bs = append(bs, delim...)
|
|
||||||
return bs
|
|
||||||
}
|
|
||||||
|
|
||||||
func formatErr(ierr error) []byte {
|
|
||||||
ierrstr := []byte(ierr.Error())
|
|
||||||
bs := make([]byte, 0, len(ierrstr)+3)
|
|
||||||
bs = append(bs, errPrefix)
|
|
||||||
bs = append(bs, ierrstr...)
|
|
||||||
bs = append(bs, delim...)
|
|
||||||
return bs
|
|
||||||
}
|
|
||||||
|
|
||||||
func formatInt(i int64, forceString bool) []byte {
|
|
||||||
istr := strconv.FormatInt(i, 10)
|
|
||||||
if forceString {
|
|
||||||
return formatStr([]byte(istr))
|
|
||||||
}
|
|
||||||
bs := make([]byte, 0, len(istr)+3)
|
|
||||||
bs = append(bs, intPrefix)
|
|
||||||
bs = append(bs, istr...)
|
|
||||||
bs = append(bs, delim...)
|
|
||||||
return bs
|
|
||||||
}
|
|
||||||
|
|
||||||
var nilFormatted = []byte("$-1\r\n")
|
|
||||||
|
|
||||||
func formatNil() []byte {
|
|
||||||
return nilFormatted
|
|
||||||
}
|
|
||||||
209
Godeps/_workspace/src/github.com/fzzy/radix/redis/resp/resp_test.go
generated
vendored
209
Godeps/_workspace/src/github.com/fzzy/radix/redis/resp/resp_test.go
generated
vendored
@ -1,209 +0,0 @@
|
|||||||
package resp
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"errors"
|
|
||||||
"github.com/stretchr/testify/assert"
|
|
||||||
. "testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestRead(t *T) {
|
|
||||||
var m *Message
|
|
||||||
var err error
|
|
||||||
|
|
||||||
_, err = NewMessage(nil)
|
|
||||||
assert.NotNil(t, err)
|
|
||||||
|
|
||||||
_, err = NewMessage([]byte{})
|
|
||||||
assert.NotNil(t, err)
|
|
||||||
|
|
||||||
// Simple string
|
|
||||||
m, _ = NewMessage([]byte("+ohey\r\n"))
|
|
||||||
assert.Equal(t, SimpleStr, m.Type)
|
|
||||||
assert.Equal(t, []byte("ohey"), m.val)
|
|
||||||
|
|
||||||
// Empty simple string
|
|
||||||
m, _ = NewMessage([]byte("+\r\n"))
|
|
||||||
assert.Equal(t, SimpleStr, m.Type)
|
|
||||||
assert.Equal(t, []byte(""), m.val.([]byte))
|
|
||||||
|
|
||||||
// Error
|
|
||||||
m, _ = NewMessage([]byte("-ohey\r\n"))
|
|
||||||
assert.Equal(t, Err, m.Type)
|
|
||||||
assert.Equal(t, []byte("ohey"), m.val.([]byte))
|
|
||||||
|
|
||||||
// Empty error
|
|
||||||
m, _ = NewMessage([]byte("-\r\n"))
|
|
||||||
assert.Equal(t, Err, m.Type)
|
|
||||||
assert.Equal(t, []byte(""), m.val.([]byte))
|
|
||||||
|
|
||||||
// Int
|
|
||||||
m, _ = NewMessage([]byte(":1024\r\n"))
|
|
||||||
assert.Equal(t, Int, m.Type)
|
|
||||||
assert.Equal(t, int64(1024), m.val.(int64))
|
|
||||||
|
|
||||||
// Bulk string
|
|
||||||
m, _ = NewMessage([]byte("$3\r\nfoo\r\n"))
|
|
||||||
assert.Equal(t, BulkStr, m.Type)
|
|
||||||
assert.Equal(t, []byte("foo"), m.val.([]byte))
|
|
||||||
|
|
||||||
// Empty bulk string
|
|
||||||
m, _ = NewMessage([]byte("$0\r\n\r\n"))
|
|
||||||
assert.Equal(t, BulkStr, m.Type)
|
|
||||||
assert.Equal(t, []byte(""), m.val.([]byte))
|
|
||||||
|
|
||||||
// Nil bulk string
|
|
||||||
m, _ = NewMessage([]byte("$-1\r\n"))
|
|
||||||
assert.Equal(t, Nil, m.Type)
|
|
||||||
|
|
||||||
// Array
|
|
||||||
m, _ = NewMessage([]byte("*2\r\n+foo\r\n+bar\r\n"))
|
|
||||||
assert.Equal(t, Array, m.Type)
|
|
||||||
assert.Equal(t, 2, len(m.val.([]*Message)))
|
|
||||||
assert.Equal(t, SimpleStr, m.val.([]*Message)[0].Type)
|
|
||||||
assert.Equal(t, []byte("foo"), m.val.([]*Message)[0].val.([]byte))
|
|
||||||
assert.Equal(t, SimpleStr, m.val.([]*Message)[1].Type)
|
|
||||||
assert.Equal(t, []byte("bar"), m.val.([]*Message)[1].val.([]byte))
|
|
||||||
|
|
||||||
// Empty array
|
|
||||||
m, _ = NewMessage([]byte("*0\r\n"))
|
|
||||||
assert.Equal(t, Array, m.Type)
|
|
||||||
assert.Equal(t, 0, len(m.val.([]*Message)))
|
|
||||||
|
|
||||||
// Nil Array
|
|
||||||
m, _ = NewMessage([]byte("*-1\r\n"))
|
|
||||||
assert.Equal(t, Nil, m.Type)
|
|
||||||
|
|
||||||
// Embedded Array
|
|
||||||
m, _ = NewMessage([]byte("*3\r\n+foo\r\n+bar\r\n*2\r\n+foo\r\n+bar\r\n"))
|
|
||||||
assert.Equal(t, Array, m.Type)
|
|
||||||
assert.Equal(t, 3, len(m.val.([]*Message)))
|
|
||||||
assert.Equal(t, SimpleStr, m.val.([]*Message)[0].Type)
|
|
||||||
assert.Equal(t, []byte("foo"), m.val.([]*Message)[0].val.([]byte))
|
|
||||||
assert.Equal(t, SimpleStr, m.val.([]*Message)[1].Type)
|
|
||||||
assert.Equal(t, []byte("bar"), m.val.([]*Message)[1].val.([]byte))
|
|
||||||
m = m.val.([]*Message)[2]
|
|
||||||
assert.Equal(t, 2, len(m.val.([]*Message)))
|
|
||||||
assert.Equal(t, SimpleStr, m.val.([]*Message)[0].Type)
|
|
||||||
assert.Equal(t, []byte("foo"), m.val.([]*Message)[0].val.([]byte))
|
|
||||||
assert.Equal(t, SimpleStr, m.val.([]*Message)[1].Type)
|
|
||||||
assert.Equal(t, []byte("bar"), m.val.([]*Message)[1].val.([]byte))
|
|
||||||
|
|
||||||
// Test that two bulks in a row read correctly
|
|
||||||
m, _ = NewMessage([]byte("*2\r\n$3\r\nfoo\r\n$3\r\nbar\r\n"))
|
|
||||||
assert.Equal(t, Array, m.Type)
|
|
||||||
assert.Equal(t, 2, len(m.val.([]*Message)))
|
|
||||||
assert.Equal(t, BulkStr, m.val.([]*Message)[0].Type)
|
|
||||||
assert.Equal(t, []byte("foo"), m.val.([]*Message)[0].val.([]byte))
|
|
||||||
assert.Equal(t, BulkStr, m.val.([]*Message)[1].Type)
|
|
||||||
assert.Equal(t, []byte("bar"), m.val.([]*Message)[1].val.([]byte))
|
|
||||||
}
|
|
||||||
|
|
||||||
type arbitraryTest struct {
|
|
||||||
val interface{}
|
|
||||||
expect []byte
|
|
||||||
}
|
|
||||||
|
|
||||||
var nilMessage, _ = NewMessage([]byte("$-1\r\n"))
|
|
||||||
|
|
||||||
var arbitraryTests = []arbitraryTest{
|
|
||||||
{[]byte("OHAI"), []byte("$4\r\nOHAI\r\n")},
|
|
||||||
{"OHAI", []byte("$4\r\nOHAI\r\n")},
|
|
||||||
{true, []byte("$1\r\n1\r\n")},
|
|
||||||
{false, []byte("$1\r\n0\r\n")},
|
|
||||||
{nil, []byte("$-1\r\n")},
|
|
||||||
{80, []byte(":80\r\n")},
|
|
||||||
{int64(-80), []byte(":-80\r\n")},
|
|
||||||
{uint64(80), []byte(":80\r\n")},
|
|
||||||
{float32(0.1234), []byte("$6\r\n0.1234\r\n")},
|
|
||||||
{float64(0.1234), []byte("$6\r\n0.1234\r\n")},
|
|
||||||
{errors.New("hi"), []byte("-hi\r\n")},
|
|
||||||
|
|
||||||
{nilMessage, []byte("$-1\r\n")},
|
|
||||||
|
|
||||||
{[]int{1, 2, 3}, []byte("*3\r\n:1\r\n:2\r\n:3\r\n")},
|
|
||||||
{map[int]int{1: 2}, []byte("*2\r\n:1\r\n:2\r\n")},
|
|
||||||
|
|
||||||
{NewSimpleString("OK"), []byte("+OK\r\n")},
|
|
||||||
}
|
|
||||||
|
|
||||||
var arbitraryAsStringTests = []arbitraryTest{
|
|
||||||
{[]byte("OHAI"), []byte("$4\r\nOHAI\r\n")},
|
|
||||||
{"OHAI", []byte("$4\r\nOHAI\r\n")},
|
|
||||||
{true, []byte("$1\r\n1\r\n")},
|
|
||||||
{false, []byte("$1\r\n0\r\n")},
|
|
||||||
{nil, []byte("$0\r\n\r\n")},
|
|
||||||
{80, []byte("$2\r\n80\r\n")},
|
|
||||||
{int64(-80), []byte("$3\r\n-80\r\n")},
|
|
||||||
{uint64(80), []byte("$2\r\n80\r\n")},
|
|
||||||
{float32(0.1234), []byte("$6\r\n0.1234\r\n")},
|
|
||||||
{float64(0.1234), []byte("$6\r\n0.1234\r\n")},
|
|
||||||
{errors.New("hi"), []byte("$2\r\nhi\r\n")},
|
|
||||||
|
|
||||||
{nilMessage, []byte("$-1\r\n")},
|
|
||||||
|
|
||||||
{[]int{1, 2, 3}, []byte("*3\r\n$1\r\n1\r\n$1\r\n2\r\n$1\r\n3\r\n")},
|
|
||||||
{map[int]int{1: 2}, []byte("*2\r\n$1\r\n1\r\n$1\r\n2\r\n")},
|
|
||||||
|
|
||||||
{NewSimpleString("OK"), []byte("+OK\r\n")},
|
|
||||||
}
|
|
||||||
|
|
||||||
var arbitraryAsFlattenedStringsTests = []arbitraryTest{
|
|
||||||
{
|
|
||||||
[]interface{}{"wat", map[string]interface{}{
|
|
||||||
"foo": 1,
|
|
||||||
}},
|
|
||||||
[]byte("*3\r\n$3\r\nwat\r\n$3\r\nfoo\r\n$1\r\n1\r\n"),
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestWriteArbitrary(t *T) {
|
|
||||||
var err error
|
|
||||||
buf := bytes.NewBuffer([]byte{})
|
|
||||||
for _, test := range arbitraryTests {
|
|
||||||
t.Logf("Checking test %v", test)
|
|
||||||
buf.Reset()
|
|
||||||
err = WriteArbitrary(buf, test.val)
|
|
||||||
assert.Nil(t, err)
|
|
||||||
assert.Equal(t, test.expect, buf.Bytes())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestWriteArbitraryAsString(t *T) {
|
|
||||||
var err error
|
|
||||||
buf := bytes.NewBuffer([]byte{})
|
|
||||||
for _, test := range arbitraryAsStringTests {
|
|
||||||
t.Logf("Checking test %v", test)
|
|
||||||
buf.Reset()
|
|
||||||
err = WriteArbitraryAsString(buf, test.val)
|
|
||||||
assert.Nil(t, err)
|
|
||||||
assert.Equal(t, test.expect, buf.Bytes())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestWriteArbitraryAsFlattenedStrings(t *T) {
|
|
||||||
var err error
|
|
||||||
buf := bytes.NewBuffer([]byte{})
|
|
||||||
for _, test := range arbitraryAsFlattenedStringsTests {
|
|
||||||
t.Logf("Checking test %v", test)
|
|
||||||
buf.Reset()
|
|
||||||
err = WriteArbitraryAsFlattenedStrings(buf, test.val)
|
|
||||||
assert.Nil(t, err)
|
|
||||||
assert.Equal(t, test.expect, buf.Bytes())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestMessageWrite(t *T) {
|
|
||||||
var err error
|
|
||||||
var m *Message
|
|
||||||
buf := bytes.NewBuffer([]byte{})
|
|
||||||
for _, test := range arbitraryTests {
|
|
||||||
t.Logf("Checking test; %v", test)
|
|
||||||
buf.Reset()
|
|
||||||
m, err = NewMessage(test.expect)
|
|
||||||
assert.Nil(t, err)
|
|
||||||
err = WriteMessage(buf, m)
|
|
||||||
assert.Nil(t, err)
|
|
||||||
assert.Equal(t, test.expect, buf.Bytes())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
84
thirdparty/redis-datastore/datastore.go
vendored
84
thirdparty/redis-datastore/datastore.go
vendored
@ -1,84 +0,0 @@
|
|||||||
package redis
|
|
||||||
|
|
||||||
import (
|
|
||||||
"errors"
|
|
||||||
"fmt"
|
|
||||||
"sync"
|
|
||||||
"time"
|
|
||||||
|
|
||||||
"github.com/ipfs/go-ipfs/Godeps/_workspace/src/github.com/fzzy/radix/redis"
|
|
||||||
datastore "github.com/ipfs/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-datastore"
|
|
||||||
query "github.com/ipfs/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-datastore/query"
|
|
||||||
)
|
|
||||||
|
|
||||||
var _ datastore.Datastore = &Datastore{}
|
|
||||||
var _ datastore.ThreadSafeDatastore = &Datastore{}
|
|
||||||
|
|
||||||
var ErrInvalidType = errors.New("redis datastore: invalid type error. this datastore only supports []byte values")
|
|
||||||
|
|
||||||
func NewExpiringDatastore(client *redis.Client, ttl time.Duration) (datastore.ThreadSafeDatastore, error) {
|
|
||||||
return &Datastore{
|
|
||||||
client: client,
|
|
||||||
ttl: ttl,
|
|
||||||
}, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewDatastore(client *redis.Client) (datastore.ThreadSafeDatastore, error) {
|
|
||||||
return &Datastore{
|
|
||||||
client: client,
|
|
||||||
}, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
type Datastore struct {
|
|
||||||
mu sync.Mutex
|
|
||||||
client *redis.Client
|
|
||||||
ttl time.Duration
|
|
||||||
}
|
|
||||||
|
|
||||||
func (ds *Datastore) Put(key datastore.Key, value interface{}) error {
|
|
||||||
ds.mu.Lock()
|
|
||||||
defer ds.mu.Unlock()
|
|
||||||
|
|
||||||
data, ok := value.([]byte)
|
|
||||||
if !ok {
|
|
||||||
return ErrInvalidType
|
|
||||||
}
|
|
||||||
|
|
||||||
ds.client.Append("SET", key.String(), data)
|
|
||||||
if ds.ttl != 0 {
|
|
||||||
ds.client.Append("EXPIRE", key.String(), ds.ttl.Seconds())
|
|
||||||
}
|
|
||||||
if err := ds.client.GetReply().Err; err != nil {
|
|
||||||
return fmt.Errorf("failed to put value: %s", err)
|
|
||||||
}
|
|
||||||
if ds.ttl != 0 {
|
|
||||||
if err := ds.client.GetReply().Err; err != nil {
|
|
||||||
return fmt.Errorf("failed to set expiration: %s", err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (ds *Datastore) Get(key datastore.Key) (value interface{}, err error) {
|
|
||||||
ds.mu.Lock()
|
|
||||||
defer ds.mu.Unlock()
|
|
||||||
return ds.client.Cmd("GET", key.String()).Bytes()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (ds *Datastore) Has(key datastore.Key) (exists bool, err error) {
|
|
||||||
ds.mu.Lock()
|
|
||||||
defer ds.mu.Unlock()
|
|
||||||
return ds.client.Cmd("EXISTS", key.String()).Bool()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (ds *Datastore) Delete(key datastore.Key) (err error) {
|
|
||||||
ds.mu.Lock()
|
|
||||||
defer ds.mu.Unlock()
|
|
||||||
return ds.client.Cmd("DEL", key.String()).Err
|
|
||||||
}
|
|
||||||
|
|
||||||
func (ds *Datastore) Query(q query.Query) (query.Results, error) {
|
|
||||||
return nil, errors.New("TODO implement query for redis datastore?")
|
|
||||||
}
|
|
||||||
|
|
||||||
func (ds *Datastore) IsThreadSafe() {}
|
|
||||||
108
thirdparty/redis-datastore/datastore_test.go
vendored
108
thirdparty/redis-datastore/datastore_test.go
vendored
@ -1,108 +0,0 @@
|
|||||||
package redis
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"os"
|
|
||||||
"testing"
|
|
||||||
"time"
|
|
||||||
|
|
||||||
"github.com/ipfs/go-ipfs/Godeps/_workspace/src/github.com/fzzy/radix/redis"
|
|
||||||
datastore "github.com/ipfs/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-datastore"
|
|
||||||
"github.com/ipfs/go-ipfs/thirdparty/assert"
|
|
||||||
)
|
|
||||||
|
|
||||||
const RedisEnv = "REDIS_DATASTORE_TEST_HOST"
|
|
||||||
|
|
||||||
func TestPutGetBytes(t *testing.T) {
|
|
||||||
client := clientOrAbort(t)
|
|
||||||
ds, err := NewDatastore(client)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
key, val := datastore.NewKey("foo"), []byte("bar")
|
|
||||||
assert.Nil(ds.Put(key, val), t)
|
|
||||||
v, err := ds.Get(key)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if bytes.Compare(v.([]byte), val) != 0 {
|
|
||||||
t.Fail()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestHasBytes(t *testing.T) {
|
|
||||||
client := clientOrAbort(t)
|
|
||||||
ds, err := NewDatastore(client)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
key, val := datastore.NewKey("foo"), []byte("bar")
|
|
||||||
has, err := ds.Has(key)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if has {
|
|
||||||
t.Fail()
|
|
||||||
}
|
|
||||||
|
|
||||||
assert.Nil(ds.Put(key, val), t)
|
|
||||||
hasAfterPut, err := ds.Has(key)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if !hasAfterPut {
|
|
||||||
t.Fail()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestDelete(t *testing.T) {
|
|
||||||
client := clientOrAbort(t)
|
|
||||||
ds, err := NewDatastore(client)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
key, val := datastore.NewKey("foo"), []byte("bar")
|
|
||||||
assert.Nil(ds.Put(key, val), t)
|
|
||||||
assert.Nil(ds.Delete(key), t)
|
|
||||||
|
|
||||||
hasAfterDelete, err := ds.Has(key)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if hasAfterDelete {
|
|
||||||
t.Fail()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestExpiry(t *testing.T) {
|
|
||||||
ttl := 1 * time.Second
|
|
||||||
client := clientOrAbort(t)
|
|
||||||
ds, err := NewExpiringDatastore(client, ttl)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
key, val := datastore.NewKey("foo"), []byte("bar")
|
|
||||||
assert.Nil(ds.Put(key, val), t)
|
|
||||||
time.Sleep(ttl + 1*time.Second)
|
|
||||||
assert.Nil(ds.Delete(key), t)
|
|
||||||
|
|
||||||
hasAfterExpiration, err := ds.Has(key)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if hasAfterExpiration {
|
|
||||||
t.Fail()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func clientOrAbort(t *testing.T) *redis.Client {
|
|
||||||
c, err := redis.Dial("tcp", os.Getenv(RedisEnv))
|
|
||||||
if err != nil {
|
|
||||||
t.Log("could not connect to a redis instance")
|
|
||||||
t.SkipNow()
|
|
||||||
}
|
|
||||||
if err := c.Cmd("FLUSHALL").Err; err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
return c
|
|
||||||
}
|
|
||||||
Reference in New Issue
Block a user