pool

README

Pool

Pool is a thread safe connection pool for pool.RpcAble interface heavily based on https://godoc.org/gopkg.in/fatih/pool.v2

It can be used to manage and reuse connections used by net.rpc for example.

Install and Usage

Install the package with:

go get github.com/maxatome/pool

Import it with:

import "github.com/maxatome/pool"

and use pool as the package name inside the code.

Example

// create a factory() to be used with channel based pool
factory := func() (pool.RpcAble, error) {
    conn, err := net.Dial(network, address)
    if err != nil {
        return nil, err
    }
    return rpc.NewClient(conn), nil
}

// create a new channel based pool with an initial capacity of 5 and maximum
// capacity of 30. The factory will create 5 initial RPC connections and put
// them into the pool.
p, err := pool.NewChannelPool(5, 30, factory)

// now you can get a RpcAble connection from the pool, if there is no connection
// available it will create a new one via the factory function.
rconn, err := p.Get()

// do something with rconn...
args := &Args{7, 8}
mulReply := new(Reply)
mulCall := rconn.Go("Arith.Mul", args, mulReply, nil)

// ...and put it back to the pool by closing it

// (this doesn't close the underlying RPC connection instead
// it's putting it back to the pool).
rconn.Close()

// close pool any time you want, this closes all the
// RPC connections inside a pool
p.Close()

// currently available RPC connections in the pool
current := p.Len()

Credits

• Fatih Arslan
• sougou

License

The MIT License (MIT) - see LICENSE for more details

Documentation

Overview

Package pool implements a pool of RpcAble interfaces to manage and reuse them.

Index

• Variables
• type Factory
• type Pool
  • func NewChannelPool(initialCap, maxCap int, factory Factory) (Pool, error)
• type PoolRconn
  • func (p PoolRconn) Close() error
  • func (p *PoolRconn) MarkUnusable()
• type RpcAble

Variables

var (
	// ErrClosed is the error resulting if the pool is closed via pool.Close().
	ErrClosed = errors.New("pool is closed")
)

Types

type Factory

type Factory func() (RpcAble, error)

Factory is a function to create new RPC-able connections.

type Pool

type Pool interface {
	// Get returns a new RPC-able connection from the pool. Closing a
	// RPC-able connection puts it back to the Pool. Closing it when the
	// pool is destroyed or full will be counted as an error.
	Get() (RpcAble, error)

	// Close closes the pool and all its RPC-able connections. After
	// Close() the pool is no longer usable.
	Close()

	// Len returns the current number of RPC-able connections of the pool.
	Len() int
}

Pool interface describes a pool implementation. A pool should have maximum capacity. An ideal pool is threadsafe and easy to use.

func NewChannelPool

func NewChannelPool(initialCap, maxCap int, factory Factory) (Pool, error)

NewChannelPool returns a new pool based on buffered channels with an initial capacity and maximum capacity. Factory is used when initial capacity is greater than zero to fill the pool. A zero initialCap doesn't fill the Pool until a new Get() is called. During a Get(), If there is no new RPC-able connection available in the pool, a new RPC-able connection will be created via the Factory() method.

type PoolRconn

type PoolRconn struct {
	RpcAble
	// contains filtered or unexported fields
}

PoolRconn is a wrapper around RpcAble to modify the behavior of RpcAble's Close() method.

func (PoolRconn) Close

func (p PoolRconn) Close() error

Close() puts the given rconn back to the pool instead of closing it.

func (*PoolRconn) MarkUnusable

func (p *PoolRconn) MarkUnusable()

MarkUnusable() marks the rconn not usable any more, to let the pool close it instead of returning it to pool.

type RpcAble

type RpcAble interface {
	Call(serviceMethod string, args interface{}, reply interface{}) error
	Go(serviceMethod string, args interface{}, reply interface{}, done chan *rpc.Call) *rpc.Call
	Close() error
}