Set max-life-time to shrink pool (#237)

* Even though idle connections are evicted from the pool it's
  likeley that connections in the pool are "touched" also during infrequent usage,
  i.e. they are not idle.
* By setting the max-life-time the connections are cycled out from the pool and
  the number of connections in the pool will shrink, as long as there is not demand
  for more connections.

Author: patriknw

core/src/main/resources/reference.conf

@@ -141,9 +141,15 @@ akka.persistence.r2dbc {
     acquire-retry = 20
 
     # Maximum idle time of the connection in the pool.
-    # This value is used as an interval for background eviction of idle connections.
+    # Background eviction interval of idle connections is derived from this property
+    # and max-life-time.
     max-idle-time = 30 minutes
 
+    # Maximum lifetime of the connection in the pool.
+    # Background eviction interval of connections is derived from this property
+    # and max-idle-time.
+    max-life-time = 60 minutes
+
     # Configures the statement cache size.
     # 0 means no cache, negative values will select an unbounded cache
     # a positive value will configure a bounded cache with the passed size.

core/src/main/scala/akka/persistence/r2dbc/ConnectionFactoryProvider.scala

@@ -8,6 +8,7 @@ import java.time.{ Duration => JDuration }
 import java.util.concurrent.ConcurrentHashMap
 
 import scala.concurrent.Future
+import scala.concurrent.duration.Duration
 import scala.jdk.CollectionConverters.ConcurrentMapHasAsScala
 
 import akka.Done
@@ -96,6 +97,19 @@ class ConnectionFactoryProvider(system: ActorSystem[_]) extends Extension {
   private def createConnectionPoolFactory(settings: ConnectionFactorySettings): ConnectionPool = {
     val connectionFactory = createConnectionFactory(settings)
 
+    val evictionInterval = {
+      import settings.{ maxIdleTime, maxLifeTime }
+      if (maxIdleTime <= Duration.Zero && maxLifeTime <= Duration.Zero) {
+        JDuration.ZERO
+      } else if (maxIdleTime <= Duration.Zero) {
+        JDuration.ofMillis((maxLifeTime / 4).toMillis)
+      } else if (maxLifeTime <= Duration.Zero) {
+        JDuration.ofMillis((maxIdleTime / 4).toMillis)
+      } else {
+        JDuration.ofMillis((maxIdleTime.min(maxIdleTime) / 4).toMillis)
+      }
+    }
+
     val poolConfiguration = ConnectionPoolConfiguration
       .builder(connectionFactory)
       .initialSize(settings.initialSize)
@@ -104,9 +118,8 @@ class ConnectionFactoryProvider(system: ActorSystem[_]) extends Extension {
       .maxAcquireTime(JDuration.ofMillis(settings.acquireTimeout.toMillis))
       .acquireRetry(settings.acquireRetry)
       .maxIdleTime(JDuration.ofMillis(settings.maxIdleTime.toMillis))
-      // setting lifetime due to issue https://github.com/r2dbc/r2dbc-pool/issues/129
-      .maxLifeTime(JDuration.ofDays(365 * 100))
-      .backgroundEvictionInterval(JDuration.ofMillis((settings.maxIdleTime / 4).toMillis))
+      .maxLifeTime(JDuration.ofMillis(settings.maxLifeTime.toMillis))
+      .backgroundEvictionInterval(evictionInterval)
 
     if (settings.validationQuery.nonEmpty)
       poolConfiguration.validationQuery(settings.validationQuery)

core/src/main/scala/akka/persistence/r2dbc/R2dbcSettings.scala

@@ -101,6 +101,7 @@ final class ConnectionFactorySettings(config: Config) {
   val initialSize: Int = config.getInt("initial-size")
   val maxSize: Int = config.getInt("max-size")
   val maxIdleTime: FiniteDuration = config.getDuration("max-idle-time").asScala
+  val maxLifeTime: FiniteDuration = config.getDuration("max-life-time").asScala
 
   val createTimeout: FiniteDuration = config.getDuration("create-timeout").asScala
   val acquireTimeout: FiniteDuration = config.getDuration("acquire-timeout").asScala