redis/multi.go

177 lines
3.7 KiB
Go
Raw Normal View History

package redis
import (
2014-05-11 11:42:40 +04:00
"errors"
"fmt"
"log"
)
2014-05-11 11:42:40 +04:00
var errDiscard = errors.New("redis: Discard can be used only inside Exec")
2015-05-18 14:59:39 +03:00
// Multi implements Redis transactions as described in
2015-11-04 15:25:48 +03:00
// http://redis.io/topics/transactions. It's NOT safe for concurrent use
// by multiple goroutines, because Exec resets connection state.
// If you don't need WATCH it is better to use Pipeline.
//
// TODO(vmihailenco): rename to Tx
2014-05-11 11:42:40 +04:00
type Multi struct {
2015-01-24 15:12:48 +03:00
commandable
base *baseClient
2015-11-04 15:25:48 +03:00
cmds []Cmder
closed bool
}
2014-05-11 11:42:40 +04:00
func (c *Client) Multi() *Multi {
2015-01-24 15:12:48 +03:00
multi := &Multi{
base: &baseClient{
opt: c.opt,
connPool: newStickyConnPool(c.connPool, true),
},
2015-01-24 15:12:48 +03:00
}
multi.commandable.process = multi.process
return multi
}
func (c *Multi) process(cmd Cmder) {
if c.cmds == nil {
c.base.process(cmd)
} else {
c.cmds = append(c.cmds, cmd)
2014-05-11 11:42:40 +04:00
}
}
2015-11-04 15:25:48 +03:00
// Close closes the client, releasing any open resources.
2014-05-11 11:42:40 +04:00
func (c *Multi) Close() error {
2015-11-04 15:25:48 +03:00
c.closed = true
if err := c.Unwatch().Err(); err != nil {
log.Printf("redis: Unwatch failed: %s", err)
}
2015-01-24 15:12:48 +03:00
return c.base.Close()
}
2015-11-04 15:25:48 +03:00
// Watch marks the keys to be watched for conditional execution
// of a transaction.
2014-05-11 11:42:40 +04:00
func (c *Multi) Watch(keys ...string) *StatusCmd {
args := make([]interface{}, 1+len(keys))
args[0] = "WATCH"
for i, key := range keys {
args[1+i] = key
}
2014-05-11 11:42:40 +04:00
cmd := NewStatusCmd(args...)
c.Process(cmd)
return cmd
}
2015-11-04 15:25:48 +03:00
// Unwatch flushes all the previously watched keys for a transaction.
2014-05-11 11:42:40 +04:00
func (c *Multi) Unwatch(keys ...string) *StatusCmd {
args := make([]interface{}, 1+len(keys))
args[0] = "UNWATCH"
for i, key := range keys {
args[1+i] = key
}
2014-05-11 11:42:40 +04:00
cmd := NewStatusCmd(args...)
c.Process(cmd)
return cmd
}
2015-11-04 15:25:48 +03:00
// Discard discards queued commands.
2014-05-11 11:42:40 +04:00
func (c *Multi) Discard() error {
if c.cmds == nil {
return errDiscard
2012-08-25 23:51:42 +04:00
}
2014-05-11 11:42:40 +04:00
c.cmds = c.cmds[:1]
return nil
}
2015-11-04 15:25:48 +03:00
// Exec executes all previously queued commands in a transaction
// and restores the connection state to normal.
//
// When using WATCH, EXEC will execute commands only if the watched keys
// were not modified, allowing for a check-and-set mechanism.
//
2014-05-11 11:42:40 +04:00
// Exec always returns list of commands. If transaction fails
// TxFailedErr is returned. Otherwise Exec returns error of the first
// failed command or nil.
2014-07-02 17:18:19 +04:00
func (c *Multi) Exec(f func() error) ([]Cmder, error) {
2015-11-04 15:25:48 +03:00
if c.closed {
return nil, errClosed
}
2014-05-11 11:42:40 +04:00
c.cmds = []Cmder{NewStatusCmd("MULTI")}
2014-07-02 17:18:19 +04:00
if err := f(); err != nil {
return nil, err
}
2014-05-11 11:42:40 +04:00
c.cmds = append(c.cmds, NewSliceCmd("EXEC"))
2012-08-25 23:51:42 +04:00
2014-05-11 11:42:40 +04:00
cmds := c.cmds
c.cmds = nil
2012-08-13 15:45:32 +04:00
2014-05-11 11:42:40 +04:00
if len(cmds) == 2 {
return []Cmder{}, nil
}
2015-01-24 15:12:48 +03:00
cn, err := c.base.conn()
if err != nil {
2014-05-11 11:42:40 +04:00
setCmdsErr(cmds[1:len(cmds)-1], err)
return cmds[1 : len(cmds)-1], err
}
2014-05-11 11:42:40 +04:00
err = c.execCmds(cn, cmds)
2015-04-17 16:18:44 +03:00
c.base.putConn(cn, err)
return cmds[1 : len(cmds)-1], err
}
2014-05-11 11:42:40 +04:00
func (c *Multi) execCmds(cn *conn, cmds []Cmder) error {
2015-01-24 15:12:48 +03:00
err := cn.writeCmds(cmds...)
if err != nil {
2014-05-11 11:42:40 +04:00
setCmdsErr(cmds[1:len(cmds)-1], err)
return err
}
2014-05-11 11:42:40 +04:00
statusCmd := NewStatusCmd()
2014-05-11 11:42:40 +04:00
// Omit last command (EXEC).
cmdsLen := len(cmds) - 1
// Parse queued replies.
2014-05-11 11:42:40 +04:00
for i := 0; i < cmdsLen; i++ {
2015-10-07 17:09:20 +03:00
if err := statusCmd.readReply(cn); err != nil {
2014-05-11 11:42:40 +04:00
setCmdsErr(cmds[1:len(cmds)-1], err)
return err
}
}
// Parse number of replies.
2015-09-03 17:55:31 +03:00
line, err := readLine(cn)
if err != nil {
2014-05-11 11:42:40 +04:00
setCmdsErr(cmds[1:len(cmds)-1], err)
return err
}
if line[0] != '*' {
2014-05-11 11:42:40 +04:00
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' {
2014-05-11 11:42:40 +04:00
setCmdsErr(cmds[1:len(cmds)-1], TxFailedErr)
return TxFailedErr
}
2014-05-11 11:42:40 +04:00
var firstCmdErr error
// Parse replies.
2014-05-11 11:42:40 +04:00
// Loop starts from 1 to omit MULTI cmd.
for i := 1; i < cmdsLen; i++ {
cmd := cmds[i]
2015-10-07 17:09:20 +03:00
if err := cmd.readReply(cn); err != nil {
2014-05-11 11:42:40 +04:00
if firstCmdErr == nil {
firstCmdErr = err
}
}
}
2014-05-11 11:42:40 +04:00
return firstCmdErr
}