redis/internal/pool/pool_test.go

262 lines
5.4 KiB
Go
Raw Normal View History

2016-03-12 15:42:12 +03:00
package pool_test
import (
"errors"
"net"
"testing"
"time"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"gopkg.in/redis.v4/internal/pool"
2016-03-12 15:42:12 +03:00
)
2016-03-17 14:48:04 +03:00
var _ = Describe("ConnPool", func() {
var connPool *pool.ConnPool
BeforeEach(func() {
2016-03-17 19:00:47 +03:00
connPool = pool.NewConnPool(
dummyDialer, 10, time.Hour, time.Millisecond, time.Millisecond)
2016-03-17 14:48:04 +03:00
})
AfterEach(func() {
connPool.Close()
})
It("rate limits dial", func() {
var rateErr error
for i := 0; i < 1000; i++ {
cn, err := connPool.Get()
if err != nil {
rateErr = err
break
}
2016-03-17 19:00:47 +03:00
_ = connPool.Remove(cn, errors.New("test"))
2016-03-17 14:48:04 +03:00
}
Expect(rateErr).To(MatchError(`redis: you open connections too fast (last_error="test")`))
})
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
}
2016-03-17 19:00:47 +03:00
err = connPool.Remove(cn, errors.New("test"))
2016-03-17 14:48:04 +03:00
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())
}
})
})
2016-03-12 15:42:12 +03:00
2016-03-17 19:00:47 +03:00
var _ = Describe("conns reaper", func() {
const idleTimeout = time.Minute
2016-03-12 15:42:12 +03:00
var connPool *pool.ConnPool
var idleConns, closedConns []*pool.Conn
2016-03-12 15:42:12 +03:00
BeforeEach(func() {
2016-03-17 19:00:47 +03:00
connPool = pool.NewConnPool(
dummyDialer, 10, time.Second, idleTimeout, time.Hour)
closedConns = nil
connPool.OnClose = func(cn *pool.Conn) error {
closedConns = append(closedConns, cn)
return nil
}
2016-03-17 19:00:47 +03:00
var cns []*pool.Conn
2016-03-12 15:42:12 +03:00
// add stale connections
idleConns = nil
2016-03-12 15:42:12 +03:00
for i := 0; i < 3; i++ {
2016-03-17 19:00:47 +03:00
cn, err := connPool.Get()
Expect(err).NotTo(HaveOccurred())
cn.UsedAt = time.Now().Add(-2 * idleTimeout)
2016-03-17 19:00:47 +03:00
cns = append(cns, cn)
idleConns = append(idleConns, cn)
2016-03-12 15:42:12 +03:00
}
// add fresh connections
for i := 0; i < 3; i++ {
cn := pool.NewConn(&net.TCPConn{})
2016-03-17 19:00:47 +03:00
cn, err := connPool.Get()
Expect(err).NotTo(HaveOccurred())
cns = append(cns, cn)
}
for _, cn := range cns {
Expect(connPool.Put(cn)).NotTo(HaveOccurred())
2016-03-12 15:42:12 +03:00
}
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))
})
2016-03-17 14:48:04 +03:00
AfterEach(func() {
connPool.Close()
})
2016-03-12 15:42:12 +03:00
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(closedConns).To(HaveLen(3))
Expect(closedConns).To(ConsistOf(idleConns))
})
2016-03-12 15:42:12 +03:00
It("pool is functional", func() {
for j := 0; j < 3; j++ {
var freeCns []*pool.Conn
for i := 0; i < 3; i++ {
2016-03-17 19:00:47 +03:00
cn, err := connPool.Get()
Expect(err).NotTo(HaveOccurred())
2016-03-12 15:42:12 +03:00
Expect(cn).NotTo(BeNil())
freeCns = append(freeCns, cn)
}
Expect(connPool.Len()).To(Equal(3))
Expect(connPool.FreeLen()).To(Equal(0))
2016-03-15 15:04:35 +03:00
cn, err := connPool.Get()
2016-03-12 15:42:12 +03:00
Expect(err).NotTo(HaveOccurred())
Expect(cn).NotTo(BeNil())
Expect(connPool.Len()).To(Equal(4))
Expect(connPool.FreeLen()).To(Equal(0))
err = connPool.Remove(cn, errors.New("test"))
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))
}
})
})
2016-03-17 14:48:04 +03:00
var _ = Describe("race", func() {
var connPool *pool.ConnPool
2016-03-17 19:00:47 +03:00
var C, N int
2016-03-17 14:48:04 +03:00
BeforeEach(func() {
2016-03-17 19:00:47 +03:00
C, N = 10, 1000
if testing.Short() {
C = 4
N = 100
}
2016-03-17 14:48:04 +03:00
})
AfterEach(func() {
connPool.Close()
})
2016-03-17 19:00:47 +03:00
It("does not happen on Get, Put, and Remove", func() {
connPool = pool.NewConnPool(
dummyDialer, 10, time.Minute, time.Millisecond, time.Millisecond)
connPool.DialLimiter = nil
2016-03-17 14:48:04 +03:00
perform(C, func(id int) {
for i := 0; i < N; i++ {
cn, err := connPool.Get()
2016-03-17 19:00:47 +03:00
Expect(err).NotTo(HaveOccurred())
2016-03-17 14:48:04 +03:00
if err == nil {
2016-03-17 19:00:47 +03:00
Expect(connPool.Put(cn)).NotTo(HaveOccurred())
2016-03-17 14:48:04 +03:00
}
}
}, func(id int) {
for i := 0; i < N; i++ {
cn, err := connPool.Get()
2016-03-17 19:00:47 +03:00
Expect(err).NotTo(HaveOccurred())
2016-03-17 14:48:04 +03:00
if err == nil {
2016-03-17 19:00:47 +03:00
Expect(connPool.Remove(cn, errors.New("test"))).NotTo(HaveOccurred())
2016-03-17 14:48:04 +03:00
}
}
2016-03-17 19:00:47 +03:00
})
})
It("does not happen on Get and PopFree", func() {
connPool = pool.NewConnPool(
dummyDialer, 10, time.Minute, time.Second, time.Millisecond)
connPool.DialLimiter = nil
perform(C, func(id int) {
2016-03-17 14:48:04 +03:00
for i := 0; i < N; i++ {
cn, err := connPool.Get()
2016-03-17 19:00:47 +03:00
Expect(err).NotTo(HaveOccurred())
2016-03-17 14:48:04 +03:00
if err == nil {
2016-03-17 19:00:47 +03:00
Expect(connPool.Put(cn)).NotTo(HaveOccurred())
}
cn = connPool.PopFree()
if cn != nil {
Expect(connPool.Put(cn)).NotTo(HaveOccurred())
2016-03-17 14:48:04 +03:00
}
}
})
})
})