This repository has been archived by the owner on Jul 28, 2020. It is now read-only.
forked from redis/go-redis
-
Notifications
You must be signed in to change notification settings - Fork 0
/
pipeline.go
109 lines (90 loc) · 1.99 KB
/
pipeline.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
package redis
import (
"sync"
"sync/atomic"
"gopkg.in/redis.v4/internal/errors"
"gopkg.in/redis.v4/internal/pool"
)
// Pipeline implements pipelining as described in
// http://redis.io/topics/pipelining. It's safe for concurrent use
// by multiple goroutines.
type Pipeline struct {
cmdable
statefulCmdable
exec func([]Cmder) error
mu sync.Mutex // protects cmds
cmds []Cmder
closed int32
}
func (c *Pipeline) Process(cmd Cmder) error {
c.mu.Lock()
c.cmds = append(c.cmds, cmd)
c.mu.Unlock()
return nil
}
// Close closes the pipeline, releasing any open resources.
func (c *Pipeline) Close() error {
atomic.StoreInt32(&c.closed, 1)
c.Discard()
return nil
}
func (c *Pipeline) isClosed() bool {
return atomic.LoadInt32(&c.closed) == 1
}
// Discard resets the pipeline and discards queued commands.
func (c *Pipeline) Discard() error {
defer c.mu.Unlock()
c.mu.Lock()
if c.isClosed() {
return pool.ErrClosed
}
c.cmds = c.cmds[:0]
return nil
}
// Exec executes all previously queued commands using one
// client-server roundtrip.
//
// Exec always returns list of commands and error of the first failed
// command if any.
func (c *Pipeline) Exec() ([]Cmder, error) {
if c.isClosed() {
return nil, pool.ErrClosed
}
defer c.mu.Unlock()
c.mu.Lock()
if len(c.cmds) == 0 {
return c.cmds, nil
}
cmds := c.cmds
c.cmds = nil
return cmds, c.exec(cmds)
}
func (c *Pipeline) pipelined(fn func(*Pipeline) error) ([]Cmder, error) {
if err := fn(c); err != nil {
return nil, err
}
cmds, err := c.Exec()
_ = c.Close()
return cmds, err
}
func execCmds(cn *pool.Conn, cmds []Cmder) ([]Cmder, error) {
if err := writeCmd(cn, cmds...); err != nil {
setCmdsErr(cmds, err)
return cmds, err
}
var firstCmdErr error
var failedCmds []Cmder
for _, cmd := range cmds {
err := cmd.readReply(cn)
if err == nil {
continue
}
if firstCmdErr == nil {
firstCmdErr = err
}
if errors.IsRetryable(err) {
failedCmds = append(failedCmds, cmd)
}
}
return failedCmds, firstCmdErr
}