fixes #559

WebReactiveOptions support for maxIdleTime and maxLifeTime

feign-reactor-webclient/src/main/java/reactivefeign/webclient/NettyClientHttpConnectorBuilder.java

@@ -33,25 +33,33 @@ private NettyClientHttpConnectorBuilder() {
     public static ClientHttpConnector buildNettyClientHttpConnector(HttpClient httpClient, WebReactiveOptions webOptions) {
 
         if (httpClient == null) {
-            ConnectionProvider connectionProvider = TcpResources.get();
-
-            Integer maxConnections = webOptions.getMaxConnections();
-            Integer pendingAcquireMaxCount = webOptions.getPendingAcquireMaxCount();
-            Long pendingAcquireTimeoutMillis = webOptions.getPendingAcquireTimeoutMillis();
-            if (maxConnections != null || pendingAcquireMaxCount != null || pendingAcquireTimeoutMillis != null) {
-                ConnectionProvider.Builder connectionProviderBuilder = connectionProvider.mutate();
-                if (maxConnections != null) {
-                    connectionProviderBuilder = connectionProviderBuilder.maxConnections(maxConnections);
-                }
-                if (pendingAcquireMaxCount != null) {
-                    connectionProviderBuilder = connectionProviderBuilder.pendingAcquireMaxCount(pendingAcquireMaxCount);
-                }
-                if (pendingAcquireTimeoutMillis != null) {
-                    Duration pendingAcquireTimeout = Duration.ofMillis(pendingAcquireTimeoutMillis);
-                    connectionProviderBuilder = connectionProviderBuilder.pendingAcquireTimeout(pendingAcquireTimeout);
-                }
-                connectionProvider = connectionProviderBuilder.build();
+
+            ConnectionProvider connectionProvider = webOptions.getConnectionProvider();
+            if(connectionProvider == null){
+                connectionProvider = TcpResources.get();
+            }
+
+            ConnectionProvider.Builder connectionProviderBuilder = connectionProvider.mutate();
+            if (webOptions.getMaxConnections() != null) {
+                connectionProviderBuilder = connectionProviderBuilder.maxConnections(webOptions.getMaxConnections());
             }
+            if(webOptions.getConnectionMaxIdleTimeMillis() != null){
+                connectionProviderBuilder = connectionProviderBuilder.maxIdleTime(
+                        Duration.ofMillis(webOptions.getConnectionMaxIdleTimeMillis()));
+            }
+            if(webOptions.getConnectionMaxLifeTimeMillis() != null){
+                connectionProviderBuilder = connectionProviderBuilder.maxLifeTime(
+                        Duration.ofMillis(webOptions.getConnectionMaxLifeTimeMillis()));
+            }
+            if (webOptions.getPendingAcquireMaxCount() != null) {
+                connectionProviderBuilder = connectionProviderBuilder.pendingAcquireMaxCount(webOptions.getPendingAcquireMaxCount());
+            }
+            if (webOptions.getPendingAcquireTimeoutMillis() != null) {
+                connectionProviderBuilder = connectionProviderBuilder.pendingAcquireTimeout(
+                        Duration.ofMillis(webOptions.getPendingAcquireTimeoutMillis()));
+            }
+
+            connectionProvider = connectionProviderBuilder.build();
 
             httpClient = HttpClient.create(connectionProvider)
                     .runOn(HttpResources.get(), DEFAULT_NATIVE);

feign-reactor-webclient/src/main/java/reactivefeign/webclient/WebReactiveOptions.java

@@ -15,6 +15,7 @@
 
 import io.netty.handler.ssl.SslContext;
 import reactivefeign.ReactiveOptions;
+import reactor.netty.resources.ConnectionProvider;
 
 /**
  * @author Sergii Karpenko
@@ -31,9 +32,13 @@ public class WebReactiveOptions extends ReactiveOptions {
   private final Long readTimeoutMillis;
   private final Long writeTimeoutMillis;
   private final Long responseTimeoutMillis;
-  private SslContext sslContext;
+  private final SslContext sslContext;
   private final Boolean disableSslValidation;
+
+  private final ConnectionProvider connectionProvider;
   private final Integer maxConnections;
+  private final Long connectionMaxIdleTimeMillis;
+  private final Long connectionMaxLifeTimeMillis;
   private final Integer pendingAcquireMaxCount;
   private final Long pendingAcquireTimeoutMillis;
 
@@ -42,15 +47,21 @@ private WebReactiveOptions(Boolean useHttp2, Long connectTimeoutMillis,
                              Boolean tryUseCompression, Boolean followRedirects,
                              ProxySettings proxySettings,
                              SslContext sslContext, Boolean disableSslValidation,
-                             Integer maxConnections, Integer pendingAcquireMaxCount, Long pendingAcquireTimeoutMillis) {
+                             ConnectionProvider connectionProvider,
+                             Integer maxConnections,
+                             Long connectionMaxIdleTimeMillis, Long connectionMaxLifeTimeMillis,
+                             Integer pendingAcquireMaxCount, Long pendingAcquireTimeoutMillis) {
     super(useHttp2, connectTimeoutMillis, tryUseCompression, followRedirects, proxySettings);
 
     this.readTimeoutMillis = readTimeoutMillis;
     this.writeTimeoutMillis = writeTimeoutMillis;
     this.responseTimeoutMillis = responseTimeoutMillis;
     this.sslContext = sslContext;
     this.disableSslValidation = disableSslValidation;
+    this.connectionProvider = connectionProvider;
     this.maxConnections = maxConnections;
+    this.connectionMaxIdleTimeMillis = connectionMaxIdleTimeMillis;
+    this.connectionMaxLifeTimeMillis = connectionMaxLifeTimeMillis;
     this.pendingAcquireMaxCount = pendingAcquireMaxCount;
     this.pendingAcquireTimeoutMillis = pendingAcquireTimeoutMillis;
   }
@@ -79,10 +90,22 @@ public SslContext getSslContext() {
     return sslContext;
   }
 
+  public ConnectionProvider getConnectionProvider() {
+    return connectionProvider;
+  }
+
   public Integer getMaxConnections() {
     return maxConnections;
   }
 
+  public Long getConnectionMaxIdleTimeMillis() {
+    return connectionMaxIdleTimeMillis;
+  }
+
+  public Long getConnectionMaxLifeTimeMillis() {
+    return connectionMaxLifeTimeMillis;
+  }
+
   public Integer getPendingAcquireMaxCount() {
     return pendingAcquireMaxCount;
   }
@@ -97,7 +120,10 @@ public static class Builder extends ReactiveOptions.Builder {
     private Long responseTimeoutMillis;
     private Boolean disableSslValidation;
     private SslContext sslContext;
+    private ConnectionProvider connectionProvider;
     private Integer maxConnections;
+    private Long connectionMaxIdleTimeMillis;
+    private Long connectionMaxLifeTimeMillis;
     private Integer pendingAcquireMaxCount;
     private Long pendingAcquireTimeoutMillis;
 
@@ -133,6 +159,16 @@ public Builder setMaxConnections(Integer maxConnections) {
       return this;
     }
 
+    public Builder setConnectionMaxIdleTimeMillis(Long connectionMaxIdleTimeMillis) {
+      this.connectionMaxIdleTimeMillis = connectionMaxIdleTimeMillis;
+      return this;
+    }
+
+    public Builder setConnectionMaxLifeTimeMillis(Long connectionMaxLifeTimeMillis) {
+      this.connectionMaxLifeTimeMillis = connectionMaxLifeTimeMillis;
+      return this;
+    }
+
     public Builder setPendingAcquireMaxCount(Integer pendingAcquireMaxCount) {
       this.pendingAcquireMaxCount = pendingAcquireMaxCount;
       return this;
@@ -148,7 +184,9 @@ public WebReactiveOptions build() {
               readTimeoutMillis, writeTimeoutMillis, responseTimeoutMillis,
               acceptCompressed, followRedirects, proxySettings,
               sslContext, disableSslValidation,
-              maxConnections, pendingAcquireMaxCount, pendingAcquireTimeoutMillis);
+              connectionProvider,
+              maxConnections, connectionMaxIdleTimeMillis, connectionMaxLifeTimeMillis,
+              pendingAcquireMaxCount, pendingAcquireTimeoutMillis);
     }
   }