private ProxyServerSelector resolveProxyServerSelector() { if (proxyServerSelector != null) return proxyServerSelector; if (useProxySelector) return ProxyUtils.getJdkDefaultProxyServerSelector(); if (useProxyProperties) return ProxyUtils.createProxyServerSelector(System.getProperties()); return ProxyServerSelector.NO_PROXY_SELECTOR; }
public <T> ListenableFuture<T> sendRequest(final Request request, final AsyncHandler<T> asyncHandler, NettyResponseFuture<T> future) { if (isClosed()) { throw new IllegalStateException("Closed"); } validateWebSocketRequest(request, asyncHandler); ProxyServer proxyServer = getProxyServer(config, request); // WebSockets use connect tunneling to work with proxies if (proxyServer != null && proxyServer.getProxyType().isHttp() && (request.getUri().isSecured() || request.getUri().isWebSocket()) && !isConnectAlreadyDone(request, future)) { // Proxy with HTTPS or WebSocket: CONNECT for sure if (future != null && future.isConnectAllowed()) { // Perform CONNECT return sendRequestWithCertainForceConnect(request, asyncHandler, future, proxyServer, true); } else { // CONNECT will depend if we can pool or connection or if we have to open a new one return sendRequestThroughProxy(request, asyncHandler, future, proxyServer); } } else { // no CONNECT for sure return sendRequestWithCertainForceConnect(request, asyncHandler, future, proxyServer, false); } }
/** * @param config the global config * @param request the request * @return the proxy server to be used for this request (can be null) */ public static ProxyServer getProxyServer(AsyncHttpClientConfig config, Request request) { ProxyServer proxyServer = request.getProxyServer(); if (proxyServer == null) { ProxyServerSelector selector = config.getProxyServerSelector(); if (selector != null) { proxyServer = selector.select(request.getUri()); } } return ProxyUtils.avoidProxy(proxyServer, request) ? null : proxyServer; }
/** * Get a proxy server selector based on the JDK default proxy selector. * * @return The proxy server selector. */ public static ProxyServerSelector getJdkDefaultProxyServerSelector() { return createProxyServerSelector(ProxySelector.getDefault()); }
/** * @see #ignoreProxy(ProxyServer, String) */ public static boolean avoidProxy(final ProxyServer proxyServer, final Request request) { return ignoreProxy(proxyServer, request.getUri().getHost()); }
/** * Checks whether proxy should be used according to nonProxyHosts settings of it, or we want to go directly to * target host. If <code>null</code> proxy is passed in, this method returns true -- since there is NO proxy, we * should avoid to use it. Simple hostname pattern matching using "*" are supported, but only as prefixes. * See http://download.oracle.com/javase/1.4.2/docs/guide/net/properties.html * * @param proxyServer * @param hostname the hostname * @return true if we have to ignore proxy use (obeying non-proxy hosts settings), false otherwise. */ public static boolean ignoreProxy(final ProxyServer proxyServer, final String hostname) { if (proxyServer != null) { if (hostname == null) throw new NullPointerException("hostname"); List<String> nonProxyHosts = proxyServer.getNonProxyHosts(); if (isNonEmpty(nonProxyHosts)) { for (String nonProxyHost : nonProxyHosts) { if (matchNonProxyHost(hostname, nonProxyHost)) return true; } } return false; } else { return true; } }
public <T> ListenableFuture<T> sendRequest(final Request request,// final AsyncHandler<T> asyncHandler,// NettyResponseFuture<T> future,// boolean reclaimCache) throws IOException { if (closed.get()) throw new IOException("Closed"); Uri uri = request.getUri(); validateWebSocketRequest(request, uri, asyncHandler); ProxyServer proxyServer = getProxyServer(config, request); boolean resultOfAConnect = future != null && future.getNettyRequest() != null && future.getNettyRequest().getHttpRequest().getMethod() == HttpMethod.CONNECT; boolean useProxy = proxyServer != null && !resultOfAConnect; if (useProxy && useProxyConnect(uri)) // SSL proxy, have to handle CONNECT if (future != null && future.isConnectAllowed()) // CONNECT forced return sendRequestWithCertainForceConnect(request, asyncHandler, future, reclaimCache, uri, proxyServer, true, true); else return sendRequestThroughSslProxy(request, asyncHandler, future, reclaimCache, uri, proxyServer); else return sendRequestWithCertainForceConnect(request, asyncHandler, future, reclaimCache, uri, proxyServer, useProxy, false); }
private InetSocketAddress remoteAddress(Request request, Uri uri, ProxyServer proxy, boolean useProxy) throws UnknownHostException { InetAddress address; int port = getDefaultPort(uri); if (request.getInetAddress() != null) { address = request.getInetAddress(); } else if (!useProxy || avoidProxy(proxy, uri.getHost())) { address = request.getNameResolver().resolve(uri.getHost()); } else { address = request.getNameResolver().resolve(proxy.getHost()); port = proxy.getPort(); } return new InetSocketAddress(address, port); }
/** * Set an instance of {@link ProxyServer} used by an * {@link AsyncHttpClient} * * @param proxyServer instance of {@link ProxyServer} * @return a {@link Builder} */ public Builder setProxyServer(ProxyServer proxyServer) { this.proxyServerSelector = ProxyUtils.createProxyServerSelector(proxyServer); return this; }
public ChannelConnector(Request request, ProxyServer proxy, boolean useProxy, AsyncHandler<?> asyncHandler) throws UnknownHostException { this.asyncHandlerExtensions = asyncHandler instanceof AsyncHandlerExtensions ? (AsyncHandlerExtensions) asyncHandler : null; NameResolution[] resolutions; Uri uri = request.getUri(); int port = uri.getExplicitPort(); if (request.getInetAddress() != null) { resolutions = new NameResolution[] { new NameResolution(request.getInetAddress()) }; } else if (!useProxy || ignoreProxy(proxy, uri.getHost())) { resolutions = request.getNameResolver().resolve(uri.getHost()); } else { resolutions = request.getNameResolver().resolve(proxy.getHost()); port = uri.isSecured() ? proxy.getSecuredPort(): proxy.getPort(); } if (asyncHandlerExtensions != null) asyncHandlerExtensions.onDnsResolved(resolutions); remoteAddresses = new InetSocketAddress[resolutions.length]; for (int i = 0; i < resolutions.length; i ++) { remoteAddresses[i] = new InetSocketAddress(resolutions[i].address, port); } if (request.getLocalAddress() != null) { localAddress = new InetSocketAddress(request.getLocalAddress(), 0); } else { localAddress = null; } }
public <T> ListenableFuture<T> sendRequest(final Request request,// final AsyncHandler<T> asyncHandler,// NettyResponseFuture<T> future,// boolean reclaimCache) { if (closed.get()) throw new IllegalStateException("Closed"); validateWebSocketRequest(request, asyncHandler); ProxyServer proxyServer = getProxyServer(config, request); boolean resultOfAConnect = future != null && future.getNettyRequest() != null && future.getNettyRequest().getHttpRequest().getMethod() == HttpMethod.CONNECT; boolean useProxy = proxyServer != null && !resultOfAConnect; if (useProxy && request.getUri().useProxyConnect()) // SSL proxy, have to handle CONNECT if (future != null && future.isConnectAllowed()) // CONNECT forced return sendRequestWithCertainForceConnect(request, asyncHandler, future, reclaimCache, proxyServer, true, true); else return sendRequestThroughSslProxy(request, asyncHandler, future, reclaimCache, proxyServer); else return sendRequestWithCertainForceConnect(request, asyncHandler, future, reclaimCache, proxyServer, useProxy, false); }
proxyServerSelector = ProxyUtils.getJdkDefaultProxyServerSelector(); proxyServerSelector = ProxyUtils.createProxyServerSelector(System.getProperties());
private InetSocketAddress remoteAddress(Request request, Uri uri, ProxyServer proxy, boolean useProxy) throws UnknownHostException { InetAddress address; int port = getDefaultPort(uri); if (request.getInetAddress() != null) { address = request.getInetAddress(); } else if (!useProxy || avoidProxy(proxy, uri.getHost())) { address = request.getNameResolver().resolve(uri.getHost()); } else { address = request.getNameResolver().resolve(proxy.getHost()); port = proxy.getPort(); } return new InetSocketAddress(address, port); }
public AsyncHttpClientConfigBean setProxyServer(ProxyServer proxyServer) { this.proxyServerSelector = ProxyUtils.createProxyServerSelector(proxyServer); return this; }
public <T> ListenableFuture<T> sendRequest(final Request request,// final AsyncHandler<T> asyncHandler,// NettyResponseFuture<T> future,// boolean reclaimCache) throws IOException { if (closed.get()) throw new IOException("Closed"); Uri uri = request.getUri(); validateWebSocketRequest(request, uri, asyncHandler); ProxyServer proxyServer = getProxyServer(config, request); boolean resultOfAConnect = future != null && future.getNettyRequest() != null && future.getNettyRequest().getHttpRequest().getMethod() == HttpMethod.CONNECT; boolean useProxy = proxyServer != null && !resultOfAConnect; if (useProxy && useProxyConnect(uri)) // SSL proxy, have to handle CONNECT if (future != null && future.isConnectAllowed()) // CONNECT forced return sendRequestWithCertainForceConnect(request, asyncHandler, future, reclaimCache, uri, proxyServer, true, true); else return sendRequestThroughSslProxy(request, asyncHandler, future, reclaimCache, uri, proxyServer); else return sendRequestWithCertainForceConnect(request, asyncHandler, future, reclaimCache, uri, proxyServer, useProxy, false); }
void configureDefaults() { maxConnections = defaultMaxConnections(); maxConnectionsPerHost = defaultMaxConnectionsPerHost(); name = defaultName(); connectTimeout = defaultConnectTimeout(); webSocketTimeout = defaultWebSocketTimeout(); pooledConnectionIdleTimeout = defaultPooledConnectionIdleTimeout(); readTimeout = defaultReadTimeout(); requestTimeout = defaultRequestTimeout(); connectionTTL = defaultConnectionTTL(); followRedirect = defaultFollowRedirect(); maxRedirects = defaultMaxRedirects(); compressionEnforced = defaultCompressionEnforced(); userAgent = defaultUserAgent(); allowPoolingConnections = defaultAllowPoolingConnections(); maxRequestRetry = defaultMaxRequestRetry(); ioThreadMultiplier = defaultIoThreadMultiplier(); allowPoolingSslConnections = defaultAllowPoolingSslConnections(); disableUrlEncodingForBoundRequests = defaultDisableUrlEncodingForBoundRequests(); strict302Handling = defaultStrict302Handling(); acceptAnyCertificate = defaultAcceptAnyCertificate(); sslSessionCacheSize = defaultSslSessionCacheSize(); sslSessionTimeout = defaultSslSessionTimeout(); if (defaultUseProxySelector()) { proxyServerSelector = ProxyUtils.getJdkDefaultProxyServerSelector(); } else if (defaultUseProxyProperties()) { proxyServerSelector = ProxyUtils.createProxyServerSelector(System.getProperties()); } }
/** * Get a proxy server selector based on the JDK default proxy selector. * * @return The proxy server selector. */ public static ProxyServerSelector getJdkDefaultProxyServerSelector() { return createProxyServerSelector(ProxySelector.getDefault()); }
public <T> ListenableFuture<T> sendRequest(final Request request,// final AsyncHandler<T> asyncHandler,// NettyResponseFuture<T> future,// boolean reclaimCache) { if (isClosed()) throw new IllegalStateException("Closed"); validateWebSocketRequest(request, asyncHandler); ProxyServer proxyServer = getProxyServer(config, request); boolean resultOfAConnect = future != null && future.getNettyRequest() != null && future.getNettyRequest().getHttpRequest().getMethod() == HttpMethod.CONNECT; boolean useProxy = proxyServer != null && !resultOfAConnect; if (useProxy && request.getUri().useProxyConnect()) // SSL proxy, have to handle CONNECT if (future != null && future.isConnectAllowed()) // CONNECT forced return sendRequestWithCertainForceConnect(request, asyncHandler, future, reclaimCache, proxyServer, true, true); else return sendRequestThroughSslProxy(request, asyncHandler, future, reclaimCache, proxyServer); else return sendRequestWithCertainForceConnect(request, asyncHandler, future, reclaimCache, proxyServer, useProxy, false); }
return createProxyServerSelector(proxyServer);