Idle Timeout #103

Author: rymsha

src/main/java/com/enonic/lib/http/client/HttpClientFactory.java

@@ -5,9 +5,12 @@
 import java.net.InetSocketAddress;
 import java.net.PasswordAuthentication;
 import java.net.ProxySelector;
+import java.net.URI;
 import java.net.http.HttpClient;
 import java.nio.CharBuffer;
 import java.time.Duration;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.Executor;
@@ -26,18 +29,33 @@
 
 class HttpClientFactory
 {
+    private static final long IDLE_TIMEOUT_MS = Long.getLong( "com.enonic.lib.http.client.idle.timeout", 30000 );
+
     private static final long DEFAULT_CONNECT_TIMEOUT_MS = 10_000;
 
     private static final int DEFAULT_PROXY_PORT = 8080;
 
-    private static final ConcurrentMap<String, HttpClient> CACHE = new ConcurrentHashMap<>();
+    private static final ConcurrentMap<String, HttpClientWrapper> CACHE = new ConcurrentHashMap<>();
 
     private static final Executor SHARED_WORKERS_EXECUTOR = Executors.newCachedThreadPool( new SharedWorkerThreadFactory() );
 
     private HttpClientFactory()
     {
     }
 
+    private static class HttpClientWrapper
+    {
+        final HttpClient client;
+
+        final Map<String, Long> lastAccess;
+
+        public HttpClientWrapper( final HttpClient client, Map<String, Long> lastAccess )
+        {
+            this.client = client;
+            this.lastAccess = lastAccess;
+        }
+    }
+
     static class ClientParams
     {
         final Duration connectTimeout;
@@ -212,9 +230,54 @@ static void clearCache()
         CACHE.clear();
     }
 
-    static HttpClient getHttpClient( ClientParams params )
+    static HttpClient getHttpClient( final ClientParams params, final URI uri )
     {
-        return CACHE.computeIfAbsent( cacheKey( params ), c -> createClient( params ) );
+        return CACHE.compute( cacheKey( params ), ( key, old ) -> {
+            if ( IDLE_TIMEOUT_MS <= 0 )
+            {
+                return old != null ? old : new HttpClientWrapper( createClient( params ), null );
+            }
+            final String keyForRequest = keyForRequest( uri, params.proxy );
+            final long currentTimeMillis = System.currentTimeMillis();
+
+            final Long lastAccess = old != null ? old.lastAccess.get( keyForRequest ) : null;
+
+            if ( old != null && ( lastAccess == null || lastAccess > currentTimeMillis - IDLE_TIMEOUT_MS ) )
+            {
+                old.lastAccess.put( keyForRequest, currentTimeMillis );
+                return old;
+            }
+            else
+            {
+                return new HttpClientWrapper( createClient( params ), new HashMap<>( Map.of( keyForRequest, currentTimeMillis ) ) );
+            }
+        } ).client;
+    }
+
+    private static String keyForRequest( final URI uri, final InetSocketAddress proxy )
+    {
+        final boolean isSecure = Utils.isSecure( uri );
+        final String host = uri.getHost();
+        final int port = uri.getPort() == -1 ? ( isSecure ? 443 : 80 ) : uri.getPort();
+
+        final StringBuilder keyBuilder = new StringBuilder( isSecure ? "S:" : "C:" );
+
+        if ( proxy == null )
+        {
+            keyBuilder.append( "H:" ).append( host ).append( ":" ).append( port );
+        }
+        else
+        {
+            if ( isSecure )
+            {
+                keyBuilder.append( "T:H:" ).append( host ).append( ":" ).append( port ).append( ";" );
+            }
+            final String proxyHost = proxy.getHostString();
+            final int proxyPort = proxy.getPort();
+
+            keyBuilder.append( "P:" ).append( proxyHost ).append( ":" ).append( proxyPort );
+        }
+        return keyBuilder.toString();
     }
 
     private static String cacheKey( final ClientParams params )

src/main/java/com/enonic/lib/http/client/HttpRequestHandler.java

@@ -95,7 +95,7 @@ private HttpResponse<Supplier<ByteSource>> executeRequest()
                                                                            .build() );
 
         final HttpClient client = HttpClientFactory.getHttpClient( HttpClientFactory.params()
-                                                                       .disableHttp2( !url.startsWith( "https://" ) )
+                                                                       .disableHttp2( !Utils.isSecure( request.uri() ) )
                                                                        .connectTimeout( connectionTimeout )
                                                                        .authUser( authUser )
                                                                        .authPassword( authPassword )
@@ -106,7 +106,7 @@ private HttpResponse<Supplier<ByteSource>> executeRequest()
                                                                        .followRedirects( followRedirects )
                                                                        .certificates( certificates )
                                                                        .clientCertificate( clientCertificate )
-                                                                       .build() );
+                                                                       .build(), request.uri() );
 
         return client.send( request, mapToFullyReadByteSource(
             MoreBodySubscribers.withReadTimeout( HttpResponse.BodySubscribers.ofInputStream(),

src/main/java/com/enonic/lib/http/client/Utils.java

@@ -31,6 +31,11 @@ private Utils()
     {
     }
 
+    public static boolean isSecure( final URI uri )
+    {
+        return uri.getScheme().equalsIgnoreCase( "https" );
+    }
+
     public static long getContentLength( final HttpHeaders headers )
     {
         try

src/test/java/com/enonic/lib/http/client/HttpRequestHandlerTest.java

@@ -5,7 +5,6 @@
 import java.util.concurrent.TimeUnit;
 
 import org.junit.After;
-import org.junit.Ignore;
 import org.junit.Test;
 import org.mockito.Mockito;