Add MaxConnAge

internal/pool/pool_test.go

@@ -248,114 +248,128 @@ var _ = Describe("MinIdleConns", func() {
 
 var _ = Describe("conns reaper", func() {
 	const idleTimeout = time.Minute
+	const maxAge = time.Hour
 
 	var connPool *pool.ConnPool
-	var conns, idleConns, closedConns []*pool.Conn
+	var conns, staleConns, closedConns []*pool.Conn
 
-	BeforeEach(func() {
-		conns = nil
-		closedConns = nil
+	assert := func(typ string) {
+		BeforeEach(func() {
+			closedConns = nil
+			connPool = pool.NewConnPool(&pool.Options{
+				Dialer:             dummyDialer,
+				PoolSize:           10,
+				IdleTimeout:        idleTimeout,
+				MaxConnAge:         maxAge,
+				PoolTimeout:        time.Second,
+				IdleCheckFrequency: time.Hour,
+				OnClose: func(cn *pool.Conn) error {
+					closedConns = append(closedConns, cn)
+					return nil
+				},
+			})
 
-		connPool = pool.NewConnPool(&pool.Options{
-			Dialer:             dummyDialer,
-			PoolSize:           10,
-			PoolTimeout:        time.Second,
-			IdleTimeout:        idleTimeout,
-			IdleCheckFrequency: time.Hour,
+			conns = nil
 
-			OnClose: func(cn *pool.Conn) error {
-				closedConns = append(closedConns, cn)
-				return nil
-			},
-		})
-
-		// add stale connections
-		idleConns = nil
-		for i := 0; i < 3; i++ {
-			cn, err := connPool.Get()
-			Expect(err).NotTo(HaveOccurred())
-			cn.SetUsedAt(time.Now().Add(-2 * idleTimeout))
-			conns = append(conns, cn)
-			idleConns = append(idleConns, 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 {
-			connPool.Put(cn)
-		}
-
-		Expect(connPool.Len()).To(Equal(6))
-		Expect(connPool.IdleLen()).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.IdleLen()).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.IdleLen()).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(idleConns)))
-		Expect(closedConns).To(ConsistOf(idleConns))
-	})
-
-	It("pool is functional", func() {
-		for j := 0; j < 3; j++ {
-			var freeCns []*pool.Conn
+			// add stale connections
+			staleConns = nil
 			for i := 0; i < 3; i++ {
 				cn, err := connPool.Get()
 				Expect(err).NotTo(HaveOccurred())
-				Expect(cn).NotTo(BeNil())
-				freeCns = append(freeCns, cn)
+				switch typ {
+				case "idle":
+					cn.SetUsedAt(time.Now().Add(-2 * idleTimeout))
+				case "aged":
+					cn.InitedAt = time.Now().Add(-2 * maxAge)
+				}
+				conns = append(conns, cn)
+				staleConns = append(staleConns, cn)
 			}
 
-			Expect(connPool.Len()).To(Equal(3))
-			Expect(connPool.IdleLen()).To(Equal(0))
+			// add fresh connections
+			for i := 0; i < 3; i++ {
+				cn, err := connPool.Get()
+				Expect(err).NotTo(HaveOccurred())
+				conns = append(conns, cn)
+			}
 
-			cn, err := connPool.Get()
-			Expect(err).NotTo(HaveOccurred())
-			Expect(cn).NotTo(BeNil())
-			conns = append(conns, cn)
-
-			Expect(connPool.Len()).To(Equal(4))
-			Expect(connPool.IdleLen()).To(Equal(0))
-
-			connPool.Remove(cn)
-
-			Expect(connPool.Len()).To(Equal(3))
-			Expect(connPool.IdleLen()).To(Equal(0))
-
-			for _, cn := range freeCns {
+			for _, cn := range conns {
+				if cn.InitedAt.IsZero() {
+					cn.InitedAt = time.Now()
+				}
 				connPool.Put(cn)
 			}
 
+			Expect(connPool.Len()).To(Equal(6))
+			Expect(connPool.IdleLen()).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.IdleLen()).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.IdleLen()).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.IdleLen()).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.IdleLen()).To(Equal(0))
+
+				connPool.Remove(cn)
+
+				Expect(connPool.Len()).To(Equal(3))
+				Expect(connPool.IdleLen()).To(Equal(0))
+
+				for _, cn := range freeCns {
+					connPool.Put(cn)
+				}
+
+				Expect(connPool.Len()).To(Equal(3))
+				Expect(connPool.IdleLen()).To(Equal(3))
+			}
+		})
+	}
+
+	assert("idle")
+	assert("aged")
 })
 
 var _ = Describe("race", func() {