Consistent handler method names, close AsyncHttpClient#929

Author: slandelle

api/src/main/java/org/asynchttpclient/AsyncCompletionHandler.java

@@ -86,7 +86,7 @@ public void onThrowable(Throwable t) {
      *
      * @return a {@link org.asynchttpclient.AsyncHandler.State} telling to CONTINUE or ABORT the current processing.
      */
-    public State onHeaderWriteCompleted() {
+    public State onHeadersWritten() {
         return State.CONTINUE;
     }
 
@@ -96,7 +96,7 @@ public State onHeaderWriteCompleted() {
      *
      * @return a {@link org.asynchttpclient.AsyncHandler.State} telling to CONTINUE or ABORT the current processing.
      */
-    public State onContentWriteCompleted() {
+    public State onContentWriten() {
         return State.CONTINUE;
     }
 

api/src/main/java/org/asynchttpclient/handler/AsyncHandlerExtensions.java

@@ -21,29 +21,23 @@
  * For now, those methods are in a dedicated interface in order not to break the
  * existing API, but could be merged into one of the existing ones in AHC 2.
  * 
- * More additional hooks might come, such as:
- * <ul>
- * <li>onConnectionClosed()</li>
- * <li>onBytesSent(long numberOfBytes)</li>
- * <li>onBytesReceived(long numberOfBytes)</li>
- * </ul>
  */
 public interface AsyncHandlerExtensions {
 
     /**
      * Notify the callback when trying to open a new connection.
      */
-    void onOpenConnection();
+    void onConnectionOpen();
 
     /**
      * Notify the callback when a new connection was successfully opened.
      */
-    void onConnectionOpen();
+    void onConnectionOpened();
 
     /**
      * Notify the callback when trying to fetch a connection from the pool.
      */
-    void onPoolConnection();
+    void onConnectionPool();
 
     /**
      * Notify the callback when a new connection was successfully fetched from
@@ -58,7 +52,7 @@ public interface AsyncHandlerExtensions {
      * 
      * @param request the real request object as passed to the provider
      */
-    void onSendRequest(Object request);
+    void onRequestSend(Object request);
 
     /**
      * Notify the callback every time a request is being retried.

api/src/main/java/org/asynchttpclient/handler/ProgressAsyncHandler.java

@@ -27,15 +27,15 @@ public interface ProgressAsyncHandler<T> extends AsyncHandler<T> {
      *
      * @return a {@link AsyncHandler.State} telling to CONTINUE or ABORT the current processing.
      */
-    State onHeaderWriteCompleted();
+    State onHeadersWritten();
 
     /**
      * Invoked when the content (a {@link java.io.File}, {@link String} or {@link java.io.FileInputStream} has been fully
      * written on the I/O socket.
      *
      * @return a {@link AsyncHandler.State} telling to CONTINUE or ABORT the current processing.
      */
-    State onContentWriteCompleted();
+    State onContentWriten();
 
     /**
      * Invoked when the I/O operation associated with the {@link Request} body wasn't fully written in a single I/O write

api/src/main/java/org/asynchttpclient/handler/TransferCompletionHandler.java

@@ -158,7 +158,7 @@ public Response onCompleted(Response response) throws Exception {
     }
 
     @Override
-    public State onHeaderWriteCompleted() {
+    public State onHeadersWritten() {
         if (headers != null) {
             fireOnHeadersSent(headers);
         }

api/src/main/java/org/asynchttpclient/simple/SimpleAsyncHttpClient.java

@@ -707,12 +707,12 @@ public ResumableBodyConsumerAsyncHandler(long byteTransferred, ProgressAsyncHand
             this.delegate = delegate;
         }
 
-        public AsyncHandler.State onHeaderWriteCompleted() {
-            return delegate.onHeaderWriteCompleted();
+        public AsyncHandler.State onHeadersWritten() {
+            return delegate.onHeadersWritten();
         }
 
-        public AsyncHandler.State onContentWriteCompleted() {
-            return delegate.onContentWriteCompleted();
+        public AsyncHandler.State onContentWriten() {
+            return delegate.onContentWriten();
         }
 
         public AsyncHandler.State onContentWriteProgress(long amount, long current, long total) {

api/src/test/java/org/asynchttpclient/AsyncProvidersBasicTest.java

@@ -55,6 +55,7 @@
 import org.asynchttpclient.proxy.ProxyServer;
 import org.asynchttpclient.request.body.multipart.Part;
 import org.asynchttpclient.request.body.multipart.StringPart;
+import org.asynchttpclient.test.EventCollectingHandler;
 import org.testng.annotations.Test;
 
 public abstract class AsyncProvidersBasicTest extends AbstractBasicTest {
@@ -1402,4 +1403,28 @@ public void mirrorByteTest() throws Exception {
             assertEquals(new String(response.getResponseBodyAsBytes(), UTF_8), "MIRROR");
         }
     }
+
+    @Test(groups = { "standalone", "default_provider", "async" })
+    public void testNewConnectionEventsFired() throws Exception {
+        Request request = new RequestBuilder("GET").setUrl("http://127.0.0.1:" + port1 + "/Test").build();
+
+        try (AsyncHttpClient client = getAsyncHttpClient(null)) {
+            EventCollectingHandler handler = new EventCollectingHandler();
+            client.executeRequest(request, handler).get(3, TimeUnit.SECONDS);
+            handler.waitForCompletion(3, TimeUnit.SECONDS);
+
+            List<String> expectedEvents = Arrays.asList(
+                    "ConnectionPool",
+                    "ConnectionOpen",
+                    "DnsResolved",
+                    "ConnectionOpened",
+                    "RequestSend",
+                    "HeadersWriten",
+                    "StatusReceived",
+                    "HeadersReceived",
+                    "Completed");
+
+            assertEquals(handler.firedEvents, expectedEvents, "Got " + Arrays.toString(handler.firedEvents.toArray()));
+        }
+    }
 }

api/src/test/java/org/asynchttpclient/BasicHttpsTest.java

@@ -22,12 +22,16 @@
 
 import org.asynchttpclient.AsyncHttpClient;
 import org.asynchttpclient.AsyncHttpClientConfig.Builder;
+import org.asynchttpclient.test.EventCollectingHandler;
 import org.testng.annotations.Test;
 
 import javax.servlet.http.HttpServletResponse;
 
+import java.util.Arrays;
+import java.util.List;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 public abstract class BasicHttpsTest extends AbstractBasicHttpsTest {
@@ -113,4 +117,27 @@ public void failInstantlyIfNotAllowedSelfSignedCertificate() throws Throwable {
             }
         }
     }
+
+    @Test(groups = { "standalone", "default_provider" })
+    public void testNormalEventsFired() throws InterruptedException, TimeoutException, ExecutionException {
+        try (AsyncHttpClient client = getAsyncHttpClient(new AsyncHttpClientConfig.Builder().setSSLContext(createSSLContext(new AtomicBoolean(true))).build())) {
+            EventCollectingHandler handler = new EventCollectingHandler();
+            client.preparePost(getTargetUrl()).setBody("whatever").execute(handler).get(3, TimeUnit.SECONDS);
+            handler.waitForCompletion(3, TimeUnit.SECONDS);
+
+            List<String> expectedEvents = Arrays.asList(
+                    "ConnectionPool",
+                    "ConnectionOpen",
+                    "DnsResolved",
+                    "SslHandshakeCompleted",
+                    "ConnectionOpened",
+                    "RequestSend",
+                    "HeadersWritten",
+                    "StatusReceived",
+                    "HeadersReceived",
+                    "Completed");
+
+            assertEquals(handler.firedEvents, expectedEvents, "Got " + Arrays.toString(handler.firedEvents.toArray()));
+        }
+    }
 }

api/src/test/java/org/asynchttpclient/channel/pool/ConnectionPoolTest.java

@@ -22,6 +22,7 @@
 
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
@@ -39,6 +40,7 @@
 import org.asynchttpclient.Request;
 import org.asynchttpclient.RequestBuilder;
 import org.asynchttpclient.Response;
+import org.asynchttpclient.test.EventCollectingHandler;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.testng.annotations.Test;
@@ -269,4 +271,30 @@ public void nonPoolableConnectionReleaseSemaphoresTest() throws Throwable {
             client.executeRequest(request).get();
         }
     }
+    
+    @Test(groups = { "standalone", "default_provider" })
+    public void testPooledEventsFired() throws Exception {
+        Request request = new RequestBuilder("GET").setUrl("http://127.0.0.1:" + port1 + "/Test").build();
+
+        try (AsyncHttpClient client = getAsyncHttpClient(null)) {
+            EventCollectingHandler firstHandler = new EventCollectingHandler();
+            client.executeRequest(request, firstHandler).get(3, TimeUnit.SECONDS);
+            firstHandler.waitForCompletion(3, TimeUnit.SECONDS);
+
+            EventCollectingHandler secondHandler = new EventCollectingHandler();
+            client.executeRequest(request, secondHandler).get(3, TimeUnit.SECONDS);
+            secondHandler.waitForCompletion(3, TimeUnit.SECONDS);
+
+            List<String> expectedEvents = Arrays.asList(
+                    "ConnectionPool",
+                    "ConnectionPooled",
+                    "RequestSend",
+                    "HeadersWritten",
+                    "StatusReceived",
+                    "HeadersReceived",
+                    "Completed");
+
+            assertEquals(secondHandler.firedEvents, expectedEvents, "Got " + Arrays.toString(secondHandler.firedEvents.toArray()));
+        }
+    }
 }

api/src/test/java/org/asynchttpclient/request/body/ZeroCopyFileTest.java

@@ -76,12 +76,12 @@ public void zeroCopyPostTest() throws IOException, ExecutionException, TimeoutEx
 
             Response resp = client.preparePost("http://127.0.0.1:" + port1 + "/").setBody(SIMPLE_TEXT_FILE).execute(new AsyncCompletionHandler<Response>() {
 
-                public State onHeaderWriteCompleted() {
+                public State onHeadersWritten() {
                     headerSent.set(true);
                     return State.CONTINUE;
                 }
 
-                public State onContentWriteCompleted() {
+                public State onContentWriten() {
                     operationCompleted.set(true);
                     return State.CONTINUE;
                 }

api/src/test/java/org/asynchttpclient/test/EventCollectingHandler.java

@@ -58,30 +58,30 @@ public State onHeadersReceived(HttpResponseHeaders headers) throws Exception {
     }
 
     @Override
-    public State onHeaderWriteCompleted() {
-        firedEvents.add("HeaderWriteCompleted");
-        return super.onHeaderWriteCompleted();
+    public State onHeadersWritten() {
+        firedEvents.add("HeadersWritten");
+        return super.onHeadersWritten();
     }
 
     @Override
-    public State onContentWriteCompleted() {
-        firedEvents.add("ContentWriteCompleted");
-        return super.onContentWriteCompleted();
+    public State onContentWriten() {
+        firedEvents.add("ContentWritten");
+        return super.onContentWriten();
     }
 
     @Override
-    public void onOpenConnection() {
-        firedEvents.add("OpenConnection");
+    public void onConnectionOpen() {
+        firedEvents.add("ConnectionOpen");
     }
 
     @Override
-    public void onConnectionOpen() {
-        firedEvents.add("ConnectionOpen");
+    public void onConnectionOpened() {
+        firedEvents.add("ConnectionOpened");
     }
 
     @Override
-    public void onPoolConnection() {
-        firedEvents.add("PoolConnection");
+    public void onConnectionPool() {
+        firedEvents.add("ConnectionPool");
     }
 
     @Override
@@ -90,8 +90,8 @@ public void onConnectionPooled() {
     }
 
     @Override
-    public void onSendRequest(Object request) {
-        firedEvents.add("SendRequest");
+    public void onRequestSend(Object request) {
+        firedEvents.add("RequestSend");
     }
 
     @Override

providers/netty3/src/main/java/org/asynchttpclient/netty/channel/NettyConnectListener.java

@@ -78,7 +78,7 @@ private void writeRequest(Channel channel) {
         future.attachChannel(channel, false);
 
         if (future.getAsyncHandler() instanceof AsyncHandlerExtensions)
-            AsyncHandlerExtensions.class.cast(future.getAsyncHandler()).onConnectionOpen();
+            AsyncHandlerExtensions.class.cast(future.getAsyncHandler()).onConnectionOpened();
 
         channelManager.registerOpenChannel(channel, partitionKey);
         requestSender.writeRequest(future, channel);

providers/netty3/src/main/java/org/asynchttpclient/netty/request/NettyRequestSender.java

@@ -274,7 +274,7 @@ private <T> ListenableFuture<T> sendRequestWithNewChannel(//
             }
 
             if (asyncHandler instanceof AsyncHandlerExtensions)
-                AsyncHandlerExtensions.class.cast(asyncHandler).onOpenConnection();
+                AsyncHandlerExtensions.class.cast(asyncHandler).onConnectionOpen();
 
             ChannelFuture channelFuture = connect(request, uri, proxy, useProxy, bootstrap, asyncHandler);
             channelFuture.addListener(new NettyConnectListener<T>(future, this, channelManager, channelPreempted, partitionKey));
@@ -325,7 +325,7 @@ public <T> void writeRequest(NettyResponseFuture<T> future, Channel channel) {
 
             if (!future.isHeadersAlreadyWrittenOnContinue()) {
                     if (future.getAsyncHandler() instanceof AsyncHandlerExtensions)
-                        AsyncHandlerExtensions.class.cast(future.getAsyncHandler()).onSendRequest(nettyRequest);
+                        AsyncHandlerExtensions.class.cast(future.getAsyncHandler()).onRequestSend(nettyRequest);
                     channel.write(httpRequest).addListener(new ProgressListener(config, future.getAsyncHandler(), future, true));
             }
 
@@ -506,7 +506,7 @@ else if (!request.getMethod().equals(HttpMethod.GET.getName()))
     public Channel pollAndVerifyCachedChannel(Uri uri, ProxyServer proxy, ConnectionPoolPartitioning connectionPoolPartitioning, AsyncHandler<?> asyncHandler) {
 
         if (asyncHandler instanceof AsyncHandlerExtensions)
-            AsyncHandlerExtensions.class.cast(asyncHandler).onPoolConnection();
+            AsyncHandlerExtensions.class.cast(asyncHandler).onConnectionPool();
 
         final Channel channel = channelManager.poll(uri, proxy, connectionPoolPartitioning);
 

providers/netty3/src/main/java/org/asynchttpclient/netty/request/ProgressListener.java

@@ -77,9 +77,9 @@ public void operationComplete(ChannelFuture cf) {
 
             if (startPublishing && asyncHandler instanceof ProgressAsyncHandler) {
                 if (notifyHeaders) {
-                    ProgressAsyncHandler.class.cast(asyncHandler).onHeaderWriteCompleted();
+                    ProgressAsyncHandler.class.cast(asyncHandler).onHeadersWritten();
                 } else {
-                    ProgressAsyncHandler.class.cast(asyncHandler).onContentWriteCompleted();
+                    ProgressAsyncHandler.class.cast(asyncHandler).onContentWriten();
                 }
             }
         }