Merge "Resolved JERSEY-2540."

Author: shamoh

connectors/grizzly-connector/src/main/java/org/glassfish/jersey/grizzly/connector/GrizzlyConnector.java

@@ -101,10 +101,13 @@ class GrizzlyConnector implements Connector {
     /**
      * Create new connector based on Grizzly asynchronous client library.
      *
-     * @param client Jersey client instance to create the connector for.
-     * @param config Jersey client runtime configuration to be used to configure the connector parameters.
+     * @param client                Jersey client instance to create the connector for.
+     * @param config                Jersey client runtime configuration to be used to configure the connector parameters.
+     * @param asyncClientCustomizer Async HTTP Client configuration builder customizer.
      */
-    GrizzlyConnector(Client client, Configuration config) {
+    GrizzlyConnector(final Client client,
+                     final Configuration config,
+                     final GrizzlyConnectorProvider.AsyncClientCustomizer asyncClientCustomizer) {
         AsyncHttpClientConfig.Builder builder = new AsyncHttpClientConfig.Builder();
 
         ExecutorService executorService;
@@ -161,6 +164,10 @@ class GrizzlyConnector implements Connector {
             builder.setHostnameVerifier(client.getHostnameVerifier());
         }
 
+        if (asyncClientCustomizer != null) {
+            builder = asyncClientCustomizer.customize(client, config, builder);
+        }
+
         AsyncHttpClientConfig asyncClientConfig = builder.build();
 
         this.grizzlyClient = new AsyncHttpClient(new GrizzlyAsyncHttpProvider(asyncClientConfig), asyncClientConfig);
@@ -401,6 +408,14 @@ public OutputStream getOutputStream(int contentLength) throws IOException {
                 builder.setBody(getEntityWriter(requestContext));
             }
         }
+
+        final GrizzlyConnectorProvider.RequestCustomizer requestCustomizer = requestContext.resolveProperty(
+                GrizzlyConnectorProvider.REQUEST_CUSTOMIZER,
+                GrizzlyConnectorProvider.RequestCustomizer.class);
+        if (requestCustomizer != null) {
+            builder = requestCustomizer.customize(requestContext, builder);
+        }
+
         return builder.build();
     }
 

connectors/grizzly-connector/src/main/java/org/glassfish/jersey/grizzly/connector/GrizzlyConnectorProvider.java

@@ -40,14 +40,20 @@
 package org.glassfish.jersey.grizzly.connector;
 
 import javax.ws.rs.client.Client;
+import javax.ws.rs.client.Invocation;
 import javax.ws.rs.core.Configurable;
 import javax.ws.rs.core.Configuration;
 
+import org.glassfish.jersey.client.ClientConfig;
+import org.glassfish.jersey.client.ClientRequest;
 import org.glassfish.jersey.client.Initializable;
 import org.glassfish.jersey.client.spi.Connector;
 import org.glassfish.jersey.client.spi.ConnectorProvider;
+import org.glassfish.jersey.internal.util.Property;
 
 import com.ning.http.client.AsyncHttpClient;
+import com.ning.http.client.AsyncHttpClientConfig;
+import com.ning.http.client.RequestBuilder;
 
 /**
  * Connector provider for Jersey {@link Connector connectors} that utilize
@@ -86,9 +92,135 @@
  * @since 2.5
  */
 public class GrizzlyConnectorProvider implements ConnectorProvider {
+    /**
+     * A {@link GrizzlyConnectorProvider.RequestCustomizer request customizer} instance to be used to customize the
+     * request.
+     *
+     * The value MUST be an instance implementing the  {@link GrizzlyConnectorProvider.RequestCustomizer} SPI.
+     * <p>
+     * A default value is not set (is {@code null}).
+     * </p>
+     * <p>
+     * The name of the configuration property is <tt>{@value}</tt>.
+     * </p>
+     *
+     * @see #register(Invocation.Builder, GrizzlyConnectorProvider.RequestCustomizer)
+     * @see org.glassfish.jersey.grizzly.connector.GrizzlyConnectorProvider.RequestCustomizer
+     */
+    @Property
+    static final String REQUEST_CUSTOMIZER = "jersey.config.grizzly.client.request.customizer";
+
+    private final AsyncClientCustomizer asyncClientCustomizer;
+
+    /**
+     * A customization SPI for the async client instance underlying Grizzly connectors.
+     * <p>
+     * An implementation of async client customizer can be
+     * registered in a {@code GrizzlyConnectorProvider}
+     * {@link GrizzlyConnectorProvider#GrizzlyConnectorProvider(GrizzlyConnectorProvider.AsyncClientCustomizer) constructor}.
+     * When a connector instance is then created, the customizer is invoked to update the
+     * {@link com.ning.http.client.AsyncHttpClientConfig.Builder underlying async client configuration builder} before the actual
+     * configuration instance is built and used to create the async client instance.
+     * The customizer thus provides a way how to configure parts of the underlying async client SPI that are not directly
+     * exposed in the {@code GrizzlyConnectorProvider} API.
+     * </p>
+     *
+     * @see org.glassfish.jersey.grizzly.connector.GrizzlyConnectorProvider.RequestCustomizer
+     * @since 2.10
+     */
+    public static interface AsyncClientCustomizer {
+        /**
+         * Customize the underlying asynchronous client configuration builder.
+         * <p>
+         * The configuration builder instance instance returned from the method will be subsequently used to build the
+         * configuration object that configures both the {@link com.ning.http.client.providers.grizzly.GrizzlyAsyncHttpProvider}
+         * Grizzly async client provider} as well as the underlying {@link com.ning.http.client.AsyncHttpClient async HTTP
+         * client} instance itself.
+         * </p>
+         * <p>
+         * Note that any JAX-RS and Jersey specific configuration updates on the configuration builder happen before this method
+         * is invoked. As such, changes made to the configuration builder may override or cancel the effect of the JAX-RS and
+         * Jersey specific configuration changes. As such any configuration changes should be made with care and implementers
+         * should be aware of possible side effect of their changes.
+         * </p>
+         *
+         * @param client        JAX-RS client for which the connector is being created.
+         * @param config        JAX-RS configuration that was used to initialize connector's configuration.
+         * @param configBuilder Async HTTP Client configuration builder that has been initialized based on the JAX-RS
+         *                      configuration.
+         * @return Async HTTP Client builder instance to be used to configure the underlying Grizzly provider and async HTTP
+         * client instance. Typically, the method returns the same {@code configBuilder} instance that has been passed into
+         * the method as an input parameter, but it is not required to do so.
+         */
+        public AsyncHttpClientConfig.Builder customize(final Client client,
+                                                       final Configuration config,
+                                                       final AsyncHttpClientConfig.Builder configBuilder);
+    }
+
+    /**
+     * A customization SPI for the async client request instances.
+     *
+     * A request customizer can be used to configure Async HTTP Client specific details of the request, which are not directly
+     * exposed via the JAX-RS, Jersey or Grizzly connector provider API.
+     * <p>
+     * Before a request is built and sent for execution, a registered request customizer
+     * implementation can update the Async HTTP Client {@link com.ning.http.client.RequestBuilder request builder} used
+     * to build the request instance ultimately sent for processing.
+     * An instance of the request customizer can be either {@link #register(ClientConfig, RequestCustomizer) registered globally}
+     * for all requests by registering the customizer in the Jersey client configuration, or it can be individually
+     * {@link #register(Invocation.Builder, RequestCustomizer) registered per request}, by registering it into a specific
+     * invocation builder instance. In case of a conflict when one instance is registered globally and another per request, the
+     * per request registered customizer takes precedence and the global customizer will be ignored.
+     * </p>
+     *
+     * @see org.glassfish.jersey.grizzly.connector.GrizzlyConnectorProvider.AsyncClientCustomizer
+     * @see #register(org.glassfish.jersey.client.ClientConfig, GrizzlyConnectorProvider.RequestCustomizer)
+     * @see #register(Invocation.Builder, GrizzlyConnectorProvider.RequestCustomizer)
+     * @since 2.10
+     */
+    public static interface RequestCustomizer {
+        /**
+         * Customize the underlying Async HTTP Client request builder associated with a specific Jersey client request.
+         * <p>
+         * The request builder instance returned from the method will be subsequently used to build the actual Async HTTP Client
+         * request instance sent for execution.
+         * </p>
+         * <p>
+         * Note that any JAX-RS and Jersey specific request configuration updates on the request builder happen before this
+         * method is invoked. As such, changes made to the request builder may override or cancel the effect of the JAX-RS and
+         * Jersey specific request configuration changes. As such any request builder changes should be made with care and
+         * implementers should be aware of possible side effect of their changes.
+         * </p>
+         *
+         * @param requestContext Jersey client request instance for which the Async HTTP Client request is being built.
+         * @param requestBuilder Async HTTP Client request builder for the Jersey request.
+         * @return Async HTTP Client request builder instance that will be used to build the actual Async HTTP Client
+         * request instance sent for execution. Typically, the method returns the same {@code requestBuilder} instance that
+         * has been passed into the method as an input parameter, but it is not required to do so.
+         */
+        public RequestBuilder customize(final ClientRequest requestContext, final RequestBuilder requestBuilder);
+    }
+
+    /**
+     * Create new Grizzly Async HTTP Client connector provider.
+     */
+    public GrizzlyConnectorProvider() {
+        this.asyncClientCustomizer = null;
+    }
+
+    /**
+     * Create new Grizzly Async HTTP Client connector provider with a custom client configuration customizer.
+     *
+     * @param asyncClientCustomizer Async HTTP Client configuration customizer.
+     * @since 2.10
+     */
+    public GrizzlyConnectorProvider(final AsyncClientCustomizer asyncClientCustomizer) {
+        this.asyncClientCustomizer = asyncClientCustomizer;
+    }
+
     @Override
     public Connector getConnector(Client client, Configuration config) {
-        return new GrizzlyConnector(client, config);
+        return new GrizzlyConnector(client, config, asyncClientCustomizer);
     }
 
     /**
@@ -124,4 +256,41 @@ public static AsyncHttpClient getHttpClient(Configurable<?> component) {
 
         throw new IllegalArgumentException(LocalizationMessages.EXPECTED_CONNECTOR_PROVIDER_NOT_USED());
     }
+
+    /**
+     * Register a request customizer for a single request.
+     *
+     * A registered customizer will be used to customize the underlying Async HTTP Client request builder.
+     * <p>
+     * Invoking this method on an instance that is not configured to use Grizzly Async HTTP Client
+     * connector does not have any effect.
+     * </p>
+     *
+     * @param builder    JAX-RS request invocation builder.
+     * @param customizer request customizer to be registered.
+     * @return updated Jersey client config with the Grizzly
+     * {@link org.glassfish.jersey.grizzly.connector.GrizzlyConnectorProvider.RequestCustomizer} attached.
+     */
+    public static Invocation.Builder register(Invocation.Builder builder, RequestCustomizer customizer) {
+        return builder.property(REQUEST_CUSTOMIZER, customizer);
+    }
+
+    /**
+     * Register a request customizer for a all requests executed by a client instance configured with this client config.
+     *
+     * A registered customizer will be used to customize underlying Async HTTP Client request builders for all requests created
+     * using the Jersey client instance configured with this client config.
+     * <p>
+     * Invoking this method on an instance that is not configured to use Grizzly Async HTTP Client
+     * connector does not have any effect.
+     * </p>
+     *
+     * @param config     Jersey client configuration.
+     * @param customizer Async HTTP Client configuration customizer.
+     * @return updated JAX-RS client invocation builder with the Grizzly
+     * {@link org.glassfish.jersey.grizzly.connector.GrizzlyConnectorProvider.RequestCustomizer RequestCustomizer} attached.
+     */
+    public static ClientConfig register(ClientConfig config, RequestCustomizer customizer) {
+        return config.property(REQUEST_CUSTOMIZER, customizer);
+    }
 }

connectors/grizzly-connector/src/test/java/org/glassfish/jersey/grizzly/connector/CustomizersTest.java

@@ -0,0 +1,155 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
+ * Copyright (c) 2014 Oracle and/or its affiliates. All rights reserved.
+ *
+ * The contents of this file are subject to the terms of either the GNU
+ * General Public License Version 2 only ("GPL") or the Common Development
+ * and Distribution License("CDDL") (collectively, the "License").  You
+ * may not use this file except in compliance with the License.  You can
+ * obtain a copy of the License at
+ * http://glassfish.java.net/public/CDDL+GPL_1_1.html
+ * or packager/legal/LICENSE.txt.  See the License for the specific
+ * language governing permissions and limitations under the License.
+ *
+ * When distributing the software, include this License Header Notice in each
+ * file and include the License file at packager/legal/LICENSE.txt.
+ *
+ * GPL Classpath Exception:
+ * Oracle designates this particular file as subject to the "Classpath"
+ * exception as provided by Oracle in the GPL Version 2 section of the License
+ * file that accompanied this code.
+ *
+ * Modifications:
+ * If applicable, add the following below the License Header, with the fields
+ * enclosed by brackets [] replaced by your own identifying information:
+ * "Portions Copyright [year] [name of copyright owner]"
+ *
+ * Contributor(s):
+ * If you wish your version of this file to be governed by only the CDDL or
+ * only the GPL Version 2, indicate your decision by adding "[Contributor]
+ * elects to include this software in this distribution under the [CDDL or GPL
+ * Version 2] license."  If you don't indicate a single choice of license, a
+ * recipient has the option to distribute your version of this file under
+ * either the CDDL, the GPL Version 2 or to extend the choice of license to
+ * its licensees as provided above.  However, if you add GPL Version 2 code
+ * and therefore, elected the GPL Version 2 license, then the option applies
+ * only if the new code is made subject to such option by the copyright
+ * holder.
+ */
+package org.glassfish.jersey.grizzly.connector;
+
+import javax.ws.rs.HeaderParam;
+import javax.ws.rs.POST;
+import javax.ws.rs.Path;
+import javax.ws.rs.client.Client;
+import javax.ws.rs.client.Invocation;
+import javax.ws.rs.core.Application;
+import javax.ws.rs.core.Configuration;
+import javax.ws.rs.core.Response;
+
+import static javax.ws.rs.client.Entity.text;
+
+import org.glassfish.jersey.client.ClientConfig;
+import org.glassfish.jersey.client.ClientRequest;
+import org.glassfish.jersey.server.ResourceConfig;
+import org.glassfish.jersey.test.JerseyTest;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+import com.ning.http.client.AsyncHttpClientConfig;
+import com.ning.http.client.RequestBuilder;
+import com.ning.http.client.filter.FilterContext;
+import com.ning.http.client.filter.FilterException;
+import com.ning.http.client.filter.RequestFilter;
+
+/**
+ * Async HTTP Client Config and Request customizers unit tests.
+ *
+ * @author Marek Potociar (marek.potociar at oracle.com)
+ */
+public class CustomizersTest extends JerseyTest {
+
+    @Path("/test")
+    public static class EchoResource {
+        @POST
+        public Response post(@HeaderParam("X-Test-Config") String testConfigHeader,
+                           @HeaderParam("X-Test-Request") String testRequestHeader,
+                           String entity) {
+            return Response.ok("POSTed " + entity)
+                    .header("X-Test-Config", testConfigHeader)
+                    .header("X-Test-Request", testRequestHeader)
+                    .build();
+        }
+    }
+
+    @Override
+    protected Application configure() {
+        return new ResourceConfig(EchoResource.class);
+    }
+
+    @Override
+    protected void configureClient(ClientConfig config) {
+        final GrizzlyConnectorProvider connectorProvider = new GrizzlyConnectorProvider(
+                new GrizzlyConnectorProvider.AsyncClientCustomizer() {
+                    @Override
+                    public AsyncHttpClientConfig.Builder customize(Client client,
+                                                                   Configuration config,
+                                                                   AsyncHttpClientConfig.Builder configBuilder) {
+                        return configBuilder.addRequestFilter(new RequestFilter() {
+                            @Override
+                            public FilterContext filter(FilterContext filterContext) throws FilterException {
+                                filterContext.getRequest().getHeaders().add("X-Test-Config", "tested");
+                                return filterContext;
+                            }
+                        });
+                    }
+                });
+        config.connectorProvider(connectorProvider);
+        GrizzlyConnectorProvider.register(config, new GrizzlyConnectorProvider.RequestCustomizer() {
+            @Override
+            public RequestBuilder customize(ClientRequest requestContext, RequestBuilder requestBuilder) {
+                requestBuilder.addHeader("X-Test-Request", "tested-global");
+                return requestBuilder;
+            }
+        });
+    }
+
+    /**
+     * Jersey-2540 related test.
+     */
+    @Test
+    public void testCustomizers() {
+        Response response;
+
+        // now using global request customizer
+        response = target("test").request().post(text("echo"));
+        assertEquals("POSTed echo", response.readEntity(String.class));
+        assertEquals("tested", response.getHeaderString("X-Test-Config"));
+        assertEquals("tested-global", response.getHeaderString("X-Test-Request"));
+
+
+        // now using request-specific request customizer
+        final Invocation.Builder builder = target("test").request();
+        GrizzlyConnectorProvider.register(builder, new GrizzlyConnectorProvider.RequestCustomizer() {
+            @Override
+            public RequestBuilder customize(ClientRequest requestContext, RequestBuilder requestBuilder) {
+                requestBuilder.addHeader("X-Test-Request", "tested-per-request");
+                return requestBuilder;
+            }
+        });
+        response = builder.post(text("echo"));
+        assertEquals("POSTed echo", response.readEntity(String.class));
+        assertEquals("tested", response.getHeaderString("X-Test-Config"));
+        assertEquals("tested-per-request", response.getHeaderString("X-Test-Request"));
+
+
+        // now using global request customizer again
+        response = target("test").request().post(text("echo"));
+        assertEquals("POSTed echo", response.readEntity(String.class));
+        assertEquals("tested", response.getHeaderString("X-Test-Config"));
+        assertEquals("tested-global", response.getHeaderString("X-Test-Request"));
+    }
+}