vendor dependencies with dep

vendor/github.com/go-pg/pg/internal/pool/bench_test.go

@@ -0,0 +1,80 @@
+package pool_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/go-pg/pg/internal/pool"
+)
+
+func benchmarkPoolGetPut(b *testing.B, poolSize int) {
+	connPool := pool.NewConnPool(&pool.Options{
+		Dialer:             dummyDialer,
+		PoolSize:           poolSize,
+		PoolTimeout:        time.Second,
+		IdleTimeout:        time.Hour,
+		IdleCheckFrequency: time.Hour,
+	})
+
+	b.ResetTimer()
+
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			cn, _, err := connPool.Get()
+			if err != nil {
+				b.Fatal(err)
+			}
+			if err = connPool.Put(cn); err != nil {
+				b.Fatal(err)
+			}
+		}
+	})
+}
+
+func BenchmarkPoolGetPut10Conns(b *testing.B) {
+	benchmarkPoolGetPut(b, 10)
+}
+
+func BenchmarkPoolGetPut100Conns(b *testing.B) {
+	benchmarkPoolGetPut(b, 100)
+}
+
+func BenchmarkPoolGetPut1000Conns(b *testing.B) {
+	benchmarkPoolGetPut(b, 1000)
+}
+
+func benchmarkPoolGetRemove(b *testing.B, poolSize int) {
+	connPool := pool.NewConnPool(&pool.Options{
+		Dialer:             dummyDialer,
+		PoolSize:           poolSize,
+		PoolTimeout:        time.Second,
+		IdleTimeout:        time.Hour,
+		IdleCheckFrequency: time.Hour,
+	})
+
+	b.ResetTimer()
+
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			cn, _, err := connPool.Get()
+			if err != nil {
+				b.Fatal(err)
+			}
+			if err := connPool.Remove(cn); err != nil {
+				b.Fatal(err)
+			}
+		}
+	})
+}
+
+func BenchmarkPoolGetRemove10Conns(b *testing.B) {
+	benchmarkPoolGetRemove(b, 10)
+}
+
+func BenchmarkPoolGetRemove100Conns(b *testing.B) {
+	benchmarkPoolGetRemove(b, 100)
+}
+
+func BenchmarkPoolGetRemove1000Conns(b *testing.B) {
+	benchmarkPoolGetRemove(b, 1000)
+}

vendor/github.com/go-pg/pg/internal/pool/conn.go

@@ -0,0 +1,106 @@
+package pool
+
+import (
+	"bufio"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"net"
+	"strconv"
+	"time"
+)
+
+var noDeadline = time.Time{}
+
+type Conn struct {
+	netConn net.Conn
+
+	Reader  *bufio.Reader
+	readBuf []byte
+	Columns [][]byte
+
+	Writer *WriteBuffer
+
+	InitedAt time.Time
+	UsedAt   time.Time
+
+	ProcessId int32
+	SecretKey int32
+
+	_lastId int64
+}
+
+func NewConn(netConn net.Conn) *Conn {
+	cn := &Conn{
+		Reader:  bufio.NewReader(netConn),
+		readBuf: make([]byte, 0, 512),
+
+		Writer: NewWriteBuffer(),
+
+		UsedAt: time.Now(),
+	}
+	cn.SetNetConn(netConn)
+	return cn
+}
+
+func (cn *Conn) RemoteAddr() net.Addr {
+	return cn.netConn.RemoteAddr()
+}
+
+func (cn *Conn) SetNetConn(netConn net.Conn) {
+	cn.netConn = netConn
+	cn.Reader.Reset(netConn)
+}
+
+func (cn *Conn) NetConn() net.Conn {
+	return cn.netConn
+}
+
+func (cn *Conn) NextId() string {
+	cn._lastId++
+	return strconv.FormatInt(cn._lastId, 10)
+}
+
+func (cn *Conn) SetTimeout(rt, wt time.Duration) {
+	cn.UsedAt = time.Now()
+	if rt > 0 {
+		cn.netConn.SetReadDeadline(cn.UsedAt.Add(rt))
+	} else {
+		cn.netConn.SetReadDeadline(noDeadline)
+	}
+	if wt > 0 {
+		cn.netConn.SetWriteDeadline(cn.UsedAt.Add(wt))
+	} else {
+		cn.netConn.SetWriteDeadline(noDeadline)
+	}
+}
+
+func (cn *Conn) ReadN(n int) ([]byte, error) {
+	if d := n - cap(cn.readBuf); d > 0 {
+		cn.readBuf = cn.readBuf[:cap(cn.readBuf)]
+		cn.readBuf = append(cn.readBuf, make([]byte, d)...)
+	} else {
+		cn.readBuf = cn.readBuf[:n]
+	}
+	_, err := io.ReadFull(cn.Reader, cn.readBuf)
+	return cn.readBuf, err
+}
+
+func (cn *Conn) FlushWriter() error {
+	_, err := cn.netConn.Write(cn.Writer.Bytes)
+	cn.Writer.Reset()
+	return err
+}
+
+func (cn *Conn) Close() error {
+	return cn.netConn.Close()
+}
+
+func (cn *Conn) CheckHealth() error {
+	if cn.Reader.Buffered() != 0 {
+		b, _ := cn.Reader.Peek(cn.Reader.Buffered())
+		err := fmt.Errorf("connection has unread data:\n%s", hex.Dump(b))
+		return err
+	}
+	return nil
+}

vendor/github.com/go-pg/pg/internal/pool/main_test.go

@@ -0,0 +1,35 @@
+package pool_test
+
+import (
+	"net"
+	"sync"
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestGinkgoSuite(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "pool")
+}
+
+func perform(n int, cbs ...func(int)) {
+	var wg sync.WaitGroup
+	for _, cb := range cbs {
+		for i := 0; i < n; i++ {
+			wg.Add(1)
+			go func(cb func(int), i int) {
+				defer GinkgoRecover()
+				defer wg.Done()
+
+				cb(i)
+			}(cb, i)
+		}
+	}
+	wg.Wait()
+}
+
+func dummyDialer() (net.Conn, error) {
+	return &net.TCPConn{}, nil
+}

vendor/github.com/go-pg/pg/internal/pool/pool.go

@@ -0,0 +1,377 @@
+package pool
+
+import (
+	"errors"
+	"net"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/go-pg/pg/internal"
+)
+
+var ErrClosed = errors.New("pg: database is closed")
+var ErrPoolTimeout = errors.New("pg: connection pool timeout")
+
+var timers = sync.Pool{
+	New: func() interface{} {
+		t := time.NewTimer(time.Hour)
+		t.Stop()
+		return t
+	},
+}
+
+// Stats contains pool state information and accumulated stats.
+type Stats struct {
+	Hits     uint32 // number of times free connection was found in the pool
+	Misses   uint32 // number of times free connection was NOT found in the pool
+	Timeouts uint32 // number of times a wait timeout occurred
+
+	TotalConns uint32 // number of total connections in the pool
+	FreeConns  uint32 // number of free connections in the pool
+	StaleConns uint32 // number of stale connections removed from the pool
+}
+
+type Pooler interface {
+	NewConn() (*Conn, error)
+	CloseConn(*Conn) error
+
+	Get() (*Conn, bool, error)
+	Put(*Conn) error
+	Remove(*Conn) error
+
+	Len() int
+	FreeLen() int
+	Stats() *Stats
+
+	Close() error
+}
+
+type Options struct {
+	Dialer  func() (net.Conn, error)
+	OnClose func(*Conn) error
+
+	PoolSize           int
+	PoolTimeout        time.Duration
+	IdleTimeout        time.Duration
+	IdleCheckFrequency time.Duration
+	MaxAge             time.Duration
+}
+
+type ConnPool struct {
+	opt *Options
+
+	dialErrorsNum  uint32 // atomic
+	_lastDialError atomic.Value
+
+	queue chan struct{}
+
+	connsMu sync.Mutex
+	conns   []*Conn
+
+	freeConnsMu sync.Mutex
+	freeConns   []*Conn
+
+	stats Stats
+
+	_closed uint32 // atomic
+}
+
+var _ Pooler = (*ConnPool)(nil)
+
+func NewConnPool(opt *Options) *ConnPool {
+	p := &ConnPool{
+		opt: opt,
+
+		queue:     make(chan struct{}, opt.PoolSize),
+		conns:     make([]*Conn, 0, opt.PoolSize),
+		freeConns: make([]*Conn, 0, opt.PoolSize),
+	}
+
+	if opt.IdleTimeout > 0 && opt.IdleCheckFrequency > 0 {
+		go p.reaper(opt.IdleCheckFrequency)
+	}
+
+	return p
+}
+
+func (p *ConnPool) NewConn() (*Conn, error) {
+	if p.closed() {
+		return nil, ErrClosed
+	}
+
+	if atomic.LoadUint32(&p.dialErrorsNum) >= uint32(p.opt.PoolSize) {
+		return nil, p.lastDialError()
+	}
+
+	netConn, err := p.opt.Dialer()
+	if err != nil {
+		p.setLastDialError(err)
+		if atomic.AddUint32(&p.dialErrorsNum, 1) == uint32(p.opt.PoolSize) {
+			go p.tryDial()
+		}
+		return nil, err
+	}
+	atomic.StoreUint32(&p.dialErrorsNum, 0)
+
+	cn := NewConn(netConn)
+	p.connsMu.Lock()
+	p.conns = append(p.conns, cn)
+	p.connsMu.Unlock()
+
+	return cn, nil
+}
+
+func (p *ConnPool) tryDial() {
+	for {
+		if p.closed() {
+			return
+		}
+
+		conn, err := p.opt.Dialer()
+		if err != nil {
+			p.setLastDialError(err)
+			time.Sleep(time.Second)
+			continue
+		}
+
+		atomic.StoreUint32(&p.dialErrorsNum, 0)
+		_ = conn.Close()
+		return
+	}
+}
+
+func (p *ConnPool) setLastDialError(err error) {
+	p._lastDialError.Store(err)
+}
+
+func (p *ConnPool) lastDialError() error {
+	return p._lastDialError.Load().(error)
+}
+
+func (p *ConnPool) isStaleConn(cn *Conn) bool {
+	if p.opt.IdleTimeout == 0 && p.opt.MaxAge == 0 {
+		return false
+	}
+
+	now := time.Now()
+	if p.opt.IdleTimeout > 0 && now.Sub(cn.UsedAt) >= p.opt.IdleTimeout {
+		return true
+	}
+	if p.opt.MaxAge > 0 && now.Sub(cn.InitedAt) >= p.opt.MaxAge {
+		return true
+	}
+
+	return false
+}
+
+func (p *ConnPool) popFree() *Conn {
+	if len(p.freeConns) == 0 {
+		return nil
+	}
+
+	idx := len(p.freeConns) - 1
+	cn := p.freeConns[idx]
+	p.freeConns = p.freeConns[:idx]
+	return cn
+}
+
+// Get returns existed connection from the pool or creates a new one.
+func (p *ConnPool) Get() (*Conn, bool, error) {
+	if p.closed() {
+		return nil, false, ErrClosed
+	}
+
+	select {
+	case p.queue <- struct{}{}:
+	default:
+		timer := timers.Get().(*time.Timer)
+		timer.Reset(p.opt.PoolTimeout)
+
+		select {
+		case p.queue <- struct{}{}:
+			if !timer.Stop() {
+				<-timer.C
+			}
+			timers.Put(timer)
+		case <-timer.C:
+			timers.Put(timer)
+			atomic.AddUint32(&p.stats.Timeouts, 1)
+			return nil, false, ErrPoolTimeout
+		}
+	}
+
+	for {
+		p.freeConnsMu.Lock()
+		cn := p.popFree()
+		p.freeConnsMu.Unlock()
+
+		if cn == nil {
+			break
+		}
+
+		if p.isStaleConn(cn) {
+			p.CloseConn(cn)
+			continue
+		}
+
+		atomic.AddUint32(&p.stats.Hits, 1)
+		return cn, false, nil
+	}
+
+	atomic.AddUint32(&p.stats.Misses, 1)
+
+	newcn, err := p.NewConn()
+	if err != nil {
+		<-p.queue
+		return nil, false, err
+	}
+
+	return newcn, true, nil
+}
+
+func (p *ConnPool) Put(cn *Conn) error {
+	if e := cn.CheckHealth(); e != nil {
+		internal.Logf(e.Error())
+		return p.Remove(cn)
+	}
+	p.freeConnsMu.Lock()
+	p.freeConns = append(p.freeConns, cn)
+	p.freeConnsMu.Unlock()
+	<-p.queue
+	return nil
+}
+
+func (p *ConnPool) Remove(cn *Conn) error {
+	_ = p.CloseConn(cn)
+	<-p.queue
+	return nil
+}
+
+func (p *ConnPool) CloseConn(cn *Conn) error {
+	p.connsMu.Lock()
+	for i, c := range p.conns {
+		if c == cn {
+			p.conns = append(p.conns[:i], p.conns[i+1:]...)
+			break
+		}
+	}
+	p.connsMu.Unlock()
+
+	return p.closeConn(cn)
+}
+
+func (p *ConnPool) closeConn(cn *Conn) error {
+	if p.opt.OnClose != nil {
+		_ = p.opt.OnClose(cn)
+	}
+	return cn.Close()
+}
+
+// Len returns total number of connections.
+func (p *ConnPool) Len() int {
+	p.connsMu.Lock()
+	l := len(p.conns)
+	p.connsMu.Unlock()
+	return l
+}
+
+// FreeLen returns number of free connections.
+func (p *ConnPool) FreeLen() int {
+	p.freeConnsMu.Lock()
+	l := len(p.freeConns)
+	p.freeConnsMu.Unlock()
+	return l
+}
+
+func (p *ConnPool) Stats() *Stats {
+	return &Stats{
+		Hits:       atomic.LoadUint32(&p.stats.Hits),
+		Misses:     atomic.LoadUint32(&p.stats.Misses),
+		Timeouts:   atomic.LoadUint32(&p.stats.Timeouts),
+		TotalConns: uint32(p.Len()),
+		FreeConns:  uint32(p.FreeLen()),
+	}
+}
+
+func (p *ConnPool) closed() bool {
+	return atomic.LoadUint32(&p._closed) == 1
+}
+
+func (p *ConnPool) Close() error {
+	if !atomic.CompareAndSwapUint32(&p._closed, 0, 1) {
+		return ErrClosed
+	}
+
+	p.connsMu.Lock()
+	var firstErr error
+	for _, cn := range p.conns {
+		if cn == nil {
+			continue
+		}
+		if err := p.closeConn(cn); err != nil && firstErr == nil {
+			firstErr = err
+		}
+	}
+	p.conns = nil
+	p.connsMu.Unlock()
+
+	p.freeConnsMu.Lock()
+	p.freeConns = nil
+	p.freeConnsMu.Unlock()
+
+	return firstErr
+}
+
+func (p *ConnPool) reapStaleConn() bool {
+	if len(p.freeConns) == 0 {
+		return false
+	}
+
+	cn := p.freeConns[0]
+	if !p.isStaleConn(cn) {
+		return false
+	}
+
+	_ = p.CloseConn(cn)
+	p.freeConns = append(p.freeConns[:0], p.freeConns[1:]...)
+
+	return true
+}
+
+func (p *ConnPool) ReapStaleConns() (int, error) {
+	var n int
+	for {
+		p.queue <- struct{}{}
+		p.freeConnsMu.Lock()
+
+		reaped := p.reapStaleConn()
+
+		p.freeConnsMu.Unlock()
+		<-p.queue
+
+		if reaped {
+			n++
+		} else {
+			break
+		}
+	}
+	return n, nil
+}
+
+func (p *ConnPool) reaper(frequency time.Duration) {
+	ticker := time.NewTicker(frequency)
+	defer ticker.Stop()
+
+	for _ = range ticker.C {
+		if p.closed() {
+			break
+		}
+		n, err := p.ReapStaleConns()
+		if err != nil {
+			internal.Logf("ReapStaleConns failed: %s", err)
+			continue
+		}
+		atomic.AddUint32(&p.stats.StaleConns, uint32(n))
+	}
+}

vendor/github.com/go-pg/pg/internal/pool/pool_single.go

@@ -0,0 +1,55 @@
+package pool
+
+type SingleConnPool struct {
+	cn *Conn
+}
+
+var _ Pooler = (*SingleConnPool)(nil)
+
+func NewSingleConnPool(cn *Conn) *SingleConnPool {
+	return &SingleConnPool{
+		cn: cn,
+	}
+}
+
+func (p *SingleConnPool) NewConn() (*Conn, error) {
+	panic("not implemented")
+}
+
+func (p *SingleConnPool) CloseConn(*Conn) error {
+	panic("not implemented")
+}
+
+func (p *SingleConnPool) Get() (*Conn, bool, error) {
+	return p.cn, false, nil
+}
+
+func (p *SingleConnPool) Put(cn *Conn) error {
+	if p.cn != cn {
+		panic("p.cn != cn")
+	}
+	return nil
+}
+
+func (p *SingleConnPool) Remove(cn *Conn) error {
+	if p.cn != cn {
+		panic("p.cn != cn")
+	}
+	return nil
+}
+
+func (p *SingleConnPool) Len() int {
+	return 1
+}
+
+func (p *SingleConnPool) FreeLen() int {
+	return 0
+}
+
+func (p *SingleConnPool) Stats() *Stats {
+	return nil
+}
+
+func (p *SingleConnPool) Close() error {
+	return nil
+}

vendor/github.com/go-pg/pg/internal/pool/pool_test.go

@@ -0,0 +1,255 @@
+package pool_test
+
+import (
+	"testing"
+	"time"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/go-pg/pg/internal/pool"
+)
+
+var _ = Describe("ConnPool", func() {
+	var connPool *pool.ConnPool
+
+	BeforeEach(func() {
+		connPool = pool.NewConnPool(&pool.Options{
+			Dialer:             dummyDialer,
+			PoolSize:           10,
+			PoolTimeout:        time.Hour,
+			IdleTimeout:        time.Millisecond,
+			IdleCheckFrequency: time.Millisecond,
+		})
+	})
+
+	AfterEach(func() {
+		connPool.Close()
+	})
+
+	It("should unblock client when conn is removed", func() {
+		// Reserve one connection.
+		cn, _, err := connPool.Get()
+		Expect(err).NotTo(HaveOccurred())
+
+		// Reserve all other connections.
+		var cns []*pool.Conn
+		for i := 0; i < 9; i++ {
+			cn, _, err := connPool.Get()
+			Expect(err).NotTo(HaveOccurred())
+			cns = append(cns, cn)
+		}
+
+		started := make(chan bool, 1)
+		done := make(chan bool, 1)
+		go func() {
+			defer GinkgoRecover()
+
+			started <- true
+			_, _, err := connPool.Get()
+			Expect(err).NotTo(HaveOccurred())
+			done <- true
+
+			err = connPool.Put(cn)
+			Expect(err).NotTo(HaveOccurred())
+		}()
+		<-started
+
+		// Check that Get is blocked.
+		select {
+		case <-done:
+			Fail("Get is not blocked")
+		default:
+			// ok
+		}
+
+		err = connPool.Remove(cn)
+		Expect(err).NotTo(HaveOccurred())
+
+		// Check that Ping is unblocked.
+		select {
+		case <-done:
+			// ok
+		case <-time.After(time.Second):
+			Fail("Get is not unblocked")
+		}
+
+		for _, cn := range cns {
+			err = connPool.Put(cn)
+			Expect(err).NotTo(HaveOccurred())
+		}
+	})
+})
+
+var _ = Describe("conns reaper", func() {
+	const idleTimeout = time.Minute
+	const maxAge = time.Hour
+
+	var connPool *pool.ConnPool
+	var conns, staleConns, closedConns []*pool.Conn
+
+	assert := func(typ string) {
+		BeforeEach(func() {
+			closedConns = nil
+			connPool = pool.NewConnPool(&pool.Options{
+				Dialer:             dummyDialer,
+				PoolSize:           10,
+				PoolTimeout:        time.Second,
+				IdleTimeout:        idleTimeout,
+				MaxAge:             maxAge,
+				IdleCheckFrequency: time.Hour,
+				OnClose: func(cn *pool.Conn) error {
+					closedConns = append(closedConns, cn)
+					return nil
+				},
+			})
+
+			conns = nil
+
+			// add stale connections
+			staleConns = nil
+			for i := 0; i < 3; i++ {
+				cn, _, err := connPool.Get()
+				Expect(err).NotTo(HaveOccurred())
+				switch typ {
+				case "idle":
+					cn.UsedAt = time.Now().Add(-2 * idleTimeout)
+				case "aged":
+					cn.InitedAt = time.Now().Add(-2 * maxAge)
+				}
+				conns = append(conns, cn)
+				staleConns = append(staleConns, cn)
+			}
+
+			// add fresh connections
+			for i := 0; i < 3; i++ {
+				cn, _, err := connPool.Get()
+				Expect(err).NotTo(HaveOccurred())
+				conns = append(conns, cn)
+			}
+
+			for _, cn := range conns {
+				if cn.InitedAt.IsZero() {
+					cn.InitedAt = time.Now()
+				}
+				Expect(connPool.Put(cn)).NotTo(HaveOccurred())
+			}
+
+			Expect(connPool.Len()).To(Equal(6))
+			Expect(connPool.FreeLen()).To(Equal(6))
+
+			n, err := connPool.ReapStaleConns()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(n).To(Equal(3))
+		})
+
+		AfterEach(func() {
+			_ = connPool.Close()
+			Expect(connPool.Len()).To(Equal(0))
+			Expect(connPool.FreeLen()).To(Equal(0))
+			Expect(len(closedConns)).To(Equal(len(conns)))
+			Expect(closedConns).To(ConsistOf(conns))
+		})
+
+		It("reaps stale connections", func() {
+			Expect(connPool.Len()).To(Equal(3))
+			Expect(connPool.FreeLen()).To(Equal(3))
+		})
+
+		It("does not reap fresh connections", func() {
+			n, err := connPool.ReapStaleConns()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(n).To(Equal(0))
+		})
+
+		It("stale connections are closed", func() {
+			Expect(len(closedConns)).To(Equal(len(staleConns)))
+			Expect(closedConns).To(ConsistOf(staleConns))
+		})
+
+		It("pool is functional", func() {
+			for j := 0; j < 3; j++ {
+				var freeCns []*pool.Conn
+				for i := 0; i < 3; i++ {
+					cn, _, err := connPool.Get()
+					Expect(err).NotTo(HaveOccurred())
+					Expect(cn).NotTo(BeNil())
+					freeCns = append(freeCns, cn)
+				}
+
+				Expect(connPool.Len()).To(Equal(3))
+				Expect(connPool.FreeLen()).To(Equal(0))
+
+				cn, _, err := connPool.Get()
+				Expect(err).NotTo(HaveOccurred())
+				Expect(cn).NotTo(BeNil())
+				conns = append(conns, cn)
+
+				Expect(connPool.Len()).To(Equal(4))
+				Expect(connPool.FreeLen()).To(Equal(0))
+
+				err = connPool.Remove(cn)
+				Expect(err).NotTo(HaveOccurred())
+
+				Expect(connPool.Len()).To(Equal(3))
+				Expect(connPool.FreeLen()).To(Equal(0))
+
+				for _, cn := range freeCns {
+					err := connPool.Put(cn)
+					Expect(err).NotTo(HaveOccurred())
+				}
+
+				Expect(connPool.Len()).To(Equal(3))
+				Expect(connPool.FreeLen()).To(Equal(3))
+			}
+		})
+	}
+
+	assert("idle")
+	assert("aged")
+})
+
+var _ = Describe("race", func() {
+	var connPool *pool.ConnPool
+	var C, N int
+
+	BeforeEach(func() {
+		C, N = 10, 1000
+		if testing.Short() {
+			C = 4
+			N = 100
+		}
+	})
+
+	AfterEach(func() {
+		connPool.Close()
+	})
+
+	It("does not happen on Get, Put, and Remove", func() {
+		connPool = pool.NewConnPool(&pool.Options{
+			Dialer:             dummyDialer,
+			PoolSize:           10,
+			PoolTimeout:        time.Minute,
+			IdleTimeout:        time.Millisecond,
+			IdleCheckFrequency: time.Millisecond,
+		})
+
+		perform(C, func(id int) {
+			for i := 0; i < N; i++ {
+				cn, _, err := connPool.Get()
+				Expect(err).NotTo(HaveOccurred())
+				if err == nil {
+					Expect(connPool.Put(cn)).NotTo(HaveOccurred())
+				}
+			}
+		}, func(id int) {
+			for i := 0; i < N; i++ {
+				cn, _, err := connPool.Get()
+				Expect(err).NotTo(HaveOccurred())
+				if err == nil {
+					Expect(connPool.Remove(cn)).NotTo(HaveOccurred())
+				}
+			}
+		})
+	})
+})

vendor/github.com/go-pg/pg/internal/pool/write_buffer.go

@@ -0,0 +1,90 @@
+package pool
+
+import (
+	"encoding/binary"
+	"io"
+)
+
+type WriteBuffer struct {
+	Bytes []byte
+
+	msgStart, paramStart int
+}
+
+func NewWriteBuffer() *WriteBuffer {
+	return &WriteBuffer{
+		Bytes: make([]byte, 0, 4096),
+	}
+}
+
+func (buf *WriteBuffer) StartMessage(c byte) {
+	if c == 0 {
+		buf.msgStart = len(buf.Bytes)
+		buf.Bytes = append(buf.Bytes, 0, 0, 0, 0)
+	} else {
+		buf.msgStart = len(buf.Bytes) + 1
+		buf.Bytes = append(buf.Bytes, c, 0, 0, 0, 0)
+	}
+}
+
+func (buf *WriteBuffer) FinishMessage() {
+	binary.BigEndian.PutUint32(
+		buf.Bytes[buf.msgStart:], uint32(len(buf.Bytes)-buf.msgStart))
+}
+
+func (buf *WriteBuffer) StartParam() {
+	buf.paramStart = len(buf.Bytes)
+	buf.Bytes = append(buf.Bytes, 0, 0, 0, 0)
+}
+
+func (buf *WriteBuffer) FinishParam() {
+	binary.BigEndian.PutUint32(
+		buf.Bytes[buf.paramStart:], uint32(len(buf.Bytes)-buf.paramStart-4))
+}
+
+var nullParamLength = int32(-1)
+
+func (buf *WriteBuffer) FinishNullParam() {
+	binary.BigEndian.PutUint32(
+		buf.Bytes[buf.paramStart:], uint32(nullParamLength))
+}
+
+func (buf *WriteBuffer) Write(b []byte) (int, error) {
+	buf.Bytes = append(buf.Bytes, b...)
+	return len(b), nil
+}
+
+func (buf *WriteBuffer) WriteInt16(num int16) {
+	buf.Bytes = append(buf.Bytes, 0, 0)
+	binary.BigEndian.PutUint16(buf.Bytes[len(buf.Bytes)-2:], uint16(num))
+}
+
+func (buf *WriteBuffer) WriteInt32(num int32) {
+	buf.Bytes = append(buf.Bytes, 0, 0, 0, 0)
+	binary.BigEndian.PutUint32(buf.Bytes[len(buf.Bytes)-4:], uint32(num))
+}
+
+func (buf *WriteBuffer) WriteString(s string) {
+	buf.Bytes = append(buf.Bytes, s...)
+	buf.Bytes = append(buf.Bytes, 0)
+}
+
+func (buf *WriteBuffer) WriteBytes(b []byte) {
+	buf.Bytes = append(buf.Bytes, b...)
+	buf.Bytes = append(buf.Bytes, 0)
+}
+
+func (buf *WriteBuffer) WriteByte(c byte) error {
+	buf.Bytes = append(buf.Bytes, c)
+	return nil
+}
+
+func (buf *WriteBuffer) Reset() {
+	buf.Bytes = buf.Bytes[:0]
+}
+
+func (buf *WriteBuffer) ReadFrom(r io.Reader) (int64, error) {
+	n, err := r.Read(buf.Bytes[len(buf.Bytes):cap(buf.Bytes)])
+	buf.Bytes = buf.Bytes[:len(buf.Bytes)+int(n)]
+	return int64(n), err
+}