Duration PR comment fixed, polishing

Author: Viktors Baltauss

src/main/java/io/r2dbc/postgresql/MultipleHostsClientFactory.java

@@ -11,6 +11,7 @@
 import javax.annotation.Nullable;
 import java.net.InetSocketAddress;
 import java.net.SocketAddress;
+import java.time.Duration;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -115,7 +116,9 @@ private Flux<SocketAddress> getCandidates(TargetServerType targetServerType) {
             int counter = 0;
             for (SocketAddress address : addresses) {
                 HostSpecStatus currentStatus = this.statusMap.get(address);
-                if (currentStatus == null || now > currentStatus.updated + this.configuration.getHostRecheckTime()) {
+                Duration hostRecheckDuration = this.configuration.getHostRecheckTime();
+                boolean recheck = currentStatus == null || hostRecheckDuration.plusMillis(currentStatus.updated).toMillis() < now;
+                if (recheck) {
                     sink.next(address);
                     counter++;
                 } else if (targetServerType.allowStatus(currentStatus.hostStatus)) {

src/main/java/io/r2dbc/postgresql/PostgresqlConnectionConfiguration.java

@@ -598,12 +598,12 @@ public Builder targetServerType(TargetServerType targetServerType) {
         }
 
         /**
-         * Controls how long in seconds the knowledge about a host state is cached connection factory. The default value is 10000 milliseconds.
+         * Controls how long in milliseconds the knowledge about a host state is cached connection factory. The default value is 10000 milliseconds.
          *
          * @param hostRecheckTime host recheck time in milliseconds
          * @return this {@link Builder}
          */
-        public Builder hostRecheckTime(int hostRecheckTime) {
+        public Builder hostRecheckTime(@Nullable Duration hostRecheckTime) {
             if (this.multipleHostsConfiguration == null) {
                 this.multipleHostsConfiguration = MultipleHostsConfiguration.builder();
             }

src/main/java/io/r2dbc/postgresql/PostgresqlConnectionFactoryProvider.java

@@ -25,6 +25,7 @@
 import io.r2dbc.spi.Option;
 
 import javax.net.ssl.HostnameVerifier;
+import java.time.Duration;
 import java.util.Map;
 import java.util.function.Function;
 
@@ -232,6 +233,7 @@ private static PostgresqlConnectionConfiguration.Builder fromConnectionFactoryOp
 
         if (isUsingTcp(connectionFactoryOptions)) {
             setupSsl(builder, connectionFactoryOptions);
+            setupFailover(builder, connectionFactoryOptions);
         } else {
             builder.socket(connectionFactoryOptions.getRequiredValue(SOCKET));
         }
@@ -263,27 +265,11 @@ private static void setSslHostnameVerifier(PostgresqlConnectionConfiguration.Bui
         }
     }
 
-    private static void setupSsl(PostgresqlConnectionConfiguration.Builder builder, ConnectionFactoryOptions connectionFactoryOptions) {
-        Boolean ssl = connectionFactoryOptions.getValue(SSL);
-        if (ssl != null && ssl) {
-            builder.enableSsl();
-        }
-
-        Object sslMode = connectionFactoryOptions.getValue(SSL_MODE);
-        if (sslMode != null) {
-            if (sslMode instanceof String) {
-                builder.sslMode(SSLMode.fromValue(sslMode.toString()));
-            } else {
-                builder.sslMode((SSLMode) sslMode);
-            }
-        }
-
-        builder.connectTimeout(connectionFactoryOptions.getValue(CONNECT_TIMEOUT));
-        builder.database(connectionFactoryOptions.getValue(DATABASE));
-
+    private static void setupFailover(PostgresqlConnectionConfiguration.Builder builder, ConnectionFactoryOptions connectionFactoryOptions) {
         if (FAILOVER_PROTOCOL.equals(connectionFactoryOptions.getValue(PROTOCOL))) {
             if (connectionFactoryOptions.hasOption(HOST_RECHECK_TIME)) {
-                builder.hostRecheckTime(connectionFactoryOptions.getRequiredValue(HOST_RECHECK_TIME));
+                Duration hostRecheckTime = Duration.ofMillis(connectionFactoryOptions.getRequiredValue(HOST_RECHECK_TIME));
+                builder.hostRecheckTime(hostRecheckTime);
             }
             if (connectionFactoryOptions.hasOption(LOAD_BALANCE_HOSTS)) {
                 Object loadBalanceHosts = connectionFactoryOptions.getRequiredValue(LOAD_BALANCE_HOSTS);
@@ -323,11 +309,22 @@ private static void setupSsl(PostgresqlConnectionConfiguration.Builder builder,
                 builder.port(port);
             }
         }
+    }
 
+    private static void setupSsl(PostgresqlConnectionConfiguration.Builder builder, ConnectionFactoryOptions connectionFactoryOptions) {
+        Boolean ssl = connectionFactoryOptions.getValue(SSL);
+        if (ssl != null && ssl) {
+            builder.enableSsl();
+        }
 
-        builder.password(connectionFactoryOptions.getValue(PASSWORD));
-        builder.schema(connectionFactoryOptions.getValue(SCHEMA));
-        builder.username(connectionFactoryOptions.getRequiredValue(USER));
+        Object sslMode = connectionFactoryOptions.getValue(SSL_MODE);
+        if (sslMode != null) {
+            if (sslMode instanceof String) {
+                builder.sslMode(SSLMode.fromValue(sslMode.toString()));
+            } else {
+                builder.sslMode((SSLMode) sslMode);
+            }
+        }
 
         String sslRootCert = connectionFactoryOptions.getValue(SSL_ROOT_CERT);
         if (sslRootCert != null) {

src/main/java/io/r2dbc/postgresql/client/MultipleHostsConfiguration.java

@@ -3,6 +3,7 @@
 import io.r2dbc.postgresql.TargetServerType;
 import io.r2dbc.postgresql.util.Assert;
 
+import java.time.Duration;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -12,20 +13,20 @@ public class MultipleHostsConfiguration {
 
     private final List<ServerHost> hosts;
 
-    private final int hostRecheckTime;
+    private final Duration hostRecheckTime;
 
     private final boolean loadBalanceHosts;
 
     private final TargetServerType targetServerType;
 
-    public MultipleHostsConfiguration(List<ServerHost> hosts, int hostRecheckTime, boolean loadBalanceHosts, TargetServerType targetServerType) {
+    public MultipleHostsConfiguration(List<ServerHost> hosts, Duration hostRecheckTime, boolean loadBalanceHosts, TargetServerType targetServerType) {
         this.hosts = hosts;
         this.hostRecheckTime = hostRecheckTime;
         this.loadBalanceHosts = loadBalanceHosts;
         this.targetServerType = targetServerType;
     }
 
-    public int getHostRecheckTime() {
+    public Duration getHostRecheckTime() {
         return hostRecheckTime;
     }
 
@@ -95,7 +96,7 @@ public static Builder builder() {
      */
     public static class Builder {
 
-        private int hostRecheckTime = 10000;
+        private Duration hostRecheckTime = Duration.ofMillis(10000);
 
         private List<ServerHost> hosts = new ArrayList<>();
 
@@ -124,7 +125,7 @@ public Builder targetServerType(TargetServerType targetServerType) {
          * @param hostRecheckTime host recheck time in milliseconds
          * @return this {@link Builder}
          */
-        public Builder hostRecheckTime(int hostRecheckTime) {
+        public Builder hostRecheckTime(Duration hostRecheckTime) {
             this.hostRecheckTime = hostRecheckTime;
             return this;
         }

src/test/java/io/r2dbc/postgresql/PostgresqlConnectionFactoryProviderTest.java

@@ -23,6 +23,7 @@
 import io.r2dbc.spi.Option;
 import org.junit.jupiter.api.Test;
 
+import java.time.Duration;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -297,7 +298,7 @@ void testFailoverConfiguration() {
 
         assertThat(factory.getConfiguration().getSingleHostConfiguration()).isNull();
         assertThat(factory.getConfiguration().getMultipleHostsConfiguration().isLoadBalanceHosts()).isEqualTo(true);
-        assertThat(factory.getConfiguration().getMultipleHostsConfiguration().getHostRecheckTime()).isEqualTo(20000);
+        assertThat(factory.getConfiguration().getMultipleHostsConfiguration().getHostRecheckTime()).isEqualTo(Duration.ofMillis(20000));
         assertThat(factory.getConfiguration().getMultipleHostsConfiguration().getTargetServerType()).isEqualTo(TargetServerType.SECONDARY);
         List<MultipleHostsConfiguration.ServerHost> hosts = factory.getConfiguration().getMultipleHostsConfiguration().getHosts();
         assertThat(hosts).hasSize(3);