Rueidis
A fast Redis Storage that does auto pipelining and supports client side caching. redis/rueidis.
Table of Contents
Signatures
func New(config ...Config) Storage
func NewWithContext(ctx context.Context, config ...Config) *Storage
func (s *Storage) Get(key string) ([]byte, error)
func (s *Storage) GetWithContext(ctx context.Context, key string) ([]byte, error)
func (s *Storage) Set(key string, val []byte, exp time.Duration) error
func (s *Storage) SetWithContext(ctx context.Context, key string, val []byte, exp time.Duration) error
func (s *Storage) Delete(key string) error
func (s *Storage) DeleteWithContext(ctx context.Context, key string) error
func (s *Storage) Reset() error
func (s *Storage) ResetWithContext(ctx context.Context) error
func (s *Storage) Close() error
func (s *Storage) Conn() rueidis.Client
Note: AlwaysPipelining defaults to true and this config reads a zero value as "not set", so setting it to false has no effect. Use DisableAlwaysPipelining: true to turn it off, the same way DisableRetry and DisableCache work.
Installation
Rueidis is tested on the latest Go version with support for modules. So make sure to initialize one first if you didn't do that yet:
go mod init github.com/<user>/<repo>
And then install the rueidis implementation:
go get github.com/gofiber/storage/rueidis
Examples
Import the storage package.
import "github.com/gofiber/storage/rueidis"
You can use the one of the following options to create a Rueidis Storage:
// Initialize default config (localhost:6379)
store := rueidis.New()
// Initialize custom config
store := rueidis.New(rueidis.Config{
InitAddress: []string{"localhost:6380"},
Username: "",
Password: "",
Database: 0,
Reset: false,
TLSConfig: nil,
})
// Initialize using Rueidis URL
store := rueidis.New(rueidis.Config{
URL: "redis://localhost:6379",
})
// Initialize Rueidis Cluster Client
store := rueidis.New(rueidis.Config{
InitAddress: []string{":6379", ":6380"},
})
// Create a client with support for TLS
cer, err := tls.LoadX509KeyPair("./client.crt", "./client.key")
if err != nil {
log.Println(err)
return
}
tlsCfg := &tls.Config{
MinVersion: tls.VersionTLS12,
InsecureSkipVerify: true,
Certificates: []tls.Certificate{cer},
}
store = rueidis.New(rueidis.Config{
InitAddress: []string{"localhost:6380"},
Username: "<user>",
Password: "<password>",
SelectDB: 0,
TLSConfig: tlsCfg,
})
Config
type Config struct {
// Server username
//
// Optional. Default is ""
Username string
// Server password
//
// Optional. Default is ""
Password string
// ClientName will execute the `CLIENT SETNAME ClientName` command for each conn.
//
// Optional. Default is ""
ClientName string
// URL standard format Redis URL. If this is set all other config options, InitAddress, Username, Password, ClientName, and SelectDB have no effect.
//
// Example: redis://<user>:<pass>@localhost:6379/<db>
// Optional. Default is ""
URL string
// SelectDB to be selected after connecting to the server.
//
// Optional. Default is 0
SelectDB int
// Either a single address or a seed list of host:port addresses, this enables FailoverClient and ClusterClient
//
// Optional. Default is []string{"127.0.0.1:6379"}
InitAddress []string
// TLS Config to use. When set TLS will be negotiated.
//
// Optional. Default is nil
TLSConfig *tls.Config
// CacheSizeEachConn is redis client side cache size that bind to each TCP connection to a single redis instance.
//
// Optional. The default is DefaultCacheBytes: 128 * (1 << 20)
CacheSizeEachConn int
// RingScaleEachConn sets the size of the ring buffer in each connection to (2 ^ RingScaleEachConn).
//
// Optional. The default is RingScaleEachConn, which results into having a ring of size 2^10 for each connection.
RingScaleEachConn int
// ReadBufferEachConn is the size of the bufio.NewReaderSize for each connection, default to DefaultReadBuffer (0.5 MiB).
//
// Optional. The default is DefaultReadBuffer: 1 << 19
ReadBufferEachConn int
// WriteBufferEachConn is the size of the bufio.NewWriterSize for each connection, default to DefaultWriteBuffer (0.5 MiB).
//
// Optional. The default is DefaultWriteBuffer: 1 << 19
WriteBufferEachConn int
// BlockingPoolSize is the size of the connection pool shared by blocking commands (ex BLPOP, XREAD with BLOCK).
//
// Optional. The default is DefaultPoolSize: 1000
BlockingPoolSize int
// PipelineMultiplex determines how many tcp connections used to pipeline commands to one redis instance.
//
// Optional. The default for single and sentinel clients is 2, which means 4 connections (2^2).
PipelineMultiplex int
// DisableRetry disables retrying read-only commands under network errors
//
// Optional. The default is False
DisableRetry bool
// DisableCache falls back Client.DoCache/Client.DoMultiCache to Client.Do/Client.DoMulti
//
// Optional. The default is false
DisableCache bool
// AlwaysPipelining makes rueidis.Client always pipeline redis commands even if they are not issued concurrently.
//
// Optional. The default is true
AlwaysPipelining bool
// DisableAlwaysPipelining turns AlwaysPipelining off. That field defaults to
// true and a zero value reads as "not set", so setting it false does nothing;
// this is the way to disable it, matching DisableRetry and DisableCache.
//
// Optional. Default is false
DisableAlwaysPipelining bool
// Reset clears any existing keys in existing Collection
//
// Optional. Default is false
Reset bool
// CacheTTL TTL
//
// Optional. Default is time.Minute
CacheTTL time.Duration
}
Default Config
var ConfigDefault = Config{
Username: "",
Password: "",
ClientName: "",
SelectDB: 0,
InitAddress: []string{"127.0.0.1:6379"},
TLSConfig: nil,
CacheSizeEachConn: rueidis.DefaultCacheBytes,
RingScaleEachConn: rueidis.DefaultRingScale,
ReadBufferEachConn: rueidis.DefaultReadBuffer,
WriteBufferEachConn: rueidis.DefaultWriteBuffer,
BlockingPoolSize: rueidis.DefaultPoolSize,
PipelineMultiplex: 2,
DisableRetry: false,
DisableCache: false,
AlwaysPipelining: true,
DisableAlwaysPipelining: false,
Reset: false,
CacheTTL: time.Minute,
}
