Merge remote-tracking branch 'upstream/master' into throttling

Conflicts:
	src/main/java/org/littleshoot/proxy/impl/ClientToProxyConnection.java
	src/main/java/org/littleshoot/proxy/impl/ProxyToServerConnection.java

.gitignore

@@ -14,3 +14,5 @@ jmeter.log
 lib/
 LittleProxy.pro
 /bin
+*.jks
+performance/site/

README.md

@@ -40,25 +40,25 @@ HttpProxyServer server =
             public HttpFilters filterRequest(HttpRequest originalRequest, ChannelHandlerContext ctx) {
                return new HttpFiltersAdapter(originalRequest) {
                   @Override
-                  public HttpResponse requestPre(HttpObject httpObject) {
+                  public HttpResponse clientToProxyRequest(HttpObject httpObject) {
                       // TODO: implement your filtering here
                       return null;
                   }
 
                   @Override
-                  public HttpResponse requestPost(HttpObject httpObject) {
+                  public HttpResponse proxyToServerRequest(HttpObject httpObject) {
                       // TODO: implement your filtering here
                       return null;
                   }
 
                   @Override
-                  public HttpObject responsePre(HttpObject httpObject) {
+                  public HttpObject serverToProxyResponse(HttpObject httpObject) {
                       // TODO: implement your filtering here
                       return httpObject;
                   }
 
                   @Override
-                  public HttpObject responsePost(HttpObject httpObject) {
+                  public HttpObject proxyToClientResponse(HttpObject httpObject) {
                       // TODO: implement your filtering here
                       return httpObject;
                   }   

pom.xml

@@ -3,7 +3,7 @@
   <groupId>org.littleshoot</groupId>
   <artifactId>littleproxy</artifactId>
   <packaging>jar</packaging>
-  <version>1.0.0-beta9-SNAPSHOT</version>
+  <version>1.1.0-beta1-SNAPSHOT</version>
   <name>LittleProxy</name>
   <description>
     LittleProxy is a high performance HTTP proxy written in Java and using the Netty networking framework. 

src/main/java/org/littleshoot/proxy/ActivityTracker.java

@@ -3,9 +3,8 @@
 import io.netty.handler.codec.http.HttpRequest;
 import io.netty.handler.codec.http.HttpResponse;
 
-import java.net.InetSocketAddress;
-
 import javax.net.ssl.SSLSession;
+import java.net.InetSocketAddress;
 
 /**
  * <p>

src/main/java/org/littleshoot/proxy/HttpFilters.java

@@ -1,32 +1,31 @@
 package org.littleshoot.proxy;
 
-import io.netty.handler.codec.http.HttpContent;
-import io.netty.handler.codec.http.HttpObject;
-import io.netty.handler.codec.http.HttpRequest;
-import io.netty.handler.codec.http.HttpResponse;
-import io.netty.handler.codec.http.LastHttpContent;
-
+import io.netty.handler.codec.http.*;
 import org.littleshoot.proxy.impl.ProxyUtils;
 
+import java.net.InetSocketAddress;
+
 /**
  * <p>
  * Interface for objects that filter {@link HttpObject}s, including both
- * requests and responses.
+ * requests and responses, and informs of different steps in request/response.
  * </p>
  * 
  * <p>
  * Multiple methods are defined, corresponding to different steps in the request
- * processing lifecycle. Each of these methods is given the current object
- * (request, response or chunk) and is allowed to modify it in place.
+ * processing lifecycle. Some of these methods is given the current object
+ * (request, response or chunk) and is allowed to modify it in place. Others
+ * provide a notification of when specific operations happen (i.e. connection in
+ * queue, DNS resolution, SSL handshaking and so forth).
  * </p>
  * 
  * <p>
  * Because HTTP transfers can be chunked, for any given request or response, the
- * filter methods may be called multiple times, once for the initial
- * {@link HttpRequest} or {@link HttpResponse}, and once for each subsequent
- * {@link HttpContent}. The last chunk will always be a {@link LastHttpContent}
- * and can be checked for being last using
- * {@link ProxyUtils#isLastChunk(HttpObject)}.
+ * filter methods that can modify request/response in place may be called
+ * multiple times, once for the initial {@link HttpRequest} or
+ * {@link HttpResponse}, and once for each subsequent {@link HttpContent}. The
+ * last chunk will always be a {@link LastHttpContent} and can be checked for
+ * being last using {@link ProxyUtils#isLastChunk(HttpObject)}.
  * </p>
  * 
  * <p>
@@ -46,43 +45,137 @@
  * objects can be stateful.
  * </p>
  * 
+ * <p>
+ * To monitor (and time measure?) the different steps the request/response goes
+ * through, many informative methods are provided. Those steps are reported in
+ * the following order:
+ * <ol>
+ * <li>clientToProxyRequest</li>
+ * <li>proxyToServerConnectionQueued</li>
+ * <li>proxyToServerResolutionStarted</li>
+ * <li>proxyToServerResolutionSucceeded</li>
+ * <li>proxyToServerRequest (can be multiple if chunked)</li>
+ * <li>proxyToServerConnectionStarted</li>
+ * <li>proxyToServerConnectionFailed (if connection couldn't be established)</li>
+ * <li>proxyToServerConnectionSSLHandshakeStarted (only if HTTPS required)</li>
+ * <li>proxyToServerConnectionSucceeded</li>
+ * <li>proxyToServerRequestSending</li>
+ * <li>proxyToServerRequestSent</li>
+ * <li>serverToProxyResponseReceiving</li>
+ * <li>serverToProxyResponse (can be multiple if chuncked)</li>
+ * <li>serverToProxyResponseReceived</li>
+ * <li>proxyToClientResponse</li>
+ * </ol>
+ * </p>
  */
 public interface HttpFilters {
     /**
      * Filters requests on their way from the client to the proxy.
      * 
      * @param httpObject
+     *            Client to Proxy HttpRequest (and HttpContent, if chunked)
      * @return if you want to interrupted processing and return a response to
      *         the client, return it here, otherwise return null to continue
      *         processing as usual
      */
-    HttpResponse requestPre(HttpObject httpObject);
+    HttpResponse clientToProxyRequest(HttpObject httpObject);
 
     /**
      * Filters requests on their way from the proxy to the server.
      * 
      * @param httpObject
+     *            Proxy to Server HttpRequest (and HttpContent, if chunked)
      * @return if you want to interrupted processing and return a response to
      *         the client, return it here, otherwise return null to continue
      *         processing as usual
      */
-    HttpResponse requestPost(HttpObject httpObject);
+    HttpResponse proxyToServerRequest(HttpObject httpObject);
+
+    /**
+     * Informs filter that proxy to server request is being sent.
+     */
+    void proxyToServerRequestSending();
+
+    /**
+     * Informs filter that proxy to server request has been sent.
+     */
+    void proxyToServerRequestSent();
 
     /**
      * Filters responses on their way from the server to the proxy.
      * 
      * @param httpObject
+     *            Server to Proxy HttpResponse (and HttpContent, if chunked)
      * @return the modified (or unmodified) HttpObject. Returning null will
      *         force a disconnect.
      */
-    HttpObject responsePre(HttpObject httpObject);
+    HttpObject serverToProxyResponse(HttpObject httpObject);
+
+    /**
+     * Informs filter that server to proxy response is being received.
+     */
+    void serverToProxyResponseReceiving();
+
+    /**
+     * Informs filter that server to proxy response has been received.
+     */
+    void serverToProxyResponseReceived();
 
     /**
      * Filters responses on their way from the proxy to the client.
      * 
      * @param httpObject
+     *            Proxy to Client HttpResponse (and HttpContent, if chunked)
      * @return the modified (or unmodified) HttpObject. Returning null will
      *         force a disconnect.
      */
-    HttpObject responsePost(HttpObject httpObject);
+    HttpObject proxyToClientResponse(HttpObject httpObject);
+
+    /**
+     * Informs filter that proxy to server connection is in queue.
+     */
+    void proxyToServerConnectionQueued();
+
+    /**
+     * Filter DNS resolution from proxy to server.
+     * 
+     * @param resolvingServerHostAndPort
+     *            Server "HOST:PORT"
+     * @return alternative address resolution. Returning null will let normal
+     *         DNS resolution continue.
+     */
+    InetSocketAddress proxyToServerResolutionStarted(
+            String resolvingServerHostAndPort);
+
+    /**
+     * Informs filter that proxy to server DNS resolution has happened.
+     * 
+     * @param serverHostAndPort
+     *            Server "HOST:PORT"
+     * @param resolvedRemoteAddress
+     *            Address it was proxyToServerResolutionSucceeded to
+     */
+    void proxyToServerResolutionSucceeded(String serverHostAndPort,
+            InetSocketAddress resolvedRemoteAddress);
+
+    /**
+     * Informs filter that proxy to server connection is initiating.
+     */
+    void proxyToServerConnectionStarted();
+
+    /**
+     * Informs filter that proxy to server ssl handshake is initiating.
+     */
+    void proxyToServerConnectionSSLHandshakeStarted();
+
+    /**
+     * Informs filter that proxy to server connection has failed.
+     */
+    void proxyToServerConnectionFailed();
+
+    /**
+     * Informs filter that proxy to server connection has succeeded.
+     */
+    void proxyToServerConnectionSucceeded();
+
 }

src/main/java/org/littleshoot/proxy/HttpFiltersAdapter.java

@@ -5,6 +5,8 @@
 import io.netty.handler.codec.http.HttpRequest;
 import io.netty.handler.codec.http.HttpResponse;
 
+import java.net.InetSocketAddress;
+
 /**
  * Convenience base class for implementations of {@link HttpFilters}.
  */
@@ -23,23 +25,69 @@ public HttpFiltersAdapter(HttpRequest originalRequest) {
     }
 
     @Override
-    public HttpResponse requestPre(HttpObject httpObject) {
+    public HttpResponse clientToProxyRequest(HttpObject httpObject) {
         return null;
     }
 
     @Override
-    public HttpResponse requestPost(HttpObject httpObject) {
+    public HttpResponse proxyToServerRequest(HttpObject httpObject) {
         return null;
     }
 
     @Override
-    public HttpObject responsePre(HttpObject httpObject) {
+    public void proxyToServerRequestSending() {
+    }
+
+    @Override
+    public void proxyToServerRequestSent() {
+    }
+
+    @Override
+    public HttpObject serverToProxyResponse(HttpObject httpObject) {
         return httpObject;
     }
 
     @Override
-    public HttpObject responsePost(HttpObject httpObject) {
+    public void serverToProxyResponseReceiving() {
+    }
+
+    @Override
+    public void serverToProxyResponseReceived() {
+    }
+
+    @Override
+    public HttpObject proxyToClientResponse(HttpObject httpObject) {
         return httpObject;
     }
 
+    @Override
+    public void proxyToServerConnectionQueued() {
+    }
+
+    @Override
+    public InetSocketAddress proxyToServerResolutionStarted(
+            String resolvingServerHostAndPort) {
+        return null;
+    }
+
+    @Override
+    public void proxyToServerResolutionSucceeded(String serverHostAndPort,
+            InetSocketAddress resolvedRemoteAddress) {
+    }
+
+    @Override
+    public void proxyToServerConnectionStarted() {
+    }
+
+    @Override
+    public void proxyToServerConnectionSSLHandshakeStarted() {
+    }
+
+    @Override
+    public void proxyToServerConnectionFailed() {
+    }
+
+    @Override
+    public void proxyToServerConnectionSucceeded() {
+    }
 }