feat: Http connection pooling (#22)

* feat: HTTP connection pooling

* feat: HTTP connection pooling

Author: antonioT90

build.gradle.kts

@@ -32,6 +32,7 @@ repositories {
 val springDocOpenApiVersion = "2.8.5"
 val openApiToolsVersion = "0.2.6"
 val micrometerVersion = "1.4.3"
+val httpClientVersion = "5.4.2"
 
 dependencies {
   implementation("org.springframework.boot:spring-boot-starter")
@@ -43,6 +44,7 @@ dependencies {
   implementation("io.micrometer:micrometer-registry-prometheus")
   implementation("com.fasterxml.jackson.datatype:jackson-datatype-jsr310")
   implementation("org.openapitools:jackson-databind-nullable:$openApiToolsVersion")
+  implementation("org.apache.httpcomponents.client5:httpclient5:$httpClientVersion")
 
   compileOnly("org.projectlombok:lombok")
   annotationProcessor("org.projectlombok:lombok")

gradle.lockfile

@@ -44,6 +44,9 @@ jakarta.annotation:jakarta.annotation-api:2.1.1=compileClasspath
 jakarta.validation:jakarta.validation-api:3.0.2=compileClasspath
 jakarta.xml.bind:jakarta.xml.bind-api:4.0.2=compileClasspath
 org.apache.commons:commons-lang3:3.17.0=compileClasspath
+org.apache.httpcomponents.client5:httpclient5:5.4.2=compileClasspath
+org.apache.httpcomponents.core5:httpcore5-h2:5.3.3=compileClasspath
+org.apache.httpcomponents.core5:httpcore5:5.3.3=compileClasspath
 org.apache.logging.log4j:log4j-api:2.24.3=compileClasspath
 org.apache.logging.log4j:log4j-to-slf4j:2.24.3=compileClasspath
 org.apache.tomcat.embed:tomcat-embed-core:10.1.36=compileClasspath

src/main/java/it/gov/pagopa/template/config/HttpClientConfig.java

@@ -0,0 +1,37 @@
+package it.gov.pagopa.template.config;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.SuperBuilder;
+import org.springframework.boot.context.properties.NestedConfigurationProperty;
+
+@Data
+@SuperBuilder
+@NoArgsConstructor
+@AllArgsConstructor
+public class HttpClientConfig {
+    @NestedConfigurationProperty
+    private HttpClientConnectionPoolConfig connectionPool;
+    @NestedConfigurationProperty
+    private HttpClientTimeoutConfig timeout;
+
+    @Data
+    @SuperBuilder
+    @NoArgsConstructor
+    @AllArgsConstructor
+    public static class HttpClientConnectionPoolConfig {
+        private int size;
+        private int sizePerRoute;
+        private long timeToLiveMinutes;
+    }
+
+    @Data
+    @SuperBuilder
+    @NoArgsConstructor
+    @AllArgsConstructor
+    public static class HttpClientTimeoutConfig {
+        private long connectMillis;
+        private long readMillis;
+    }
+}

src/main/java/it/gov/pagopa/template/config/RestTemplateConfig.java

@@ -1,13 +1,16 @@
 package it.gov.pagopa.template.config;
 
 import it.gov.pagopa.template.performancelogger.RestInvokePerformanceLogger;
+import it.gov.pagopa.template.utils.HttpUtils;
 import it.gov.pagopa.template.utils.SecurityUtils;
 import jakarta.annotation.Nonnull;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.hc.client5.http.ssl.DefaultClientTlsStrategy;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.autoconfigure.web.client.RestTemplateBuilderConfigurer;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.boot.ssl.SslBundles;
 import org.springframework.boot.web.client.RestTemplateBuilder;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
@@ -21,28 +24,23 @@
 
 import java.io.IOException;
 import java.net.URI;
-import java.time.Duration;
 
 @Slf4j
 @Configuration(proxyBeanMethods = false)
 public class RestTemplateConfig {
-    private final int connectTimeoutMillis;
-    private final int readTimeoutHandlerMillis;
 
-    public RestTemplateConfig(
-            @Value("${rest.default-timeout.connect-millis}") int connectTimeoutMillis,
-            @Value("${rest.default-timeout.read-millis}") int readTimeoutHandlerMillis) {
-        this.connectTimeoutMillis = connectTimeoutMillis;
-        this.readTimeoutHandlerMillis = readTimeoutHandlerMillis;
-    }
+  @Bean
+  @ConfigurationProperties(prefix = "rest.defaults")
+  public HttpClientConfig defaultHttpClientConfig(){
+    return new HttpClientConfig();
+  }
 
-    @Bean
-    public RestTemplateBuilder restTemplateBuilder(RestTemplateBuilderConfigurer configurer) {
-        return configurer.configure(new RestTemplateBuilder())
-                .additionalInterceptors(new RestInvokePerformanceLogger())
-                .connectTimeout(Duration.ofMillis(connectTimeoutMillis))
-                .readTimeout(Duration.ofMillis(readTimeoutHandlerMillis));
-    }
+  @Bean
+  public RestTemplateBuilder restTemplateBuilder(RestTemplateBuilderConfigurer configurer, HttpClientConfig defaultHttpClientConfig, SslBundles sslBundles) {
+    return configurer.configure(new RestTemplateBuilder())
+      .additionalInterceptors(new RestInvokePerformanceLogger())
+      .requestFactoryBuilder(HttpUtils.buildPooledConnection(defaultHttpClientConfig, DefaultClientTlsStrategy.createSystemDefault()));
+  }
 
     public static ResponseErrorHandler bodyPrinterWhenError(String applicationName) {
         final Logger errorBodyLogger = LoggerFactory.getLogger("REST_INVOKE." + applicationName);

src/main/java/it/gov/pagopa/template/utils/HttpUtils.java

@@ -0,0 +1,37 @@
+package it.gov.pagopa.template.utils;
+
+import it.gov.pagopa.template.config.HttpClientConfig;
+import org.apache.hc.client5.http.config.ConnectionConfig;
+import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManagerBuilder;
+import org.apache.hc.client5.http.ssl.TlsSocketStrategy;
+import org.apache.hc.core5.pool.PoolConcurrencyPolicy;
+import org.apache.hc.core5.pool.PoolReusePolicy;
+import org.apache.hc.core5.util.TimeValue;
+import org.apache.hc.core5.util.Timeout;
+import org.springframework.boot.http.client.ClientHttpRequestFactoryBuilder;
+import org.springframework.boot.http.client.HttpComponentsClientHttpRequestFactoryBuilder;
+
+public class HttpUtils {
+    private HttpUtils() {
+    }
+
+    public static PoolingHttpClientConnectionManagerBuilder getPooledConnectionManagerBuilder(HttpClientConfig httpClientConfig, TlsSocketStrategy tlsSocketStrategy) {
+        return PoolingHttpClientConnectionManagerBuilder.create()
+                .setTlsSocketStrategy(tlsSocketStrategy)
+                .setPoolConcurrencyPolicy(PoolConcurrencyPolicy.STRICT)
+                .setConnPoolPolicy(PoolReusePolicy.LIFO)
+                .setMaxConnPerRoute(httpClientConfig.getConnectionPool().getSizePerRoute())
+                .setMaxConnTotal(httpClientConfig.getConnectionPool().getSize())
+                .setDefaultConnectionConfig(ConnectionConfig.custom()
+                        .setSocketTimeout(Timeout.ofMilliseconds(httpClientConfig.getTimeout().getReadMillis()))
+                        .setConnectTimeout(Timeout.ofMilliseconds(httpClientConfig.getTimeout().getConnectMillis()))
+                        .setTimeToLive(TimeValue.ofMinutes(httpClientConfig.getConnectionPool().getTimeToLiveMinutes()))
+                        .build());
+    }
+
+    public static HttpComponentsClientHttpRequestFactoryBuilder buildPooledConnection(HttpClientConfig httpClientConfig, TlsSocketStrategy tlsSocketStrategy) {
+        return ClientHttpRequestFactoryBuilder.httpComponents()
+                .withHttpClientCustomizer(configurer -> configurer
+                        .setConnectionManager(getPooledConnectionManagerBuilder(httpClientConfig, tlsSocketStrategy).build()));
+    }
+}

src/main/resources/application.yml

@@ -56,6 +56,11 @@ logging:
     PERFORMANCE_LOG.REST_INVOKE: "\${LOG_LEVEL_PERFORMANCE_LOG_REST_INVOKE:\${logging.level.PERFORMANCE_LOG}}"
 
 rest:
-  default-timeout:
-    connect-millis: "\${DEFAULT_REST_CONNECT_TIMEOUT_MILLIS:120000}"
-    read-millis: "\${DEFAULT_REST_READ_TIMEOUT_MILLIS:120000}"
+  defaults:
+    connection-pool:
+      size: "\${DEFAULT_REST_CONNECTION_POOL_SIZE:10}"
+      size-per-route: "\${DEFAULT_REST_CONNECTION_POOL_SIZE_PER_ROUTE:5}"
+      time-to-live-minutes: "\${DEFAULT_REST_CONNECTION_POOL_TIME_TO_LIVE_MINUTES:10}"
+    timeout:
+      connect-millis: "\${DEFAULT_REST_TIMEOUT_CONNECT_MILLIS:120000}"
+      read-millis: "\${DEFAULT_REST_TIMEOUT_READ_MILLIS:120000}"

src/test/java/it/gov/pagopa/template/utils/HttpUtilsTest.java

@@ -0,0 +1,78 @@
+package it.gov.pagopa.template.utils;
+
+import it.gov.pagopa.template.config.HttpClientConfig;
+import org.apache.hc.client5.http.HttpRoute;
+import org.apache.hc.client5.http.classic.HttpClient;
+import org.apache.hc.client5.http.config.ConnectionConfig;
+import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManager;
+import org.apache.hc.client5.http.ssl.TlsSocketStrategy;
+import org.apache.hc.core5.function.Resolver;
+import org.apache.hc.core5.util.Timeout;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
+
+import java.lang.reflect.Field;
+
+class HttpUtilsTest {
+
+    @Test
+    void whenGetPooledConnectionManagerBuilderThenReturnConfiguredConnectionManager() throws NoSuchFieldException, IllegalAccessException {
+        // Given
+        HttpClientConfig httpClientConfig = buildTestHttpClientConfig();
+        TlsSocketStrategy tlsSocketStrategy = Mockito.mock(TlsSocketStrategy.class);
+
+        // When
+        PoolingHttpClientConnectionManager result = HttpUtils.getPooledConnectionManagerBuilder(httpClientConfig, tlsSocketStrategy).build();
+
+        // Then
+        assertHttpClientConnectionManager(result);
+    }
+
+    @Test
+    void whenBuildPooledConnectionThenReturnConfiguredConnectionManager() throws NoSuchFieldException, IllegalAccessException {
+        // Given
+        HttpClientConfig httpClientConfig = buildTestHttpClientConfig();
+        TlsSocketStrategy tlsSocketStrategy = Mockito.mock(TlsSocketStrategy.class);
+
+        // When
+        HttpComponentsClientHttpRequestFactory result = HttpUtils.buildPooledConnection(httpClientConfig, tlsSocketStrategy).build();
+
+        // Then
+        HttpClient httpClient = result.getHttpClient();
+        Field connManagerField = httpClient.getClass().getDeclaredField("connManager");
+        connManagerField.setAccessible(true);
+        PoolingHttpClientConnectionManager pooledConnectionManager = (PoolingHttpClientConnectionManager) connManagerField.get(httpClient);
+        assertHttpClientConnectionManager(pooledConnectionManager);
+    }
+
+    private static HttpClientConfig buildTestHttpClientConfig() {
+        return HttpClientConfig.builder()
+                .connectionPool(HttpClientConfig.HttpClientConnectionPoolConfig.builder()
+                        .size(10)
+                        .sizePerRoute(5)
+                        .timeToLiveMinutes(3)
+                        .build())
+                .timeout(HttpClientConfig.HttpClientTimeoutConfig.builder()
+                        .connectMillis(1000)
+                        .readMillis(3000)
+                        .build())
+                .build();
+    }
+
+    @SuppressWarnings("unchecked")
+    private static void assertHttpClientConnectionManager(PoolingHttpClientConnectionManager result) throws NoSuchFieldException, IllegalAccessException {
+        Assertions.assertEquals(10, result.getMaxTotal());
+        Assertions.assertEquals(5, result.getDefaultMaxPerRoute());
+
+        Field connectionConfigResolverField = PoolingHttpClientConnectionManager.class.getDeclaredField("connectionConfigResolver");
+        connectionConfigResolverField.setAccessible(true);
+        Resolver<HttpRoute, ConnectionConfig> connectionConfigResolver = (Resolver<HttpRoute, ConnectionConfig>) connectionConfigResolverField.get(result);
+        ConnectionConfig connectionConfig = connectionConfigResolver.resolve(null);
+
+        Assertions.assertEquals(Timeout.ofMilliseconds(1_000), connectionConfig.getConnectTimeout());
+        Assertions.assertEquals(Timeout.ofMilliseconds(3_000), connectionConfig.getSocketTimeout());
+        Assertions.assertEquals(Timeout.ofMilliseconds(180_000), connectionConfig.getTimeToLive());
+    }
+}