Use Netty sync() for handling sync connect

Author: Stephane Landelle

providers/netty4/src/main/java/org/asynchttpclient/providers/netty4/Channels.java

@@ -169,11 +169,11 @@ public Channels(final AsyncHttpClientConfig config, NettyAsyncHttpProviderConfig
             }
         }
 
-        // FIXME clean up
-        plainBootstrap.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, config.getConnectionTimeoutInMs());
-        webSocketBootstrap.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, config.getConnectionTimeoutInMs());
-        secureBootstrap.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, config.getConnectionTimeoutInMs());
-        secureWebSocketBootstrap.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, config.getConnectionTimeoutInMs());
+        int timeOut = config.getConnectionTimeoutInMs() > 0 ? config.getConnectionTimeoutInMs() : Integer.MAX_VALUE;
+        plainBootstrap.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, timeOut);
+        webSocketBootstrap.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, timeOut);
+        secureBootstrap.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, timeOut);
+        secureWebSocketBootstrap.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, timeOut);
     }
 
     private SSLEngine createSSLEngine() throws IOException, GeneralSecurityException {

providers/netty4/src/main/java/org/asynchttpclient/providers/netty4/NettyConnectListener.java

@@ -27,8 +27,6 @@
 import java.net.URI;
 import java.nio.channels.ClosedChannelException;
 
-import javax.net.ssl.HostnameVerifier;
-
 import org.asynchttpclient.AsyncHandler;
 import org.asynchttpclient.AsyncHttpClientConfig;
 import org.asynchttpclient.ProxyServer;
@@ -60,24 +58,20 @@ public NettyResponseFuture<T> future() {
         return future;
     }
 
-    private void onFutureSuccess(final Channel channel) throws Exception {
+    public void onFutureSuccess(final Channel channel) throws ConnectException {
         Channels.setDefaultAttribute(channel, future);
         SslHandler sslHandler = Channels.getSslHandler(channel);
 
-        if (sslHandler != null) {
-            // FIXME done on connect or on every request?
-            HostnameVerifier v = config.getHostnameVerifier();
-            if (!v.verify(future.getURI().getHost(), sslHandler.engine().getSession())) {
-                ConnectException exception = new ConnectException("HostnameVerifier exception.");
-                future.abort(exception);
-                throw exception;
-            }
+        if (sslHandler != null && !config.getHostnameVerifier().verify(future.getURI().getHost(), sslHandler.engine().getSession())) {
+            ConnectException exception = new ConnectException("HostnameVerifier exception");
+            future.abort(exception);
+            throw exception;
         }
 
         requestSender.writeRequest(channel, config, future);
     }
 
-    private void onFutureFailure(Channel channel, Throwable cause) throws Exception {
+    public void onFutureFailure(Channel channel, Throwable cause) {
 
         logger.debug("Trying to recover a dead cached channel {} with a retry value of {} ", channel, future.canRetry());
         if (future.canRetry() && cause != null

providers/netty4/src/main/java/org/asynchttpclient/providers/netty4/NettyRequestSender.java

@@ -20,7 +20,6 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.RandomAccessFile;
-import java.net.ConnectException;
 import java.net.InetSocketAddress;
 import java.net.URI;
 import java.util.Map;
@@ -179,28 +178,29 @@ private ChannelFuture connect(Request request, URI uri, ProxyServer proxy, Boots
     }
 
     private void performSyncConnect(ChannelFuture channelFuture, URI uri, boolean acquiredConnection, NettyConnectListener<?> cl, AsyncHandler<?> asyncHandler) throws IOException {
-        // FIXME why not use bootstrap.childOption(ChannelOption.CONNECT_TIMEOUT_MILLIS, 10000)?
-        int timeOut = config.getConnectionTimeoutInMs() > 0 ? config.getConnectionTimeoutInMs() : Integer.MAX_VALUE;
-        if (!channelFuture.awaitUninterruptibly(timeOut, TimeUnit.MILLISECONDS)) {
-            if (acquiredConnection) {
-                channels.releaseFreeConnections();
-            }
-            channelFuture.cancel(false);
-            channels.abort(cl.future(), new ConnectException(String.format("Connect operation to %s timed out %s", uri, timeOut)));
-        }
 
         try {
-            cl.operationComplete(channelFuture);
-        } catch (Exception e) {
-            if (acquiredConnection) {
+            channelFuture.syncUninterruptibly();
+            cl.onFutureSuccess(channelFuture.channel());
+
+        } catch (Throwable t) {
+            if (t.getCause() != null)
+                t = t.getCause();
+
+            IOException ioe = null;
+            if (t instanceof IOException)
+                ioe = IOException.class.cast(t);
+            else
+                ioe = new IOException(t.getMessage(), t);
+
+            if (acquiredConnection)
                 channels.releaseFreeConnections();
-            }
-            IOException ioe = new IOException(e.getMessage());
-            ioe.initCause(e);
+
+            channels.abort(cl.future(), ioe);
             try {
                 asyncHandler.onThrowable(ioe);
-            } catch (Throwable t) {
-                LOGGER.warn("c.operationComplete()", t);
+            } catch (Throwable t2) {
+                LOGGER.warn("asyncHandler.onThrowable()", t2);
             }
             throw ioe;
         }