Extract pool package. Add pool benchmark.

redis.go

@@ -3,15 +3,26 @@ package redis // import "gopkg.in/redis.v3"
 import (
 	"fmt"
 	"log"
-	"net"
 	"os"
-	"time"
+	"sync/atomic"
+
+	"gopkg.in/redis.v3/internal/pool"
 )
 
-var Logger = log.New(os.Stderr, "redis: ", log.LstdFlags)
+// Deprecated. Use SetLogger instead.
+var Logger *log.Logger
+
+func init() {
+	SetLogger(log.New(os.Stderr, "redis: ", log.LstdFlags))
+}
+
+func SetLogger(logger *log.Logger) {
+	Logger = logger
+	pool.Logger = logger
+}
 
 type baseClient struct {
-	connPool pool
+	connPool pool.Pooler
 	opt      *Options
 
 	onClose func() error // hook called when client is closed
@@ -21,11 +32,11 @@ func (c *baseClient) String() string {
 	return fmt.Sprintf("Redis<%s db:%d>", c.opt.Addr, c.opt.DB)
 }
 
-func (c *baseClient) conn() (*conn, bool, error) {
+func (c *baseClient) conn() (*pool.Conn, bool, error) {
 	return c.connPool.Get()
 }
 
-func (c *baseClient) putConn(cn *conn, err error, allowTimeout bool) bool {
+func (c *baseClient) putConn(cn *pool.Conn, err error, allowTimeout bool) bool {
 	if isBadConn(err, allowTimeout) {
 		err = c.connPool.Remove(cn, err)
 		if err != nil {
@@ -61,7 +72,7 @@ func (c *baseClient) process(cmd Cmder) {
 		}
 		cn.WriteTimeout = c.opt.WriteTimeout
 
-		if err := cn.writeCmds(cmd); err != nil {
+		if err := writeCmd(cn, cmd); err != nil {
 			c.putConn(cn, err, false)
 			cmd.setErr(err)
 			if shouldRetry(err) {
@@ -99,93 +110,6 @@ func (c *baseClient) Close() error {
 
 //------------------------------------------------------------------------------
 
-type Options struct {
-	// The network type, either tcp or unix.
-	// Default is tcp.
-	Network string
-	// host:port address.
-	Addr string
-
-	// Dialer creates new network connection and has priority over
-	// Network and Addr options.
-	Dialer func() (net.Conn, error)
-
-	// An optional password. Must match the password specified in the
-	// requirepass server configuration option.
-	Password string
-	// A database to be selected after connecting to server.
-	DB int64
-
-	// The maximum number of retries before giving up.
-	// Default is to not retry failed commands.
-	MaxRetries int
-
-	// Sets the deadline for establishing new connections. If reached,
-	// dial will fail with a timeout.
-	DialTimeout time.Duration
-	// Sets the deadline for socket reads. If reached, commands will
-	// fail with a timeout instead of blocking.
-	ReadTimeout time.Duration
-	// Sets the deadline for socket writes. If reached, commands will
-	// fail with a timeout instead of blocking.
-	WriteTimeout time.Duration
-
-	// The maximum number of socket connections.
-	// Default is 10 connections.
-	PoolSize int
-	// Specifies amount of time client waits for connection if all
-	// connections are busy before returning an error.
-	// Default is 1 seconds.
-	PoolTimeout time.Duration
-	// Specifies amount of time after which client closes idle
-	// connections. Should be less than server's timeout.
-	// Default is to not close idle connections.
-	IdleTimeout time.Duration
-}
-
-func (opt *Options) getNetwork() string {
-	if opt.Network == "" {
-		return "tcp"
-	}
-	return opt.Network
-}
-
-func (opt *Options) getDialer() func() (net.Conn, error) {
-	if opt.Dialer == nil {
-		opt.Dialer = func() (net.Conn, error) {
-			return net.DialTimeout(opt.getNetwork(), opt.Addr, opt.getDialTimeout())
-		}
-	}
-	return opt.Dialer
-}
-
-func (opt *Options) getPoolSize() int {
-	if opt.PoolSize == 0 {
-		return 10
-	}
-	return opt.PoolSize
-}
-
-func (opt *Options) getDialTimeout() time.Duration {
-	if opt.DialTimeout == 0 {
-		return 5 * time.Second
-	}
-	return opt.DialTimeout
-}
-
-func (opt *Options) getPoolTimeout() time.Duration {
-	if opt.PoolTimeout == 0 {
-		return 1 * time.Second
-	}
-	return opt.PoolTimeout
-}
-
-func (opt *Options) getIdleTimeout() time.Duration {
-	return opt.IdleTimeout
-}
-
-//------------------------------------------------------------------------------
-
 // Client is a Redis client representing a pool of zero or more
 // underlying connections. It's safe for concurrent use by multiple
 // goroutines.
@@ -194,7 +118,7 @@ type Client struct {
 	commandable
 }
 
-func newClient(opt *Options, pool pool) *Client {
+func newClient(opt *Options, pool pool.Pooler) *Client {
 	base := baseClient{opt: opt, connPool: pool}
 	return &Client{
 		baseClient: base,
@@ -206,11 +130,19 @@ func newClient(opt *Options, pool pool) *Client {
 
 // NewClient returns a client to the Redis Server specified by Options.
 func NewClient(opt *Options) *Client {
-	pool := newConnPool(opt)
-	return newClient(opt, pool)
+	return newClient(opt, newConnPool(opt))
 }
 
-// PoolStats returns connection pool stats
+// PoolStats returns connection pool stats.
 func (c *Client) PoolStats() *PoolStats {
-	return c.connPool.Stats()
+	s := c.connPool.Stats()
+	return &PoolStats{
+		Requests: atomic.LoadUint32(&s.Requests),
+		Hits:     atomic.LoadUint32(&s.Hits),
+		Waits:    atomic.LoadUint32(&s.Waits),
+		Timeouts: atomic.LoadUint32(&s.Timeouts),
+
+		TotalConns: atomic.LoadUint32(&s.TotalConns),
+		FreeConns:  atomic.LoadUint32(&s.FreeConns),
+	}
 }