pool

Documentation

Overview

The pool package implements a connection pool for redis connections which is thread-safe

Index

• type DialFunc
• type Pool
  • func NewCustomPool(network, addr string, size int, df DialFunc) (*Pool, error)
  • func NewOrEmptyPool(network, addr string, size int) *Pool
  • func NewPool(network, addr string, size int) (*Pool, error)
  • func (p *Pool) CarefullyPut(conn *redis.Client, potentialErr *error)
  • func (p *Pool) Empty()
  • func (p *Pool) Get() (*redis.Client, error)
  • func (p *Pool) Put(conn *redis.Client)

Types

type DialFunc

type DialFunc func(network, addr string) (*redis.Client, error)

A function which can be passed into NewCustomPool

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

func NewCustomPool(network, addr string, size int, df DialFunc) (*Pool, error)

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

func NewOrEmptyPool(network, addr string, size int) *Pool

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

func NewPool(network, addr string, size int) (*Pool, error)

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

func (p *Pool) CarefullyPut(conn *redis.Client, potentialErr *error)

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

func (p *Pool) Get() (*redis.Client, error)

Retrieves an available redis client. If there are none available it will create a new one on the fly

func (*Pool) Put

func (p *Pool) Put(conn *redis.Client)

Returns a client back to the pool. If the pool is full the client is closed instead. If the client is already closed (due to connection failure or what-have-you) it should not be put back in the pool. The pool will create more connections as needed.