make connection pool configurable

Author: tbarbugli

DOCS.md

@@ -55,7 +55,9 @@ You can override this behavior by explicitly passing in the API key and secret a
 var properties = new Properties();
 properties.put(DefaultClient.API_KEY_PROP_NAME, "<api-key>");
 properties.put(DefaultClient.API_SECRET_PROP_NAME, "<api-secret>");
+properties.put(DefaultClient.CONNECTION_POOL_MAX_IDLE_CONNECTIONS_PROP_NAME, "20");
 var client = new DefaultClient(properties);
+client.setConnectionPool(20, Duration.ofSeconds(59));
 DefaultClient.setInstance(client);
 ```
 
@@ -1896,4 +1898,4 @@ Import.createImport(createUrlResponse.getPath(), Import.ImportMode.Upsert);
 ```java
 // signature comes from the HTTP header x-signature
 boolean valid =  App.verifyWebhook(body, signature)
-```
+```

README.md

@@ -132,6 +132,8 @@ To configure the SDK you need to provide required properties
 | io.getstream.chat.apiSecret | STREAM_SECRET       | -                              | Yes      |
 | io.getstream.chat.timeout   | STREAM_CHAT_TIMEOUT | 10000                          | No       |
 | io.getstream.chat.url       | STREAM_CHAT_URL     | https://chat.stream-io-api.com | No       |
+| io.getstream.chat.connectionPool.maxIdleConnections | STREAM_CHAT_CONNECTION_POOL_MAX_IDLE_CONNECTIONS | 5 | No |
+| io.getstream.chat.connectionPool.keepAliveDurationMs | STREAM_CHAT_CONNECTION_POOL_KEEP_ALIVE_DURATION_MS | 59000 | No |
 
 You can also use your own CDN by creating an implementation of FileHandler and setting it this way
 
@@ -141,6 +143,20 @@ Message.fileHandlerClass = MyFileHandler.class
 
 All setup must be done prior to any request to the API.
 
+You can also tune the underlying OkHttp connection pool explicitly:
+
+```java
+var properties = new Properties();
+properties.put(DefaultClient.API_KEY_PROP_NAME, "<api-key>");
+properties.put(DefaultClient.API_SECRET_PROP_NAME, "<api-secret>");
+properties.put(DefaultClient.CONNECTION_POOL_MAX_IDLE_CONNECTIONS_PROP_NAME, "20");
+properties.put(DefaultClient.CONNECTION_POOL_KEEP_ALIVE_DURATION_PROP_NAME, "59000");
+
+var client = new DefaultClient(properties);
+client.setConnectionPool(20, Duration.ofSeconds(59));
+DefaultClient.setInstance(client);
+```
+
 ## Print Chat app configuration
 
 <table>

src/main/java/io/getstream/chat/java/services/framework/Client.java

@@ -19,6 +19,8 @@ public interface Client {
 
   void setTimeout(@NotNull Duration timeoutDuration);
 
+  void setConnectionPool(int maxIdleConnections, @NotNull Duration keepAliveDuration);
+
   static Client getInstance() {
     return DefaultClient.getInstance();
   }

src/main/java/io/getstream/chat/java/services/framework/DefaultClient.java

@@ -33,8 +33,14 @@ public class DefaultClient implements Client {
   public static final String API_TIMEOUT_PROP_NAME = "io.getstream.chat.timeout";
   public static final String API_URL_PROP_NAME = "io.getstream.chat.url";
   public static final String X_STREAM_EXT_PROP_NAME = "io.getstream.chat.xStreamExt";
+  public static final String CONNECTION_POOL_MAX_IDLE_CONNECTIONS_PROP_NAME =
+      "io.getstream.chat.connectionPool.maxIdleConnections";
+  public static final String CONNECTION_POOL_KEEP_ALIVE_DURATION_PROP_NAME =
+      "io.getstream.chat.connectionPool.keepAliveDurationMs";
 
   private static final String API_DEFAULT_URL = "https://chat.stream-io-api.com";
+  private static final int DEFAULT_MAX_IDLE_CONNECTIONS = 5;
+  private static final long DEFAULT_KEEP_ALIVE_DURATION_MS = 59_000L;
   private static volatile DefaultClient defaultInstance;
   @NotNull private final String apiSecret;
   @NotNull private final String apiKey;
@@ -98,7 +104,7 @@ public DefaultClient(
   private OkHttpClient buildOkHttpClient() {
     OkHttpClient.Builder httpClient =
         new OkHttpClient.Builder()
-            .connectionPool(new ConnectionPool(5, 59, TimeUnit.SECONDS))
+            .connectionPool(buildConnectionPool(extendedProperties))
             .callTimeout(getStreamChatTimeout(extendedProperties), TimeUnit.MILLISECONDS);
     httpClient.interceptors().clear();
 
@@ -191,6 +197,24 @@ public void setTimeout(@NotNull Duration timeoutDuration) {
     this.serviceFactory = serviceFactoryBuilder.apply(retrofit);
   }
 
+  @Override
+  public void setConnectionPool(int maxIdleConnections, @NotNull Duration keepAliveDuration) {
+    if (maxIdleConnections < 0) {
+      throw new IllegalArgumentException("maxIdleConnections must be >= 0");
+    }
+    if (keepAliveDuration.isNegative()) {
+      throw new IllegalArgumentException("keepAliveDuration must be >= 0");
+    }
+
+    extendedProperties.setProperty(
+        CONNECTION_POOL_MAX_IDLE_CONNECTIONS_PROP_NAME, Integer.toString(maxIdleConnections));
+    extendedProperties.setProperty(
+        CONNECTION_POOL_KEEP_ALIVE_DURATION_PROP_NAME,
+        Long.toString(keepAliveDuration.toMillis()));
+    this.retrofit = buildRetrofitClient(buildOkHttpClient());
+    this.serviceFactory = serviceFactoryBuilder.apply(retrofit);
+  }
+
   private static @NotNull String jwtToken(String apiSecret) {
     Key signingKey =
         new SecretKeySpec(
@@ -233,6 +257,24 @@ private static Properties extendProperties(Properties properties) {
       canformedProperties.put(API_TIMEOUT_PROP_NAME, envTimeout);
     }
 
+    var envConnectionPoolMaxIdleConnections =
+        env.getOrDefault(
+            "STREAM_CHAT_CONNECTION_POOL_MAX_IDLE_CONNECTIONS",
+            System.getProperty("STREAM_CHAT_CONNECTION_POOL_MAX_IDLE_CONNECTIONS"));
+    if (envConnectionPoolMaxIdleConnections != null) {
+      canformedProperties.put(
+          CONNECTION_POOL_MAX_IDLE_CONNECTIONS_PROP_NAME, envConnectionPoolMaxIdleConnections);
+    }
+
+    var envConnectionPoolKeepAliveDuration =
+        env.getOrDefault(
+            "STREAM_CHAT_CONNECTION_POOL_KEEP_ALIVE_DURATION_MS",
+            System.getProperty("STREAM_CHAT_CONNECTION_POOL_KEEP_ALIVE_DURATION_MS"));
+    if (envConnectionPoolKeepAliveDuration != null) {
+      canformedProperties.put(
+          CONNECTION_POOL_KEEP_ALIVE_DURATION_PROP_NAME, envConnectionPoolKeepAliveDuration);
+    }
+
     var envApiUrl = env.getOrDefault("STREAM_CHAT_URL", System.getProperty("STREAM_CHAT_URL"));
     if (envApiUrl != null) {
       canformedProperties.put(API_URL_PROP_NAME, envApiUrl);
@@ -255,6 +297,37 @@ private static long getStreamChatTimeout(@NotNull Properties properties) {
     return Long.parseLong(timeout.toString());
   }
 
+  private static @NotNull ConnectionPool buildConnectionPool(@NotNull Properties properties) {
+    return new ConnectionPool(
+        getConnectionPoolMaxIdleConnections(properties),
+        getConnectionPoolKeepAliveDurationMs(properties),
+        TimeUnit.MILLISECONDS);
+  }
+
+  private static int getConnectionPoolMaxIdleConnections(@NotNull Properties properties) {
+    var maxIdleConnections =
+        properties.getOrDefault(
+            CONNECTION_POOL_MAX_IDLE_CONNECTIONS_PROP_NAME, DEFAULT_MAX_IDLE_CONNECTIONS);
+    int parsedMaxIdleConnections = Integer.parseInt(maxIdleConnections.toString());
+    if (parsedMaxIdleConnections < 0) {
+      throw new IllegalArgumentException(
+          CONNECTION_POOL_MAX_IDLE_CONNECTIONS_PROP_NAME + " must be >= 0");
+    }
+    return parsedMaxIdleConnections;
+  }
+
+  private static long getConnectionPoolKeepAliveDurationMs(@NotNull Properties properties) {
+    var keepAliveDuration =
+        properties.getOrDefault(
+            CONNECTION_POOL_KEEP_ALIVE_DURATION_PROP_NAME, DEFAULT_KEEP_ALIVE_DURATION_MS);
+    long parsedKeepAliveDuration = Long.parseLong(keepAliveDuration.toString());
+    if (parsedKeepAliveDuration < 0) {
+      throw new IllegalArgumentException(
+          CONNECTION_POOL_KEEP_ALIVE_DURATION_PROP_NAME + " must be >= 0");
+    }
+    return parsedKeepAliveDuration;
+  }
+
   private static String getStreamChatBaseUrl(@NotNull Properties properties) {
     var url = properties.getOrDefault(API_URL_PROP_NAME, API_DEFAULT_URL);
     return url.toString();

src/main/java/io/getstream/chat/java/services/framework/UserClient.java

@@ -69,4 +69,15 @@ public UserClient(Client delegate, String userToken) {
   public void setTimeout(@NotNull Duration timeoutDuration) {
     delegate.setTimeout(timeoutDuration);
   }
+
+  /**
+   * Sets the HTTP connection pool configuration on the underlying client.
+   *
+   * @param maxIdleConnections the maximum number of idle connections to keep in the pool
+   * @param keepAliveDuration how long idle connections should be kept alive
+   */
+  @Override
+  public void setConnectionPool(int maxIdleConnections, @NotNull Duration keepAliveDuration) {
+    delegate.setConnectionPool(maxIdleConnections, keepAliveDuration);
+  }
 }

src/test/java/io/getstream/chat/java/DefaultClientConfigurationTest.java

@@ -0,0 +1,86 @@
+package io.getstream.chat.java;
+
+import io.getstream.chat.java.services.framework.DefaultClient;
+import java.lang.reflect.Field;
+import java.time.Duration;
+import java.util.Properties;
+import okhttp3.ConnectionPool;
+import okhttp3.OkHttpClient;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import retrofit2.Retrofit;
+
+public class DefaultClientConfigurationTest {
+
+  @Test
+  @DisplayName("DefaultClient uses configured connection pool properties")
+  void givenConnectionPoolProperties_whenCreatingClient_thenUsesConfiguredPool() {
+    var properties = baseProperties();
+    properties.put(DefaultClient.CONNECTION_POOL_MAX_IDLE_CONNECTIONS_PROP_NAME, "20");
+    properties.put(DefaultClient.CONNECTION_POOL_KEEP_ALIVE_DURATION_PROP_NAME, "120000");
+
+    var client = new DefaultClient(properties);
+    var pool = getConnectionPool(client);
+
+    Assertions.assertEquals(20, readIntField(poolDelegate(pool), "maxIdleConnections"));
+    Assertions.assertEquals(
+        Duration.ofMinutes(2).toNanos(), readLongField(poolDelegate(pool), "keepAliveDurationNs"));
+  }
+
+  @Test
+  @DisplayName("DefaultClient can update connection pool at runtime")
+  void whenSettingConnectionPool_thenRebuildsClientWithNewPool() {
+    var client = new DefaultClient(baseProperties());
+
+    client.setConnectionPool(15, Duration.ofSeconds(30));
+
+    var pool = getConnectionPool(client);
+    Assertions.assertEquals(15, readIntField(poolDelegate(pool), "maxIdleConnections"));
+    Assertions.assertEquals(
+        Duration.ofSeconds(30).toNanos(), readLongField(poolDelegate(pool), "keepAliveDurationNs"));
+  }
+
+  private static Properties baseProperties() {
+    var properties = new Properties();
+    properties.put(DefaultClient.API_KEY_PROP_NAME, "test-key");
+    properties.put(DefaultClient.API_SECRET_PROP_NAME, "test-secret");
+    return properties;
+  }
+
+  private static ConnectionPool getConnectionPool(DefaultClient client) {
+    Retrofit retrofit = (Retrofit) readField(client, "retrofit");
+    OkHttpClient okHttpClient = (OkHttpClient) readField(retrofit, "callFactory");
+    return okHttpClient.connectionPool();
+  }
+
+  private static Object poolDelegate(ConnectionPool pool) {
+    return readField(pool, "delegate");
+  }
+
+  private static int readIntField(Object target, String fieldName) {
+    return (int) readField(target, fieldName);
+  }
+
+  private static long readLongField(Object target, String fieldName) {
+    return (long) readField(target, fieldName);
+  }
+
+  private static Object readField(Object target, String fieldName) {
+    Class<?> type = target.getClass();
+    while (type != null) {
+      try {
+        Field field = type.getDeclaredField(fieldName);
+        field.setAccessible(true);
+        return field.get(target);
+      } catch (NoSuchFieldException ignored) {
+        type = type.getSuperclass();
+      } catch (IllegalAccessException ex) {
+        throw new IllegalStateException(ex);
+      }
+    }
+
+    throw new IllegalStateException(
+        String.format("Field '%s' not found on %s", fieldName, target.getClass().getName()));
+  }
+}