Fix for #328.

  - Introduce async connect mode configuration option within
     AsyncHttpClientConfig. Defaults to false meaning connections
      will be made synchronously.
   - Removed Netty-specific version of async connect mode
      configuration option.
   - Updated both providers to respect new configuration
      option.

Author: rlubke

Diff for: api/src/main/java/org/asynchttpclient/AsyncHttpClientConfig.java

@@ -114,6 +114,7 @@ public class AsyncHttpClientConfig {
     protected int spdyInitialWindowSize;
     protected int spdyMaxConcurrentStreams;
     protected boolean rfc6265CookieEncoding;
+    protected boolean asyncConnectMode;
 
     protected AsyncHttpClientConfig() {
     }
@@ -153,7 +154,8 @@ private AsyncHttpClientConfig(int maxTotalConnections,
                                   boolean spdyEnabled,
                                   int spdyInitialWindowSize,
                                   int spdyMaxConcurrentStreams,
-                                  boolean rfc6265CookieEncoding) {
+                                  boolean rfc6265CookieEncoding,
+                                  boolean asyncConnectMode) {
 
         this.maxTotalConnections = maxTotalConnections;
         this.maxConnectionPerHost = maxConnectionPerHost;
@@ -197,6 +199,7 @@ private AsyncHttpClientConfig(int maxTotalConnections,
         this.spdyInitialWindowSize = spdyInitialWindowSize;
         this.spdyMaxConcurrentStreams = spdyMaxConcurrentStreams;
         this.rfc6265CookieEncoding = rfc6265CookieEncoding;
+        this.asyncConnectMode = asyncConnectMode;
     }
 
     /**
@@ -567,6 +570,16 @@ public boolean isRfc6265CookieEncoding() {
         return rfc6265CookieEncoding;
     }
 
+    /**
+     * @return <code>true</code> if the underlying provider should make new connections asynchronously or not.  By default
+     *  new connections are made synchronously.
+     *
+     * @since 2.0.0
+     */
+    public boolean isAsyncConnectMode() {
+        return asyncConnectMode;
+    }
+
     /**
      * Builder for an {@link AsyncHttpClient}
      */
@@ -609,6 +622,7 @@ public static class Builder {
         private int spdyInitialWindowSize = 10 * 1024 * 1024;
         private int spdyMaxConcurrentStreams = 100;
         private boolean rfc6265CookieEncoding;
+        private boolean asyncConnectMode;
 
         public Builder() {
         }
@@ -1121,6 +1135,21 @@ public Builder setRfc6265CookieEncoding(boolean rfc6265CookieEncoding) {
             return this;
         }
 
+        /**
+         * Configures how the underlying providers make new connections.  By default,
+         * connections will be made synchronously.
+         *
+         * @param asyncConnectMode pass <code>true</code> to enable async connect mode.
+         *
+         * @return this
+         *
+         * @since 2.0.0
+         */
+        public Builder setAsyncConnectMode(boolean asyncConnectMode) {
+            this.asyncConnectMode = asyncConnectMode;
+            return this;
+        }
+
         /**
          * Create a config builder with values taken from the given prototype configuration.
          *
@@ -1166,6 +1195,7 @@ public Builder(AsyncHttpClientConfig prototype) {
             strict302Handling = prototype.isStrict302Handling();
             useRelativeURIsWithSSLProxies = prototype.isUseRelativeURIsWithSSLProxies();
             rfc6265CookieEncoding = prototype.isRfc6265CookieEncoding();
+            asyncConnectMode = prototype.isAsyncConnectMode();
         }
 
         /**
@@ -1184,16 +1214,18 @@ public Thread newThread(Runnable r) {
                     }
                 });
             }
-        	
-        	if (applicationThreadPool == null) {
-        		applicationThreadPool = Executors.newCachedThreadPool(new ThreadFactory() {
-        	            public Thread newThread(Runnable r) {
-        	                Thread t = new Thread(r, "AsyncHttpClient-Callback");
-        	                t.setDaemon(true);
-        	                return t;
-        	            }
-        	        });
-        	}
+
+            if (applicationThreadPool == null) {
+                applicationThreadPool =
+                        Executors.newCachedThreadPool(new ThreadFactory() {
+                            public Thread newThread(Runnable r) {
+                                Thread t = new Thread(r,
+                                                      "AsyncHttpClient-Callback");
+                                t.setDaemon(true);
+                                return t;
+                            }
+                        });
+            }
 
             if (applicationThreadPool.isShutdown()) {
                 throw new IllegalStateException("ExecutorServices closed");
@@ -1239,7 +1271,8 @@ public Thread newThread(Runnable r) {
                     spdyEnabled,
                     spdyInitialWindowSize,
                     spdyMaxConcurrentStreams,
-                    rfc6265CookieEncoding);
+                    rfc6265CookieEncoding,
+                    asyncConnectMode);
         }
     }
 }

Diff for: providers/grizzly/src/main/java/org/asynchttpclient/providers/grizzly/ConnectionManager.java

@@ -61,6 +61,7 @@ public class ConnectionManager {
     private final ProxyAwareConnectorHandler connectionHandler;
     private final ConnectionMonitor connectionMonitor;
     private final GrizzlyAsyncHttpProvider provider;
+    private final boolean connectAsync;
 
 
     // ------------------------------------------------------------ Constructors
@@ -87,25 +88,34 @@ public class ConnectionManager {
         pool = connectionPool;
         this.connectionHandler = connectionHandler;
         connectionMonitor = new ConnectionMonitor(config.getMaxTotalConnections());
-
+        connectAsync = provider.getClientConfig().isAsyncConnectMode();
 
     }
 
 
     // ---------------------------------------------------------- Public Methods
 
 
-    public void doAsyncTrackedConnection(final Request request,
-                                         final GrizzlyResponseFuture requestFuture,
-                                         final CompletionHandler<Connection> connectHandler)
+    public void doTrackedConnection(final Request request,
+                                    final GrizzlyResponseFuture requestFuture,
+                                    final CompletionHandler<Connection> connectHandler)
     throws IOException {
         Connection c =
                 pool.poll(getPoolKey(request, requestFuture.getProxyServer()));
         if (c == null) {
             if (!connectionMonitor.acquire()) {
                 throw new IOException("Max connections exceeded");
             }
-            doAsyncConnect(request, requestFuture, connectHandler);
+            if (connectAsync) {
+                doAsyncConnect(request, requestFuture, connectHandler);
+            } else {
+                try {
+                    c = obtainConnection0(request, requestFuture);
+                    connectHandler.completed(c);
+                } catch (Exception e) {
+                    connectHandler.failed(e);
+                }
+            }
         } else {
             provider.touchConnection(c, request);
             connectHandler.completed(c);

Diff for: providers/grizzly/src/main/java/org/asynchttpclient/providers/grizzly/GrizzlyAsyncHttpProvider.java

@@ -165,7 +165,7 @@ public void updated(final Connection c) {
             }
         };
 
-        connectionManager.doAsyncTrackedConnection(request, future, connectHandler);
+        connectionManager.doTrackedConnection(request, future, connectHandler);
 
         return future;
     }

Diff for: providers/netty/src/main/java/org/asynchttpclient/providers/netty/NettyAsyncHttpProvider.java

@@ -260,7 +260,7 @@ void configureNetty() {
         DefaultChannelFuture.setUseDeadLockChecker(false);
 
         if (asyncHttpProviderConfig != null) {
-            executeConnectAsync = asyncHttpProviderConfig.isAsyncConnect();
+            executeConnectAsync = config.isAsyncConnectMode();
             if (!executeConnectAsync) {
                 DefaultChannelFuture.setUseDeadLockChecker(true);
             }

Diff for: providers/netty/src/main/java/org/asynchttpclient/providers/netty/NettyAsyncHttpProviderConfig.java

@@ -49,11 +49,6 @@ public class NettyAsyncHttpProviderConfig implements AsyncHttpProviderConfig<Str
      */
     private ExecutorService bossExecutorService;
 
-    /**
-     * Execute the connect operation asynchronously.
-     */
-    private boolean asyncConnect;
-
     /**
      * HttpClientCodec's maxInitialLineLength
      */
@@ -163,14 +158,6 @@ public void setBossExecutorService(ExecutorService bossExecutorService) {
         this.bossExecutorService = bossExecutorService;
     }
 
-    public boolean isAsyncConnect() {
-        return asyncConnect;
-    }
-
-    public void setAsyncConnect(boolean asyncConnect) {
-        this.asyncConnect = asyncConnect;
-    }
-
     public int getMaxInitialLineLength() {
         return maxInitialLineLength;
     }