Make SignatureCalculator both global and per request configurable.

Author: neotyk

src/main/java/com/ning/http/client/AsyncHttpClient.java

@@ -147,13 +147,6 @@ public class AsyncHttpClient {
     private final static Logger logger = LoggerFactory.getLogger(AsyncHttpClient.class);
     private final AtomicBoolean isClosed = new AtomicBoolean(false);
 
-    /**
-     * Default signature calculator to use for all requests constructed by this client instance.
-     * 
-     * @since 1.1
-     */
-    protected SignatureCalculator signatureCalculator;
-    
     /**
      * Create a new HTTP Asynchronous Client using the default {@link AsyncHttpClientConfig} configuration. The
      * default {@link AsyncHttpProvider} will be used ({@link com.ning.http.client.providers.netty.NettyAsyncHttpProvider}
@@ -203,18 +196,12 @@ public AsyncHttpClient(String providerClass, AsyncHttpClientConfig config) {
     }
 
     public class BoundRequestBuilder extends RequestBuilderBase<BoundRequestBuilder> {
-        /**
-         * Calculator used for calculating request signature for the request being
-         * built, if any.
-         */
-        protected SignatureCalculator signatureCalculator;
-
         /**
          * URL used as the base, not including possibly query parameters. Needed for
          * signature calculation
          */
         protected String baseURL;
-        
+
         private BoundRequestBuilder(String reqType) {
             super(BoundRequestBuilder.class, reqType);
         }
@@ -262,18 +249,6 @@ public BoundRequestBuilder addQueryParameter(String name, String value) {
 
         @Override
         public Request build() {
-            /* Let's first calculate and inject signature, before finalizing actual build
-             * (order does not matter with current implementation but may in future)
-             */
-            if (signatureCalculator != null) {
-                String url = baseURL;
-                // Should not include query parameters, ensure:
-                int i = url.indexOf('?');
-                if (i >= 0) {
-                    url = url.substring(0, i);
-                }
-                signatureCalculator.calculateAndAddSignature(baseURL, request, this);
-            }
             return super.build();
         }
 
@@ -339,8 +314,7 @@ public BoundRequestBuilder setVirtualHost(String virtualHost) {
         }
 
         public BoundRequestBuilder setSignatureCalculator(SignatureCalculator signatureCalculator) {
-            this.signatureCalculator = signatureCalculator;
-            return this;
+            return super.setSignatureCalculator(signatureCalculator);
         }
     }
 
@@ -382,9 +356,11 @@ public AsyncHttpClientConfig getConfig(){
 
     /**
      * Set default signature calculator to use for requests build by this client instance
+     * @deprecated Please use {@link AsyncHttpClientConfig#setSignatureCalculator(SignatureCalculator)} instead.
      */
+    @Deprecated
     public AsyncHttpClient setSignatureCalculator(SignatureCalculator signatureCalculator) {
-        this.signatureCalculator = signatureCalculator;
+        config.setSignatureCalculator(signatureCalculator);
         return this;
     }
 
@@ -549,10 +525,20 @@ private final static AsyncHttpProvider<?> loadDefaultProvider(String className,
     }
 
     protected BoundRequestBuilder requestBuilder(String reqType, String url) {
-        return new BoundRequestBuilder(reqType).setUrl(url).setSignatureCalculator(signatureCalculator);
+        BoundRequestBuilder builder = new BoundRequestBuilder(reqType).setUrl(url);
+        SignatureCalculator calculator = config.getSignatureCalculator();
+        if (calculator != null) {
+            builder.setSignatureCalculator(calculator);
+        }
+        return builder;
     }
 
     protected BoundRequestBuilder requestBuilder(Request prototype) {
-        return new BoundRequestBuilder(prototype).setSignatureCalculator(signatureCalculator);
+        BoundRequestBuilder builder = new BoundRequestBuilder(prototype);
+        SignatureCalculator calculator = getConfig().getSignatureCalculator();
+        if (calculator != null) {
+            builder.setSignatureCalculator(calculator);
+        }
+        return builder;
     }
 }

src/main/java/com/ning/http/client/AsyncHttpClientConfig.java

@@ -74,6 +74,8 @@ public class AsyncHttpClientConfig {
     private final int requestCompressionLevel;
     private final int maxRequestRetry;
     private final boolean allowSslConnectionPool;
+    // TODO: make signatureCalculator final once deprecated setSignatureCalculator is removed.
+    private /*final*/ SignatureCalculator signatureCalculator;
 
     private AsyncHttpClientConfig(int maxTotalConnections,
                                   int maxConnectionPerHost,
@@ -97,7 +99,8 @@ private AsyncHttpClientConfig(int maxTotalConnections,
                                   List<IOExceptionFilter> ioExceptionFilters,
                                   int requestCompressionLevel,
                                   int maxRequestRetry,
-                                  boolean allowSslConnectionCaching) {
+                                  boolean allowSslConnectionCaching,
+                                  SignatureCalculator signatureCalculator) {
 
         this.maxTotalConnections = maxTotalConnections;
         this.maxConnectionPerHost = maxConnectionPerHost;
@@ -121,6 +124,7 @@ private AsyncHttpClientConfig(int maxTotalConnections,
         this.maxRequestRetry = maxRequestRetry;
         this.reaper = reaper;
         this.allowSslConnectionPool = allowSslConnectionCaching;
+        this.signatureCalculator = signatureCalculator;
 
         if (applicationThreadPool == null) {
             this.applicationThreadPool = Executors.newCachedThreadPool();
@@ -374,6 +378,19 @@ public boolean isSslConnectionPoolEnabled() {
         return allowSslConnectionPool;
     }
 
+    /**
+     * TODO: remove once deprecated AHC.setSignatureCalculator is removed.
+     * @return
+     * @deprecated Do not use, only added for {@link AsyncHttpClient#setSignatureCalculator(SignatureCalculator)}.
+     */
+    @Deprecated
+    public SignatureCalculator getSignatureCalculator() {
+        return signatureCalculator;
+    }
+
+    public void setSignatureCalculator(SignatureCalculator signatureCalculator) {
+        this.signatureCalculator = signatureCalculator;
+    }
 
     /**
      * Builder for an {@link AsyncHttpClient}
@@ -415,6 +432,7 @@ public Thread newThread(Runnable r) {
         private final List<ResponseFilter> responseFilters = new LinkedList<ResponseFilter>();
         private final List<IOExceptionFilter> ioExceptionFilters = new LinkedList<IOExceptionFilter>();
         private boolean allowSslConnectionPool = true;
+        private SignatureCalculator signatureCalculator = null;
 
         public Builder() {
         }
@@ -762,6 +780,16 @@ public Builder setAllowSslConnectionPool(boolean allowSslConnectionPool) {
             return this;
         }
 
+        /**
+         * Sets {@link SignatureCalculator} globally.
+         * @param signatureCalculator Calculator to be used.
+         * @return Fluid interface.
+         */
+        public Builder setSignatureCalculator(SignatureCalculator signatureCalculator) {
+            this.signatureCalculator = signatureCalculator;
+            return this;
+        }
+
         /**
          * Create a config builder with values taken from the given prototype configuration.
          * 
@@ -790,6 +818,8 @@ public Builder( AsyncHttpClientConfig prototype )
 
             requestFilters.addAll( prototype.getRequestFilters() );
             responseFilters.addAll( prototype.getResponseFilters() );
+
+            signatureCalculator = prototype.getSignatureCalculator();
         }
 
         /**
@@ -821,7 +851,8 @@ public AsyncHttpClientConfig build() {
                     ioExceptionFilters,
                     requestCompressionLevel,
                     maxRequestRetry,
-                    allowSslConnectionPool);
+                    allowSslConnectionPool,
+                    signatureCalculator);
         }
     }
 }

src/main/java/com/ning/http/client/Request.java

@@ -177,5 +177,9 @@ public static interface EntityWriter {
      */
     public long getRangeOffset();
 
-
+    /**
+     * Gets {@link SignatureCalculator} for request.
+     * @return Calculator for request.
+     */
+    SignatureCalculator getSignatureCalculator();
 }

src/main/java/com/ning/http/client/RequestBuilderBase.java

@@ -63,6 +63,7 @@ private static final class RequestImpl implements Request {
         private boolean followRedirects;
         private PerRequestConfig perRequestConfig;
         private long rangeOffset = 0;
+        public SignatureCalculator signatureCalculator;
 
         public RequestImpl() {
         }
@@ -90,6 +91,7 @@ public RequestImpl(Request prototype) {
                 this.followRedirects = prototype.isRedirectEnabled();
                 this.perRequestConfig = prototype.getPerRequestConfig();
                 this.rangeOffset = prototype.getRangeOffset();
+                this.signatureCalculator = prototype.getSignatureCalculator();
             }
         }
 
@@ -250,6 +252,10 @@ public long getRangeOffset() {
             return rangeOffset;
         }
 
+        public SignatureCalculator getSignatureCalculator() {
+            return signatureCalculator;
+        }
+
         @Override
         public String toString() {
             StringBuilder sb = new StringBuilder(url);
@@ -276,11 +282,24 @@ protected RequestBuilderBase(Class<T> derived, String method) {
         request.method = method;
     }
 
+    protected RequestBuilderBase(Class<T> derived, String method, SignatureCalculator signatureCalculator) {
+        this.derived = derived;
+        request = new RequestImpl();
+        request.method = method;
+        request.signatureCalculator = signatureCalculator;
+    }
+
     protected RequestBuilderBase(Class<T> derived, Request prototype) {
         this.derived = derived;
         request = new RequestImpl(prototype);
     }
-    
+
+    protected RequestBuilderBase(Class<T> derived, Request prototype, SignatureCalculator signatureCalculator) {
+        this.derived = derived;
+        request = new RequestImpl(prototype);
+        request.signatureCalculator = signatureCalculator;
+    }
+
     public T setUrl(String url) {
         request.url = buildUrl(url);
         return derived.cast(this);
@@ -503,8 +522,22 @@ public T setMethod(String method) {
         return derived.cast(this);
     }
 
+    public T setSignatureCalculator(SignatureCalculator signatureCalculator) {
+        request.signatureCalculator = signatureCalculator;
+        return derived.cast(this);
+    }
 
     public Request build() {
+        SignatureCalculator calculator = request.signatureCalculator;
+        if (calculator != null) {
+            String url = request.url;
+            calculator.calculateAndAddSignature(
+                // TODO: validate, previous logic here always used baseURL, but also performed calculations for query params less URL.
+                url.contains("?") ? url.substring(0, url.indexOf('?')) : url,
+                request,
+                this
+            );
+        }
         if ((request.length < 0) && (request.streamData == null) &&
                 (("POST".equals(request.method)) || ("PUT".equals(request.method)))) {
             // can't concatenate content-length