Ensured relative URIs are used to connect to proxied WebSockets

This needed to be done both for the Grizzly and the Netty provider.

Since this is essentially the same configuration parameter as the
useRelativeURIsWithSSLProxies, I reused that parameter, but I renamed it
to useRelativeURIsWithConnectProxies to reflect its true meaning since
it's no longer used just for SSL, and I deprecated the old parameter.

Author: jroper

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

@@ -83,7 +83,7 @@ public class AsyncHttpClientConfig {
     protected HostnameVerifier hostnameVerifier;
     protected int ioThreadMultiplier;
     protected boolean strict302Handling;
-    protected boolean useRelativeURIsWithSSLProxies;
+    protected boolean useRelativeURIsWithConnectProxies;
     protected int maxConnectionLifeTimeInMs;
     protected TimeConverter timeConverter;
 
@@ -120,7 +120,7 @@ private AsyncHttpClientConfig(int maxTotalConnections,
                                   HostnameVerifier hostnameVerifier,
                                   int ioThreadMultiplier,
                                   boolean strict302Handling,
-                                  boolean useRelativeURIsWithSSLProxies,
+                                  boolean useRelativeURIsWithConnectProxies,
                                   TimeConverter timeConverter) {
 
         this.maxTotalConnections = maxTotalConnections;
@@ -151,7 +151,7 @@ private AsyncHttpClientConfig(int maxTotalConnections,
         this.hostnameVerifier = hostnameVerifier;
         this.ioThreadMultiplier = ioThreadMultiplier;
         this.strict302Handling = strict302Handling;
-        this.useRelativeURIsWithSSLProxies = useRelativeURIsWithSSLProxies;
+        this.useRelativeURIsWithConnectProxies = useRelativeURIsWithConnectProxies;
 
         if (applicationThreadPool == null) {
             this.applicationThreadPool = Executors.newCachedThreadPool();
@@ -494,15 +494,27 @@ public boolean isStrict302Handling() {
     }
 
     /**
-     * @return<code>true</code> if AHC should use relative URIs instead of absolute ones when talking with a SSL proxy,
-     *  otherwise <code>false</code>.
+     * @return<code>true</code> if AHC should use relative URIs instead of absolute ones when talking with a SSL proxy
+     * or WebSocket proxy, otherwise <code>false</code>.
      *  
      *  @since 1.7.12
+     *  @deprecated Use isUseRelativeURIsWithConnectProxies instead.
      */
+    @Deprecated
     public boolean isUseRelativeURIsWithSSLProxies() {
-        return useRelativeURIsWithSSLProxies;
+        return useRelativeURIsWithConnectProxies;
+    }
+
+    /**
+     * @return<code>true</code> if AHC should use relative URIs instead of absolute ones when talking with a proxy
+     * using the CONNECT method, for example when using SSL or WebSockets.
+     *
+     *  @since 1.8.13
+     */
+    public boolean isUseRelativeURIsWithConnectProxies() {
+        return useRelativeURIsWithConnectProxies;
     }
-    
+
     /**
      * Return the maximum time in millisecond an {@link com.ning.http.client.AsyncHttpClient} will keep connection in the pool, or -1 to keep connection while possible.
      *
@@ -538,7 +550,7 @@ public static class Builder {
         private boolean useProxyProperties = defaultUseProxyProperties();
         private boolean useProxySelector = defaultUseProxySelector();
         private boolean allowPoolingConnection = defaultAllowPoolingConnection();
-        private boolean useRelativeURIsWithSSLProxies = defaultUseRelativeURIsWithSSLProxies();
+        private boolean useRelativeURIsWithConnectProxies = defaultUseRelativeURIsWithConnectProxies();
         private int requestCompressionLevel = defaultRequestCompressionLevel();
         private int maxRequestRetry = defaultMaxRequestRetry();
         private int ioThreadMultiplier = defaultIoThreadMultiplier();
@@ -1005,15 +1017,31 @@ public Builder setStrict302Handling(final boolean strict302Handling) {
         }
 
         /**
-         * Configures this AHC instance to use relative URIs instead of absolute ones when talking with a SSL proxy.
+         * Configures this AHC instance to use relative URIs instead of absolute ones when talking with a SSL proxy or
+         * WebSocket proxy.
          *
          * @param useRelativeURIsWithSSLProxies
          * @return this
          *
          * @since 1.7.2
+         * @deprecated Use setUseRelativeURIsWithConnectProxies instead.
          */
         public Builder setUseRelativeURIsWithSSLProxies(boolean useRelativeURIsWithSSLProxies) {
-            this.useRelativeURIsWithSSLProxies = useRelativeURIsWithSSLProxies;
+            this.useRelativeURIsWithConnectProxies = useRelativeURIsWithSSLProxies;
+            return this;
+        }
+
+        /**
+         * Configures this AHC instance to use relative URIs instead of absolute ones when making requests through
+         * proxies using the CONNECT method, such as when making SSL requests or WebSocket requests.
+         *
+         * @param useRelativeURIsWithConnectProxies
+         * @return this
+         *
+         * @since 1.8.13
+         */
+        public Builder setUseRelativeURIsWithConnectProxies(boolean useRelativeURIsWithConnectProxies) {
+            this.useRelativeURIsWithConnectProxies = useRelativeURIsWithConnectProxies;
             return this;
         }
 
@@ -1139,7 +1167,7 @@ public Thread newThread(Runnable r) {
                     hostnameVerifier,
                     ioThreadMultiplier,
                     strict302Handling,
-                    useRelativeURIsWithSSLProxies,
+                    useRelativeURIsWithConnectProxies,
                     timeConverter);
         }
     }

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

@@ -58,7 +58,7 @@ void configureDefaults() {
         compressionEnabled = defaultCompressionEnabled();
         userAgent = defaultUserAgent();
         allowPoolingConnection = defaultAllowPoolingConnection();
-        useRelativeURIsWithSSLProxies = defaultUseRelativeURIsWithSSLProxies();
+        useRelativeURIsWithConnectProxies = defaultUseRelativeURIsWithConnectProxies();
         requestCompressionLevel = defaultRequestCompressionLevel();
         maxRequestRetry = defaultMaxRequestRetry();
         ioThreadMultiplier = defaultIoThreadMultiplier();

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

@@ -13,12 +13,17 @@
 package com.ning.http.client;
 
 import com.ning.http.util.AllowAllHostnameVerifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import static com.ning.http.util.MiscUtil.getBoolean;
 
 import javax.net.ssl.HostnameVerifier;
 
 public final class AsyncHttpClientConfigDefaults {
 
+    private final static Logger log = LoggerFactory.getLogger(AsyncHttpClientConfigDefaults.class);
+
     private AsyncHttpClientConfigDefaults() {
     }
 
@@ -92,8 +97,23 @@ public static boolean defaultAllowPoolingConnection() {
         return getBoolean(ASYNC_CLIENT + "allowPoolingConnection", true);
     }
 
+    /**
+     * @deprecated Use defaultUseRelativeURIsWithConnectProxies instead.
+     */
+    @Deprecated
     public static boolean defaultUseRelativeURIsWithSSLProxies() {
-        return getBoolean(ASYNC_CLIENT + "useRelativeURIsWithSSLProxies", true);
+        String systemPropValue = System.getProperty(ASYNC_CLIENT + "useRelativeURIsWithSSLProxies");
+        if (systemPropValue != null) {
+            log.warn(ASYNC_CLIENT + "useRelativeURIsWithSSLProxies is deprecated, use " + ASYNC_CLIENT +
+                    "defaultUseRelativeURIsWithConnectProxies instead");
+            return systemPropValue.equalsIgnoreCase("true");
+        } else {
+            return true;
+        }
+    }
+
+    public static boolean defaultUseRelativeURIsWithConnectProxies() {
+        return getBoolean(ASYNC_CLIENT + "useRelativeURIsWithConnectProxies", defaultUseRelativeURIsWithSSLProxies());
     }
 
     // unused/broken, left there for compatibility, fixed in Netty 4

src/main/java/com/ning/http/client/providers/grizzly/GrizzlyAsyncHttpProvider.java

@@ -891,7 +891,7 @@ private boolean sendAsGrizzlyRequest(final Request request,
                     httpCtx.establishingTunnel = true;
                     builder.method(Method.CONNECT);
                     builder.uri(AsyncHttpProviderUtils.getAuthority(uri));
-                } else if (secure && config.isUseRelativeURIsWithSSLProxies()){
+                } else if ((secure || httpCtx.isWSRequest) && config.isUseRelativeURIsWithConnectProxies()){
                     builder.uri(uri.getPath());
                 } else {
                     builder.uri(uri.toString());

src/main/java/com/ning/http/client/providers/netty/NettyAsyncHttpProvider.java

@@ -649,12 +649,16 @@ protected final static HttpRequest buildRequest(AsyncHttpClientConfig config, Re
             throws IOException {
 
         String method = request.getMethod();
-        if (allowConnect && proxyServer != null && (isSecure(uri) || isWebSocket(uri.getScheme()))) {
+        if (allowConnect && proxyServer != null && useProxyConnect(uri)) {
             method = HttpMethod.CONNECT.toString();
         }
         return construct(config, request, new HttpMethod(method), uri, buffer, proxyServer);
     }
 
+    protected final static boolean useProxyConnect(URI uri) {
+        return isSecure(uri) || isWebSocket(uri.getScheme());
+    }
+
     private static SpnegoEngine getSpnegoEngine() {
         if (spnegoEngine == null)
             spnegoEngine = new SpnegoEngine();
@@ -676,7 +680,7 @@ private static HttpRequest construct(AsyncHttpClientConfig config, Request reque
             nettyRequest = new DefaultHttpRequest(HttpVersion.HTTP_1_0, m, AsyncHttpProviderUtils.getAuthority(uri));
         } else {
             String path = null;
-            if (proxyServer != null && !(isSecure(uri) && config.isUseRelativeURIsWithSSLProxies()))
+            if (proxyServer != null && !(useProxyConnect(uri) && config.isUseRelativeURIsWithConnectProxies()))
                 path = uri.toString();
             else if (uri.getRawQuery() != null)
                 path = uri.getRawPath() + "?" + uri.getRawQuery();