public Uri getUri() { return targetRequest.getUri(); }
public Object getPartitionKey() { return connectionPoolPartitioning.getPartitionKey(targetRequest.getUri(), targetRequest.getVirtualHost(), proxyServer); }
private void validateWebSocketRequest(Request request, AsyncHandler<?> asyncHandler) { Uri uri = request.getUri(); boolean isWs = uri.isWebSocket(); if (asyncHandler instanceof WebSocketUpgradeHandler) { if (!isWs) { throw new IllegalArgumentException( "WebSocketUpgradeHandler but scheme isn't ws or wss: " + uri.getScheme()); } else if (!request.getMethod().equals(GET) && !request.getMethod().equals(CONNECT)) { throw new IllegalArgumentException( "WebSocketUpgradeHandler but method isn't GET or CONNECT: " + request.getMethod()); } } else if (isWs) { throw new IllegalArgumentException("No WebSocketUpgradeHandler but scheme is " + uri.getScheme()); } }
/** * @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 proxyServer != null && !proxyServer.isIgnoredForHost(request.getUri().getHost()) ? proxyServer : null; }
private Channel pollPooledChannel(Request request, ProxyServer proxy, AsyncHandler<?> asyncHandler) { try { asyncHandler.onConnectionPoolAttempt(); } catch (Exception e) { LOGGER.error("onConnectionPoolAttempt crashed", e); } Uri uri = request.getUri(); String virtualHost = request.getVirtualHost(); final Channel channel = channelManager.poll(uri, virtualHost, proxy, request.getChannelPoolPartitioning()); if (channel != null) { LOGGER.debug("Using pooled Channel '{}' for '{}' to '{}'", channel, request.getMethod(), uri); } return channel; }
@Override public void calculateAndAddSignature(Request request, RequestBuilderBase<?> requestBuilder) { try { String authorization = INSTANCES.get().computeAuthorizationHeader( consumerAuth, userAuth, request.getUri(), request.getMethod(), request.getFormParams(), request.getQueryParams()); requestBuilder.setHeader(HttpHeaderNames.AUTHORIZATION, authorization); } catch (InvalidKeyException e) { throw new IllegalArgumentException("Failed to compute a valid key from consumer and user secrets", e); } } }
@Test public void testAdjustRange() { MapResumableProcessor proc = new MapResumableProcessor(); ResumableAsyncHandler handler = new ResumableAsyncHandler(proc); Request request = get("http://test/url").build(); Request newRequest = handler.adjustRequestRange(request); assertEquals(newRequest.getUri(), request.getUri()); String rangeHeader = newRequest.getHeaders().get(RANGE); assertNull(rangeHeader); proc.put("http://test/url", 5000); newRequest = handler.adjustRequestRange(request); assertEquals(newRequest.getUri(), request.getUri()); rangeHeader = newRequest.getHeaders().get(RANGE); assertEquals(rangeHeader, "bytes=5000-"); }
private Future<Response> execute(RequestBuilder rb, BodyConsumer bodyConsumer, ThrowableHandler throwableHandler) throws IOException { if (throwableHandler == null) { throwableHandler = defaultThrowableHandler; } Request request = rb.build(); ProgressAsyncHandler<Response> handler = new BodyConsumerAsyncHandler(bodyConsumer, throwableHandler, errorDocumentBehaviour, request.getUri(), listener); if (resumeEnabled && request.getMethod().equals("GET") && bodyConsumer != null && bodyConsumer instanceof ResumableBodyConsumer) { ResumableBodyConsumer fileBodyConsumer = (ResumableBodyConsumer) bodyConsumer; long length = fileBodyConsumer.getTransferredBytes(); fileBodyConsumer.resume(); handler = new ResumableBodyConsumerAsyncHandler(length, handler); } return getAsyncHttpClient().executeRequest(request, handler); }
@Override protected void onSuccess(List<InetSocketAddress> addresses) { NettyConnectListener<T> connectListener = new NettyConnectListener<>(future, NettyRequestSender.this, channelManager, connectionSemaphore); NettyChannelConnector connector = new NettyChannelConnector(request.getLocalAddress(), addresses, asyncHandler, clientState); if (!future.isDone()) { // Do not throw an exception when we need an extra connection for a redirect // FIXME why? This violate the max connection per host handling, right? channelManager.getBootstrap(request.getUri(), request.getNameResolver(), proxy) .addListener((Future<Bootstrap> whenBootstrap) -> { if (whenBootstrap.isSuccess()) { connector.connect(whenBootstrap.get(), connectListener); } else { abort(null, future, whenBootstrap.cause()); } }); } }
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); } }
public boolean exitAfterHandlingConnect(Channel channel, NettyResponseFuture<?> future, Request request, ProxyServer proxyServer) { if (future.isKeepAlive()) future.attachChannel(channel, true); Uri requestUri = request.getUri(); LOGGER.debug("Connecting to proxy {} for scheme {}", proxyServer, requestUri.getScheme()); Future<Channel> whenHandshaked = channelManager.updatePipelineForHttpTunneling(channel.pipeline(), requestUri); future.setReuseChannel(true); future.setConnectAllowed(false); Request targetRequest = new RequestBuilder(future.getTargetRequest()).build(); if (whenHandshaked == null) { requestSender.drainChannelAndExecuteNextRequest(channel, future, targetRequest); } else { requestSender.drainChannelAndExecuteNextRequest(channel, future, targetRequest, whenHandshaked); } return true; } }
private void kerberosChallenge(Realm realm, Request request, HttpHeaders headers) throws SpnegoEngineException { Uri uri = request.getUri(); String host = withDefault(request.getVirtualHost(), uri.getHost()); String challengeHeader = SpnegoEngine.instance(realm.getPrincipal(), realm.getPassword(), realm.getServicePrincipalName(), realm.getRealmName(), realm.isUseCanonicalHostname(), realm.getCustomLoginConfig(), realm.getLoginContextName()).generateToken(host); headers.set(AUTHORIZATION, NEGOTIATE + " " + challengeHeader); } }
@Override public void calculateAndAddSignature(Request request, RequestBuilderBase<?> requestBuilder) { try { String authorization = new OAuthSignatureCalculatorInstance().computeAuthorizationHeader( consumerKey, requestToken, request.getUri(), request.getMethod(), request.getFormParams(), request.getQueryParams(), timestamp, nonce); requestBuilder.setHeader(HttpHeaderNames.AUTHORIZATION, authorization); } catch (InvalidKeyException | NoSuchAlgorithmException e) { throw new IllegalArgumentException(e); } } }
@Test public void testNonProxyHost() { // // should avoid, it's in non-proxy hosts Request req = get("http://somewhere.com/foo").build(); ProxyServer proxyServer = proxyServer("localhost", 1234).setNonProxyHost("somewhere.com").build(); assertTrue(proxyServer.isIgnoredForHost(req.getUri().getHost())); // // // should avoid, it's in non-proxy hosts (with "*") req = get("http://sub.somewhere.com/foo").build(); proxyServer = proxyServer("localhost", 1234).setNonProxyHost("*.somewhere.com").build(); assertTrue(proxyServer.isIgnoredForHost(req.getUri().getHost())); // should use it req = get("http://sub.somewhere.com/foo").build(); proxyServer = proxyServer("localhost", 1234).setNonProxyHost("*.somewhere.com").build(); assertTrue(proxyServer.isIgnoredForHost(req.getUri().getHost())); }
@Test public void testWithStarQueryParameterValue() throws NoSuchAlgorithmException { final Request request = get("http://term.ie/oauth/example/request_token.php?testvalue=*").build(); String signatureBaseString = new OAuthSignatureCalculatorInstance() .signatureBaseString( new ConsumerKey("key", "secret"), new RequestToken(null, null), request.getUri(), request.getMethod(), request.getFormParams(), request.getQueryParams(), 1469019732, "6ad17f97334700f3ec2df0631d5b7511").toString(); assertEquals(signatureBaseString, "GET&" + "http%3A%2F%2Fterm.ie%2Foauth%2Fexample%2Frequest_token.php&" + "oauth_consumer_key%3Dkey%26" + "oauth_nonce%3D6ad17f97334700f3ec2df0631d5b7511%26" + "oauth_signature_method%3DHMAC-SHA1%26" + "oauth_timestamp%3D1469019732%26" + "oauth_version%3D1.0%26" + "testvalue%3D%252A"); }
@Test public void testSignatureGenerationWithAsteriskInPath() throws InvalidKeyException, NoSuchAlgorithmException { ConsumerKey consumerKey = new ConsumerKey("key", "secret"); RequestToken requestToken = new RequestToken(null, null); String nonce = "6ad17f97334700f3ec2df0631d5b7511"; long timestamp = 1469019732; final Request request = get("http://example.com/oauth/example/*path/wi*th/asterisks*").build(); String expectedSignature = "cswi/v3ZqhVkTyy5MGqW841BxDA="; String actualSignature = new OAuthSignatureCalculatorInstance().computeSignature( consumerKey, requestToken, request.getUri(), request.getMethod(), request.getFormParams(), request.getQueryParams(), timestamp, nonce); assertEquals(actualSignature, expectedSignature); String generatedAuthHeader = new OAuthSignatureCalculatorInstance().computeAuthorizationHeader(consumerKey, requestToken, actualSignature, timestamp, nonce); assertTrue(generatedAuthHeader.contains("oauth_signature=\"cswi%2Fv3ZqhVkTyy5MGqW841BxDA%3D\"")); }
@Test public void testWithNullRequestToken() throws NoSuchAlgorithmException { final Request request = get("http://photos.example.net/photos?file=vacation.jpg&size=original").build(); String signatureBaseString = new OAuthSignatureCalculatorInstance() .signatureBaseString(// new ConsumerKey("9djdj82h48djs9d2", CONSUMER_SECRET), new RequestToken(null, null), request.getUri(), request.getMethod(), request.getFormParams(), request.getQueryParams(), 137131201, Utf8UrlEncoder.percentEncodeQueryElement("ZLc92RAkooZcIO/0cctl0Q==")).toString(); assertEquals(signatureBaseString, "GET&" + "http%3A%2F%2Fphotos.example.net%2Fphotos&file%3Dvacation.jpg%26" + "oauth_consumer_key%3D9djdj82h48djs9d2%26" + "oauth_nonce%3DZLc92RAkooZcIO%252F0cctl0Q%253D%253D%26" + "oauth_signature_method%3DHMAC-SHA1%26" + "oauth_timestamp%3D137131201%26" + "oauth_version%3D1.0%26size%3Doriginal"); }
@Test public void testGetCalculateSignature() throws NoSuchAlgorithmException, InvalidKeyException { Request request = get("http://photos.example.net/photos") .addQueryParam("file", "vacation.jpg") .addQueryParam("size", "original") .build(); String signature = new OAuthSignatureCalculatorInstance() .computeSignature(new ConsumerKey(CONSUMER_KEY, CONSUMER_SECRET), new RequestToken(TOKEN_KEY, TOKEN_SECRET), request.getUri(), request.getMethod(), request.getFormParams(), request.getQueryParams(), TIMESTAMP, NONCE); assertEquals(signature, "tR3+Ty81lMeYAr/Fid0kMTYa/WM="); }
@Test public void multipleConcurrentPostRequestsOverHttpsWithDisabledKeepAliveStrategy() throws Throwable { logger.debug(">>> multipleConcurrentPostRequestsOverHttpsWithDisabledKeepAliveStrategy"); KeepAliveStrategy keepAliveStrategy = (ahcRequest, nettyRequest, nettyResponse) -> !ahcRequest.getUri().isSecured(); withClient(config().setSslEngineFactory(createSslEngineFactory()).setKeepAliveStrategy(keepAliveStrategy)).run(client -> withServer(server).run(server -> { server.enqueueEcho(); server.enqueueEcho(); server.enqueueEcho(); String body = "hello there"; client.preparePost(getTargetUrl()).setBody(body).setHeader(CONTENT_TYPE, "text/html").execute(); client.preparePost(getTargetUrl()).setBody(body).setHeader(CONTENT_TYPE, "text/html").execute(); Response response = client.preparePost(getTargetUrl()).setBody(body).setHeader(CONTENT_TYPE, "text/html").execute().get(); assertEquals(response.getResponseBody(), body); })); logger.debug("<<< multipleConcurrentPostRequestsOverHttpsWithDisabledKeepAliveStrategy"); }