Documentation
¶
Overview ¶
The pool package implements a connection pool for redis connections which is thread-safe
Index ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type Pool ¶
type Pool struct {
// contains filtered or unexported fields
}
A simple connection pool. It will create a small pool of initial connections, and if more connections are needed they will be created on demand. If a connection is returned and the pool is full it will be closed.
func NewCustomPool ¶ added in v0.5.1
A Pool whose connections are all created using f(network, addr). The size indicates the maximum number of idle connections to have waiting to be used at any given moment. f will be used to create all new connections associated with this pool.
The following is an example of using NewCustomPool to have all connections automatically get AUTH called on them upon creation
df := func(network, addr string) (*redis.Client, error) {
client, err := redis.Dial(network, addr)
if err != nil {
return nil, err
}
if err = client.Cmd("AUTH", "SUPERSECRET").Err; err != nil {
client.Close()
return nil, err
}
return client, nil
}
p, _ := pool.NewCustomPool("tcp", "127.0.0.1:6379", 10, df)
func NewOrEmptyPool ¶
Calls NewPool, but if there is an error it return a pool of the same size but without any connections pre-initialized (can be used the same way, but if this happens there might be something wrong with the redis instance you're connecting to)
func NewPool ¶
Creates a new Pool whose connections are all created using redis.Dial(network, addr). The size indicates the maximum number of idle connections to have waiting to be used at any given moment
func (*Pool) CarefullyPut ¶ added in v0.5.0
A useful helper method which acts as a wrapper around Put. It will only actually Put the conn back if potentialErr is not an error or is a redis.CmdError. It would be used like the following:
func doSomeThings(p *Pool) error {
conn, redisErr := p.Get()
if redisErr != nil {
return redisErr
}
defer p.CarefullyPut(conn, &redisErr)
var i int
i, redisErr = conn.Cmd("GET", "foo").Int()
if redisErr != nil {
return redisErr
}
redisErr = conn.Cmd("SET", "foo", i * 3).Err
return redisErr
}
If we were just using the normal Put we wouldn't be able to defer it because we don't want to Put back a connection which is broken. This method takes care of doing that check so we can still use the convenient defer
func (*Pool) Empty ¶
func (p *Pool) Empty()
Removes and calls Close() on all the connections currently in the pool. Assuming there are no other connections waiting to be Put back this method effectively closes and cleans up the pool.
func (*Pool) Get ¶
Retrieves an available redis client. If there are none available it will create a new one on the fly
Source Files