mirror of
https://github.com/go-gitea/gitea.git
synced 2024-08-26 21:54:19 -04:00
* Allow common redis and leveldb connections Prevents multiple reopening of redis and leveldb connections to the same place by sharing connections. Further allows for more configurable redis connection type using the redisURI and a leveldbURI scheme. Signed-off-by: Andrew Thornton <art27@cantab.net> * add unit-test Signed-off-by: Andrew Thornton <art27@cantab.net> * as per @lunny Signed-off-by: Andrew Thornton <art27@cantab.net> * add test Signed-off-by: Andrew Thornton <art27@cantab.net> * Update modules/cache/cache_redis.go * Update modules/queue/queue_disk.go * Update modules/cache/cache_redis.go * Update modules/cache/cache_redis.go * Update modules/queue/unique_queue_disk.go * Update modules/queue/queue_disk.go * Update modules/queue/unique_queue_disk.go * Update modules/session/redis.go Co-authored-by: techknowlogick <techknowlogick@gitea.io> Co-authored-by: Lauris BH <lauris@nix.lv>
143 lines
3.0 KiB
Go
Vendored
143 lines
3.0 KiB
Go
Vendored
package redis
|
|
|
|
import (
|
|
"context"
|
|
"sync"
|
|
|
|
"github.com/go-redis/redis/v7/internal/pool"
|
|
)
|
|
|
|
type pipelineExecer func(context.Context, []Cmder) error
|
|
|
|
// Pipeliner is an mechanism to realise Redis Pipeline technique.
|
|
//
|
|
// Pipelining is a technique to extremely speed up processing by packing
|
|
// operations to batches, send them at once to Redis and read a replies in a
|
|
// singe step.
|
|
// See https://redis.io/topics/pipelining
|
|
//
|
|
// Pay attention, that Pipeline is not a transaction, so you can get unexpected
|
|
// results in case of big pipelines and small read/write timeouts.
|
|
// Redis client has retransmission logic in case of timeouts, pipeline
|
|
// can be retransmitted and commands can be executed more then once.
|
|
// To avoid this: it is good idea to use reasonable bigger read/write timeouts
|
|
// depends of your batch size and/or use TxPipeline.
|
|
type Pipeliner interface {
|
|
StatefulCmdable
|
|
Do(args ...interface{}) *Cmd
|
|
Process(cmd Cmder) error
|
|
Close() error
|
|
Discard() error
|
|
Exec() ([]Cmder, error)
|
|
ExecContext(ctx context.Context) ([]Cmder, error)
|
|
}
|
|
|
|
var _ Pipeliner = (*Pipeline)(nil)
|
|
|
|
// 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
|
|
|
|
ctx context.Context
|
|
exec pipelineExecer
|
|
|
|
mu sync.Mutex
|
|
cmds []Cmder
|
|
closed bool
|
|
}
|
|
|
|
func (c *Pipeline) init() {
|
|
c.cmdable = c.Process
|
|
c.statefulCmdable = c.Process
|
|
}
|
|
|
|
func (c *Pipeline) Do(args ...interface{}) *Cmd {
|
|
cmd := NewCmd(args...)
|
|
_ = c.Process(cmd)
|
|
return cmd
|
|
}
|
|
|
|
// Process queues the cmd for later execution.
|
|
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 {
|
|
c.mu.Lock()
|
|
_ = c.discard()
|
|
c.closed = true
|
|
c.mu.Unlock()
|
|
return nil
|
|
}
|
|
|
|
// Discard resets the pipeline and discards queued commands.
|
|
func (c *Pipeline) Discard() error {
|
|
c.mu.Lock()
|
|
err := c.discard()
|
|
c.mu.Unlock()
|
|
return err
|
|
}
|
|
|
|
func (c *Pipeline) discard() error {
|
|
if c.closed {
|
|
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) {
|
|
return c.ExecContext(c.ctx)
|
|
}
|
|
|
|
func (c *Pipeline) ExecContext(ctx context.Context) ([]Cmder, error) {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
|
|
if c.closed {
|
|
return nil, pool.ErrClosed
|
|
}
|
|
|
|
if len(c.cmds) == 0 {
|
|
return nil, nil
|
|
}
|
|
|
|
cmds := c.cmds
|
|
c.cmds = nil
|
|
|
|
return cmds, c.exec(ctx, cmds)
|
|
}
|
|
|
|
func (c *Pipeline) Pipelined(fn func(Pipeliner) error) ([]Cmder, error) {
|
|
if err := fn(c); err != nil {
|
|
return nil, err
|
|
}
|
|
cmds, err := c.Exec()
|
|
_ = c.Close()
|
|
return cmds, err
|
|
}
|
|
|
|
func (c *Pipeline) Pipeline() Pipeliner {
|
|
return c
|
|
}
|
|
|
|
func (c *Pipeline) TxPipelined(fn func(Pipeliner) error) ([]Cmder, error) {
|
|
return c.Pipelined(fn)
|
|
}
|
|
|
|
func (c *Pipeline) TxPipeline() Pipeliner {
|
|
return c
|
|
}
|