Remove blocking on future in ClientRuntime for async requests

- [Grizzly connector] Process response on grizzly's client application thread pool

Author: joejose2728

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

@@ -286,8 +286,13 @@ public STATE onHeadersReceived(HttpResponseHeaders headers) throws Exception {
 
                     HeaderUtils.checkHeaderChanges(clientHeadersSnapshot, request.getHeaders(),
                             GrizzlyConnector.this.getClass().getName());
-
-                    callback.response(translate(request, this.status, headers, entityStream));
+                    // hand-off to grizzly's application thread pool for response processing
+                    processResponse(new Runnable() {
+                        @Override
+                        public void run() {
+                           callback.response(translate(request, status, headers, entityStream));
+                        }
+                    });
                     return STATE.CONTINUE;
                 }
 
@@ -412,6 +417,14 @@ public OutputStream getOutputStream(int contentLength) throws IOException {
         return builder.build();
     }
 
+    /**
+     * Submits the response processing on Grizzly client's application thread pool
+     * @param responseTask task to be processed on application thread pool
+     */
+    public void processResponse(Runnable responseTask) {
+        this.grizzlyClient.getConfig().executorService().submit(responseTask);
+    }
+
     /**
      * Utility OutputStream implementation that can feed Grizzly chunk-encoded body generator.
      */

core-client/src/main/java/org/glassfish/jersey/client/ClientRuntime.java

@@ -40,18 +40,17 @@
 package org.glassfish.jersey.client;
 
 import java.util.Arrays;
-import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Future;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
 import javax.ws.rs.ProcessingException;
-import javax.ws.rs.client.ResponseProcessingException;
 import javax.ws.rs.core.HttpHeaders;
 import javax.ws.rs.core.MultivaluedMap;
 
+import org.glassfish.hk2.api.ServiceLocator;
 import org.glassfish.jersey.client.internal.LocalizationMessages;
 import org.glassfish.jersey.client.spi.AsyncConnectorCallback;
 import org.glassfish.jersey.client.spi.Connector;
@@ -67,10 +66,6 @@
 import org.glassfish.jersey.process.internal.Stage;
 import org.glassfish.jersey.process.internal.Stages;
 
-import org.glassfish.hk2.api.ServiceLocator;
-
-import jersey.repackaged.com.google.common.util.concurrent.SettableFuture;
-
 /**
  * Client-side request processing runtime.
  *
@@ -162,24 +157,26 @@ public void run() {
                         return;
                     }
 
-                    final SettableFuture<ClientResponse> responseFuture = SettableFuture.create();
                     final AsyncConnectorCallback connectorCallback = new AsyncConnectorCallback() {
 
                         @Override
                         public void response(final ClientResponse response) {
-                            responseFuture.set(response);
+                              requestScope.runInScope(new Runnable(){
+                                 public void run() {
+                                      processResponse(response, callback);
+                                 }});
                         }
 
                         @Override
                         public void failure(final Throwable failure) {
-                            responseFuture.setException(failure);
+                              requestScope.runInScope(new Runnable() {
+                                    public void run() {
+                                        processFailure(failure, callback);
+                                    }
+                            });
                         }
                     };
                     connector.apply(processedRequest, connectorCallback);
-
-                    processResponse(responseFuture.get(), callback);
-                } catch (final ExecutionException e) {
-                    processFailure(e.getCause(), callback);
                 } catch (final Throwable throwable) {
                     processFailure(throwable, callback);
                 }