package module
Version: v2.0.0+incompatible Latest Latest

This package is not in the latest version of its module.

Go to latest
Published: Dec 17, 2015 License: MIT Imports: 4 Imported by: 0


Pool GoDoc

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.


// 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).

// close pool any time you want, this closes all the
// RPC connections inside a pool

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



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



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



This section is empty.


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


This section is empty.


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.

	// 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 {
	// 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

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL