Configure the default connector by its config

Signed-off-by: jansupol <[email protected]>

Author: jansupol

connectors/netty-connector/src/main/java/org/glassfish/jersey/netty/connector/JerseyClientHandler.java

@@ -143,7 +143,7 @@ protected void notifyResponse(ChannelHandlerContext ctx) {
                           ctx.close();
                           if (redirectController.prepareRedirect(newReq, cr)) {
                               final NettyConnector newConnector =
-                                      new NettyConnector(newReq.getClient(), connector.connectorConfiguration);
+                                      new NettyConnector(newReq.getClient(), connector.clientConfiguration);
                               newConnector.execute(newReq, redirectUriHistory, new CompletableFuture<ClientResponse>() {
                                   @Override
                                   public boolean complete(ClientResponse value) {

connectors/netty-connector/src/main/java/org/glassfish/jersey/netty/connector/NettyClientProperties.java

@@ -72,6 +72,11 @@ public class NettyClientProperties {
      */
     public static final String IDLE_CONNECTION_PRUNE_TIMEOUT = "jersey.config.client.idleConnectionPruneTimeout";
 
+    /**
+     * Enable or disable the Netty logging by {@code LoggingHandler(Level.DEBUG)}. Disabled by default.
+     */
+    public static final String LOGGING_ENABLED = "jersey.config.client.netty.loggingEnabled";
+
     /**
      *  <p>
      *    This property determines the maximum number of idle connections that will be simultaneously kept alive, per destination.

connectors/netty-connector/src/main/java/org/glassfish/jersey/netty/connector/NettyConnector.java

@@ -61,6 +61,8 @@
 import io.netty.handler.codec.http.HttpUtil;
 import io.netty.handler.codec.http.HttpVersion;
 import io.netty.handler.codec.http.LastHttpContent;
+import io.netty.handler.logging.LogLevel;
+import io.netty.handler.logging.LoggingHandler;
 import io.netty.handler.ssl.ApplicationProtocolConfig;
 import io.netty.handler.ssl.ClientAuth;
 import io.netty.handler.ssl.IdentityCipherSuiteFilter;
@@ -96,7 +98,7 @@ class NettyConnector implements Connector {
     final EventLoopGroup group;
     final Client client;
     final HashMap<String, ArrayList<Channel>> connections = new HashMap<>();
-    final NettyConnectorProvider.Config.RW connectorConfiguration;
+    final NettyConnectorProvider.Config.RW clientConfiguration;
 
     private static final LazyValue<String> NETTY_VERSION = Values.lazy(
         (Value<String>) () -> {
@@ -117,18 +119,18 @@ class NettyConnector implements Connector {
 
     NettyConnector(Client client, NettyConnectorProvider.Config.RW connectorConfiguration) {
         this.client = client;
-        this.connectorConfiguration = connectorConfiguration.fromClient(client);
+        this.clientConfiguration = connectorConfiguration.fromClient(client);
 
         final Configuration configuration = client.getConfiguration();
-        final Integer threadPoolSize = this.connectorConfiguration.asyncThreadPoolSize();
+        final Integer threadPoolSize = this.clientConfiguration.asyncThreadPoolSize();
         if (threadPoolSize != null && threadPoolSize > 0) {
             executorService = VirtualThreadUtil
-                                .withConfig(connectorConfiguration.prefixedConfiguration(configuration))
+                                .withConfig(clientConfiguration.prefixedConfiguration(configuration))
                                 .newFixedThreadPool(threadPoolSize);
             this.group = new NioEventLoopGroup(threadPoolSize);
         } else {
             executorService = VirtualThreadUtil
-                                .withConfig(connectorConfiguration.prefixedConfiguration(configuration))
+                                .withConfig(clientConfiguration.prefixedConfiguration(configuration))
                                 .newCachedThreadPool();
             this.group = new NioEventLoopGroup();
         }
@@ -165,7 +167,7 @@ public Future<?> apply(final ClientRequest jerseyRequest, final AsyncConnectorCa
     protected void execute(final ClientRequest jerseyRequest, final Set<URI> redirectUriHistory,
             final CompletableFuture<ClientResponse> responseAvailable) {
         final NettyConnectorProvider.Config.RW requestConfiguration =
-                connectorConfiguration
+                clientConfiguration
                         .fromRequest(jerseyRequest)
                         .readTimeout(jerseyRequest)
                         .expect100ContinueTimeout(jerseyRequest);
@@ -183,7 +185,7 @@ protected void execute(final ClientRequest jerseyRequest, final Set<URI> redirec
                 : "https".equalsIgnoreCase(requestUri.getScheme()) ? 443 : 80;
 
         try {
-            final SSLParamConfigurator sslConfig = SSLParamConfigurator.builder()
+            final SSLParamConfigurator sslConfig = SSLParamConfigurator.builder(requestConfiguration)
                     .request(jerseyRequest).setSNIAlways(true).setSNIHostName(jerseyRequest).build();
 
             final String key = requestConfiguration
@@ -272,6 +274,9 @@ protected void initChannel(SocketChannel ch) throws Exception {
                          p.addLast(sslHandler);
                      }
 
+                     if (requestConfiguration.loggingEnabled.get()) {
+                         p.addLast(new LoggingHandler(LogLevel.INFO));
+                     }
                      p.addLast(requestConfiguration.createHttpClientCodec(config.getProperties()));
                      p.addLast(EXPECT_100_CONTINUE_HANDLER, expect100ContinueHandler);
                      p.addLast(new ChunkedWriteHandler());

connectors/netty-connector/src/main/java/org/glassfish/jersey/netty/connector/NettyConnectorConfiguration.java

@@ -36,22 +36,21 @@
 class NettyConnectorConfiguration<N extends NettyConnectorConfiguration<N>> extends ConnectorConfiguration<N> {
 
     /* package */ final NullableRef<NettyConnectionController> connectionController = NullableRef.empty();
-    /* package */ final NullableRef<Boolean> enableHostnameVerification = NullableRef.of(Boolean.TRUE);
-    /* package */ final Ref<Integer> expect100ContTimeout = NullableRef.of(
-                                                                NettyClientProperties.DEFAULT_EXPECT_100_CONTINUE_TIMEOUT_VALUE);
-    /* package */ final NullableRef<Boolean> filterHeadersForProxy = NullableRef.of(Boolean.TRUE);
-    /* package */ final NullableRef<Integer> firstHttpHeaderLineLength = NullableRef.of(
-                                                                NettyClientProperties.DEFAULT_INITIAL_LINE_LENGTH);
-    /* package */ final NullableRef<Integer> maxChunkSize = NullableRef.of(NettyClientProperties.DEFAULT_CHUNK_SIZE);
-    /* package */ final NullableRef<Integer> maxHeaderSize = NullableRef.of(NettyClientProperties.DEFAULT_HEADER_SIZE);
+    /* package */ final NullableRef<Boolean> enableHostnameVerification = NullableRef.empty();
+    /* package */ final Ref<Integer> expect100ContTimeout = NullableRef.empty();
+    /* package */ final NullableRef<Boolean> filterHeadersForProxy = NullableRef.empty();
+    /* package */ final NullableRef<Integer> firstHttpHeaderLineLength = NullableRef.empty();
+    /* package */ final Ref<Boolean> loggingEnabled = NullableRef.empty();
+    /* package */ final NullableRef<Integer> maxChunkSize = NullableRef.empty();
+    /* package */ final NullableRef<Integer> maxHeaderSize = NullableRef.empty();
     // either from Jersey config, or default
-    /* package */ final Ref<Integer> maxPoolSizeTotal = NullableRef.of(DEFAULT_MAX_POOL_SIZE_TOTAL);
+    /* package */ final Ref<Integer> maxPoolSizeTotal = NullableRef.empty();
     // either from Jersey config, or default
-    /* package */ final Ref<Integer> maxPoolIdle = NullableRef.of(DEFAULT_MAX_POOL_IDLE);
+    /* package */ final Ref<Integer> maxPoolIdle = NullableRef.empty();
     // either from system property, or from Jersey config, or default
-    /* package */ final Ref<Integer> maxPoolSize = NullableRef.of(HTTP_KEEPALIVE ? MAX_POOL_SIZE : DEFAULT_MAX_POOL_SIZE);
-    /* package */ final Ref<Integer> maxRedirects = NullableRef.of(DEFAULT_MAX_REDIRECTS);
-    /* package */ final NullableRef<Boolean> preserveMethodOnRedirect = NullableRef.of(Boolean.TRUE);
+    /* package */ final Ref<Integer> maxPoolSize = NullableRef.empty();
+    /* package */ final Ref<Integer> maxRedirects = NullableRef.empty();
+    /* package */ final NullableRef<Boolean> preserveMethodOnRedirect = NullableRef.empty();
     /* package */ final NullableRef<NettyHttpRedirectController> redirectController = NullableRef.empty();
 
     // If HTTP keepalive is enabled the value of "http.maxConnections" determines the maximum number
@@ -69,27 +68,6 @@ class NettyConnectorConfiguration<N extends NettyConnectorConfiguration<N>> exte
 
     private static final int DEFAULT_MAX_REDIRECTS = 5;
 
-    @Override
-    protected <X extends ConnectorConfiguration<?>> void setNonEmpty(X otherCC) {
-        NettyConnectorConfiguration<?> other = (NettyConnectorConfiguration<?>) otherCC;
-        super.setNonEmpty(other);
-        this.connectionController.setNonEmpty(other.connectionController);
-        this.redirectController.setNonEmpty(other.redirectController);
-        this.connectionController.setNonEmpty(other.connectionController);
-        this.enableHostnameVerification.setNonEmpty(other.enableHostnameVerification);
-        ((NullableRef<Integer>) this.expect100ContTimeout).setNonEmpty((NullableRef<Integer>) other.expect100ContTimeout);
-        this.filterHeadersForProxy.setNonEmpty(other.filterHeadersForProxy);
-        this.firstHttpHeaderLineLength.setNonEmpty(other.firstHttpHeaderLineLength);
-        this.maxChunkSize.setNonEmpty(other.maxChunkSize);
-        this.maxHeaderSize.setNonEmpty(other.maxHeaderSize);
-        ((NullableRef<Integer>) this.maxPoolIdle).setNonEmpty((NullableRef<Integer>) other.maxPoolIdle);
-        ((NullableRef<Integer>) this.maxPoolSize).setNonEmpty((NullableRef<Integer>) other.maxPoolSize);
-        ((NullableRef<Integer>) this.maxPoolSizeTotal).setNonEmpty((NullableRef<Integer>) other.maxPoolSizeTotal);
-        ((NullableRef<Integer>) this.maxRedirects).setNonEmpty((NullableRef<Integer>) other.maxRedirects);
-        this.preserveMethodOnRedirect.setNonEmpty(other.preserveMethodOnRedirect);
-        this.redirectController.setNonEmpty(other.redirectController);
-    }
-
     /**
      * Set the connection pooling controller for the Netty Connector.
      *
@@ -115,7 +93,7 @@ public N expect100ContinueTimeout(int millis) {
 
     /**
      * Enable or disable the endpoint identification algorithm to HTTPS. The property
-     * {@link NettyClientProperties#ENABLE_SSL_HOSTNAME_VERIFICATION} has  over this setting.
+     * {@link NettyClientProperties#ENABLE_SSL_HOSTNAME_VERIFICATION} takes precedence over this setting.
      *
      * @param enable enable or disable the hostname verification.
      * @return updated configuration.
@@ -125,6 +103,18 @@ public N enableSslHostnameVerification(boolean enable) {
         return self();
     }
 
+    /**
+     * Enable or disable the Netty logging by {@code LoggingHandler(Level.DEBUG)}. Disabled by default.
+     * The property {@link NettyClientProperties#LOGGING_ENABLED} takes precedence over this setting.
+     *
+     * @param enable to enable or disable.
+     * @return updated configuration.
+     */
+    public N enableLoggingHandler(boolean enable) {
+        loggingEnabled.set(enable);
+        return self();
+    }
+
     /**
      * Filter the HTTP headers for requests (CONNECT) towards the proxy except for PROXY-prefixed
      * and HOST headers when {@code true}.
@@ -257,6 +247,49 @@ abstract static class ReadWrite<N extends ReadWrite<N>>
             extends NettyConnectorConfiguration<N>
             implements ConnectorConfiguration.Read<N> {
 
+        @Override
+        public <X extends ConnectorConfiguration<?>> void setNonEmpty(X otherCC) {
+            NettyConnectorConfiguration<?> other = (NettyConnectorConfiguration<?>) otherCC;
+            ConnectorConfiguration.Read.super.setNonEmpty(other);
+            this.connectionController.setNonEmpty(other.connectionController);
+            this.redirectController.setNonEmpty(other.redirectController);
+            this.connectionController.setNonEmpty(other.connectionController);
+            this.enableHostnameVerification.setNonEmpty(other.enableHostnameVerification);
+            ((NullableRef<Integer>) this.expect100ContTimeout).setNonEmpty((NullableRef<Integer>) other.expect100ContTimeout);
+            this.filterHeadersForProxy.setNonEmpty(other.filterHeadersForProxy);
+            this.firstHttpHeaderLineLength.setNonEmpty(other.firstHttpHeaderLineLength);
+            ((NullableRef<Boolean>) this.loggingEnabled).setNonEmpty((NullableRef<Boolean>) other.loggingEnabled);
+            this.maxChunkSize.setNonEmpty(other.maxChunkSize);
+            this.maxHeaderSize.setNonEmpty(other.maxHeaderSize);
+            ((NullableRef<Integer>) this.maxPoolIdle).setNonEmpty((NullableRef<Integer>) other.maxPoolIdle);
+            ((NullableRef<Integer>) this.maxPoolSize).setNonEmpty((NullableRef<Integer>) other.maxPoolSize);
+            ((NullableRef<Integer>) this.maxPoolSizeTotal).setNonEmpty((NullableRef<Integer>) other.maxPoolSizeTotal);
+            ((NullableRef<Integer>) this.maxRedirects).setNonEmpty((NullableRef<Integer>) other.maxRedirects);
+            this.preserveMethodOnRedirect.setNonEmpty(other.preserveMethodOnRedirect);
+            this.redirectController.setNonEmpty(other.redirectController);
+        }
+
+        @Override
+        public N init() {
+            Read.super.init();
+            enableSslHostnameVerification(Boolean.TRUE);
+            expect100ContinueTimeout(NettyClientProperties.DEFAULT_EXPECT_100_CONTINUE_TIMEOUT_VALUE);
+            filterHeadersForProxy(Boolean.TRUE);
+            initialHttpHeaderLineLength(NettyClientProperties.DEFAULT_INITIAL_LINE_LENGTH);
+            enableLoggingHandler(Boolean.FALSE);
+            maxChunkSize(NettyClientProperties.DEFAULT_CHUNK_SIZE);
+            maxHeaderSize(NettyClientProperties.DEFAULT_HEADER_SIZE);
+            // either from Jersey config, or default
+            maxTotalConnections(DEFAULT_MAX_POOL_SIZE_TOTAL);
+            // either from Jersey config, or default
+            maxPoolIdle.set(DEFAULT_MAX_POOL_IDLE);
+            // either from system property, or from Jersey config, or default
+            maxPoolSize.set(HTTP_KEEPALIVE ? MAX_POOL_SIZE : DEFAULT_MAX_POOL_SIZE);
+            maxRedirects(DEFAULT_MAX_REDIRECTS);
+            preserveMethodOnRedirect(Boolean.TRUE);
+            return self();
+        }
+
         /**
          * Get the preset {@link NettyConnectionController} or create an instance of the default one, if not preset.
          * @return the {@link NettyConnectionController} instance.
@@ -350,29 +383,19 @@ abstract static class ReadWrite<N extends ReadWrite<N>>
          */
         /* package */ N fromClient(Client client) {
             final Map<String, Object> properties = client.getConfiguration().getProperties();
-            final N clientConfiguration = copy();
-            Object configProp = properties.get(prefixed(ClientProperties.CONNECTOR_CONFIGURATION));
-            if (configProp != null) {
-                NettyConnectorConfiguration<?> nettyCfg = (NettyConnectorConfiguration<?>) configProp;
-                if (prefix.equals(nettyCfg.prefix) || "".equals(nettyCfg.prefix.get())) {
-                    clientConfiguration.setNonEmpty(nettyCfg);
-                    clientConfiguration.prefix(prefix.get());
-                }
-            } else {
-                configProp = properties.get(ClientProperties.CONNECTOR_CONFIGURATION);
-                if (configProp != null && prefix.equals(((NettyConnectorConfiguration<?>) configProp).prefix)) {
-                    clientConfiguration.setNonEmpty((NettyConnectorConfiguration<?>) configProp);
-                }
-            }
+            final N clientConfiguration = copyFromClient(client.getConfiguration());
 
-            final Object threadPoolSize = properties.get(prefixed(ClientProperties.ASYNC_THREADPOOL_SIZE));
+            final Object threadPoolSize = properties.get(clientConfiguration.prefixed(ClientProperties.ASYNC_THREADPOOL_SIZE));
             if (threadPoolSize instanceof Integer && (Integer) threadPoolSize > 0) {
                 clientConfiguration.asyncThreadPoolSize((Integer) threadPoolSize);
             }
 
-            final Object maxPoolSizeTotalProperty = properties.get(prefixed(NettyClientProperties.MAX_CONNECTIONS_TOTAL));
-            final Object maxPoolIdleProperty = properties.get(prefixed(NettyClientProperties.IDLE_CONNECTION_PRUNE_TIMEOUT));
-            final Object maxPoolSizeProperty = properties.get(prefixed(NettyClientProperties.MAX_CONNECTIONS));
+            final Object maxPoolSizeTotalProperty = properties.get(
+                    clientConfiguration.prefixed(NettyClientProperties.MAX_CONNECTIONS_TOTAL));
+            final Object maxPoolIdleProperty = properties.get(
+                    clientConfiguration.prefixed(NettyClientProperties.IDLE_CONNECTION_PRUNE_TIMEOUT));
+            final Object maxPoolSizeProperty = properties.get(
+                    clientConfiguration.prefixed(NettyClientProperties.MAX_CONNECTIONS));
 
             if (maxPoolSizeTotalProperty != null) {
                 clientConfiguration.maxPoolSizeTotal.set((Integer) maxPoolSizeTotalProperty);
@@ -394,6 +417,13 @@ abstract static class ReadWrite<N extends ReadWrite<N>>
                 throw new ProcessingException(LocalizationMessages.WRONG_MAX_POOL_SIZE(maxPoolSize.get()));
             }
 
+            final Object logging = properties.get(clientConfiguration.prefixed(NettyClientProperties.LOGGING_ENABLED));
+            if (logging instanceof Boolean) {
+                clientConfiguration.loggingEnabled.set((Boolean) logging);
+            } else if (logging instanceof String) {
+                clientConfiguration.loggingEnabled.set(Boolean.valueOf((String) logging));
+            }
+
             return clientConfiguration;
         }
 
@@ -410,19 +440,11 @@ abstract static class ReadWrite<N extends ReadWrite<N>>
          * @return a new instance of configuration.
          */
         /* package */ N fromRequest(ClientRequest request) {
-            final N requestConfiguration = copy();
-            Object configProp = request.getProperty(prefixed(ClientProperties.CONNECTOR_CONFIGURATION));
-            if (configProp != null) {
-                NettyConnectorConfiguration<?> nettyCfg = (NettyConnectorConfiguration<?>) configProp;
-                if (prefix.equals(nettyCfg.prefix) || "".equals(nettyCfg.prefix.get())) {
-                    requestConfiguration.setNonEmpty(nettyCfg);
-                    requestConfiguration.prefix(prefix.get());
-                }
-            } else {
-                configProp = request.getProperty(ClientProperties.CONNECTOR_CONFIGURATION);
-                if (configProp != null && prefix.equals(((NettyConnectorConfiguration<?>) configProp).prefix)) {
-                    requestConfiguration.setNonEmpty((NettyConnectorConfiguration<?>) configProp);
-                }
+            final N requestConfiguration = copyFromRequest(request);
+
+            final Boolean logging = request.resolveProperty(prefixed(NettyClientProperties.LOGGING_ENABLED), Boolean.class);
+            if (logging != null) {
+                requestConfiguration.loggingEnabled.set(logging);
             }
 
             return requestConfiguration;
@@ -476,9 +498,6 @@ abstract static class ReadWrite<N extends ReadWrite<N>>
 
             return proxy;
         }
-
-        @Override
-        public abstract N self();
     }
 
 }

connectors/netty-connector/src/main/java/org/glassfish/jersey/netty/connector/NettyConnectorProvider.java

@@ -79,11 +79,6 @@ public static final class Config extends NettyConnectorConfiguration<Config> {
         private Config() {
         }
 
-        @Override
-        protected Config self() {
-            return this;
-        }
-
         /* package */ RW rw() {
             RW rw = new RW();
             rw.setNonEmpty(this);
@@ -100,8 +95,7 @@ public RW instance() {
                 return new RW();
             }
 
-            @Override
-            public RW self() {
+            public RW me() {
                 return this;
             }
         }