@Override public void process(HttpRequest request, HttpContext context) { HttpHost host = HttpClientContext.adapt(context).getTargetHost(); TraceContext parent = (TraceContext) context.getAttribute(TraceContext.class.getName()); Span span; try (Scope scope = currentTraceContext.maybeScope(parent)) { span = handler.nextSpan(request); } HttpRequestWrapper requestWrapper = HttpRequestWrapper.wrap(request, host); parseTargetAddress(requestWrapper, span); handler.handleSend(injector, request, requestWrapper, span); context.setAttribute(Span.class.getName(), span); context.setAttribute(Scope.class.getName(), currentTraceContext.newScope(span.context())); } }
private void logRequestExecution(final HttpUriRequest request) { final URI uri = request.getURI(); String query = uri.getQuery(); query = query != null ? "?" + query : ""; s_logger.debug("Executig " + request.getMethod() + " request on " + clientContext.getTargetHost() + uri.getPath() + query); }
@Override public CloseableHttpResponse execute(final HttpUriRequest request) throws CloudstackRESTException { logRequestExecution(request); try { return client.execute(clientContext.getTargetHost(), request, clientContext); } catch (final IOException e) { throw new CloudstackRESTException("Could not execute request " + request, e); } }
private void logRequestExecution(final HttpUriRequest request) { final URI uri = request.getURI(); String query = uri.getQuery(); query = query != null ? "?" + query : ""; s_logger.debug("Executig " + request.getMethod() + " request on " + clientContext.getTargetHost() + uri.getPath() + query); }
CloseableHttpClient httpclient = HttpClients.createDefault(); HttpClientContext context = HttpClientContext.create(); HttpGet httpget = new HttpGet("http://localhost:8080/"); CloseableHttpResponse response = httpclient.execute(httpget, context); try { HttpHost target = context.getTargetHost(); List<URI> redirectLocations = context.getRedirectLocations(); URI location = URIUtils.resolve(httpget.getURI(), target, redirectLocations); System.out.println("Final HTTP location: " + location.toASCIIString()); // Expected to be an absolute URI } finally { response.close(); }
@Override public CloseableHttpResponse execute(final HttpUriRequest request) throws CosmicRESTException { logRequestExecution(request); try { return client.execute(clientContext.getTargetHost(), request, clientContext); } catch (final IOException e) { throw new CosmicRESTException("Could not execute request " + request, e); } }
private RestAuthCredential getCredentials(HttpContext context) { HttpHost targetHost = ((HttpClientContext) context).getTargetHost(); int port = targetHost.getPort(); if (port == -1) { port = targetHost.getSchemeName().equals("https") ? 443 : 80; } Credentials credentials = ((HttpClientContext) context).getCredentialsProvider().getCredentials(new AuthScope(targetHost.getHostName(), port)); if (credentials instanceof RestAuthCredential) { return (RestAuthCredential) credentials; } else { return null; } }
@Override public void process(final HttpRequest request, final HttpContext context) throws IOException { if (context instanceof HttpClientContext) { final HttpClientContext clientContext = (HttpClientContext)context; final AuthState authState = clientContext.getTargetAuthState(); final CredentialsProvider credsProvider = clientContext.getCredentialsProvider(); final HttpHost targetHost = clientContext.getTargetHost(); // If not authentication scheme has been initialized yet if (authState.getAuthScheme() == null) { final AuthScope authScope = new AuthScope(targetHost.getHostName(), targetHost.getPort()); // Obtain credentials matching the target host final Credentials creds = credsProvider.getCredentials(authScope); // If found, generate BasicScheme preemptively if (creds != null) { authState.update(new BasicScheme(), creds); } } } else { throw new IllegalArgumentException("Not sure how to handle a non-HttpClientContext context."); } }
@Override public void process(final HttpRequest request, final HttpContext context) throws HttpException, IOException { HttpClientContext clientContext = HttpClientContext.adapt(context); AuthState authState = clientContext.getTargetAuthState(); if (authState.getAuthScheme() == null) { CredentialsProvider credsProvider = clientContext.getCredentialsProvider(); HttpHost targetHost = clientContext.getTargetHost(); Credentials creds = credsProvider.getCredentials(new AuthScope(targetHost.getHostName(), targetHost.getPort())); if (creds != null) { authState.update(new BasicScheme(), creds); } } } }
@Override public void process(final HttpRequest request, final HttpContext context) throws HttpException, IOException { HttpClientContext clientContext = HttpClientContext.adapt(context); AuthState authState = clientContext.getTargetAuthState(); if (authState.getAuthScheme() == null) { CredentialsProvider credsProvider = clientContext.getCredentialsProvider(); HttpHost targetHost = clientContext.getTargetHost(); Credentials creds = credsProvider.getCredentials(new AuthScope(targetHost.getHostName(), targetHost.getPort())); if (creds != null) { authState.update(new BasicScheme(), creds); } } } }
/** * Creates absolute request URI with full path from passed in context. */ @Nonnull private URI getRequestURI(final HttpContext context) { final HttpClientContext clientContext = HttpClientContext.adapt(context); final HttpRequest httpRequest = clientContext.getRequest(); final HttpHost target = clientContext.getTargetHost(); try { URI uri; if (httpRequest instanceof HttpUriRequest) { uri = ((HttpUriRequest) httpRequest).getURI(); } else { uri = URI.create(httpRequest.getRequestLine().getUri()); } return uri.isAbsolute() ? uri : URIUtils.resolve(URI.create(target.toURI()), uri); } catch (Exception e) { log.warn("Could not create absolute request URI", e); return URI.create(target.toURI()); } } }
public void process(HttpRequest request, HttpContext context) throws HttpException, IOException { final URI uri = URI.create(request.getRequestLine().getUri()); if (uri.getPath().endsWith(loginPath)) { LOG.debug("Request ends with {} so I'm not intercepting the request", loginPath); return; } Cookie loginCookie = getLoginCookie(context, loginTokenName); if (loginCookie != null) { LOG.debug("Request has cookie {}={} so I'm not intercepting the request", loginCookie.getName(), loginCookie.getValue()); return; } // get host final HttpHost host = HttpClientContext.adapt(context).getTargetHost(); // get the username and password from the credentials provider final CredentialsProvider credsProvider = HttpClientContext.adapt(context).getCredentialsProvider(); final AuthScope scope = new AuthScope(host.getHostName(), host.getPort()); final String username = credsProvider.getCredentials(scope).getUserPrincipal().getName(); final String password = credsProvider.getCredentials(scope).getPassword(); List<NameValuePair> parameters = new LinkedList<>(); parameters.add(new BasicNameValuePair("j_username", username)); parameters.add(new BasicNameValuePair("j_password", password)); HttpEntity httpEntity = new UrlEncodedFormEntity(parameters, "utf-8"); HttpPost loginPost = new HttpPost(URI.create(request.getRequestLine().getUri()).resolve(loginPath)); loginPost.setEntity(httpEntity); final CloseableHttpClient client = HttpClientBuilder.create().disableRedirectHandling().build(); client.execute(host, loginPost, context); }
@Override public void process(HttpRequest request, HttpContext context) throws HttpException, IOException { HttpClientContext clientContext = HttpClientContext.adapt(context); AuthState authState = clientContext.getTargetAuthState(); // If there's no auth scheme available yet, try to initialize it preemptively if (authState.getAuthScheme() == null) { CredentialsProvider credsProvider = clientContext.getCredentialsProvider(); HttpHost targetHost = clientContext.getTargetHost(); Credentials creds = credsProvider.getCredentials( new AuthScope(targetHost.getHostName(), targetHost.getPort())); if (creds != null) { authState.update(new BasicScheme(), creds); } } } }
@Override public void process(HttpRequest request, HttpContext context) throws HttpException, IOException { HttpClientContext clientContext = HttpClientContext.adapt(context); AuthState authState = clientContext.getTargetAuthState(); // If there's no auth scheme available yet, try to initialize it preemptively if (authState.getAuthScheme() == null) { CredentialsProvider credsProvider = clientContext.getCredentialsProvider(); HttpHost targetHost = clientContext.getTargetHost(); Credentials creds = credsProvider.getCredentials( new AuthScope(targetHost.getHostName(), targetHost.getPort())); if (creds != null) { authState.update(new BasicScheme(), creds); } } } }
/** * Schedules an asynchronous revalidation */ public synchronized void revalidateCacheEntry( final CachingExec cachingExec, final HttpRoute route, final HttpRequestWrapper request, final HttpClientContext context, final HttpExecutionAware execAware, final HttpCacheEntry entry) { // getVariantURI will fall back on getURI if no variants exist final String uri = cacheKeyGenerator.getVariantURI(context.getTargetHost(), request, entry); if (!queued.contains(uri)) { final int consecutiveFailedAttempts = failureCache.getErrorCount(uri); final AsynchronousValidationRequest revalidationRequest = new AsynchronousValidationRequest( this, cachingExec, route, request, context, execAware, entry, uri, consecutiveFailedAttempts); try { schedulingStrategy.schedule(revalidationRequest); queued.add(uri); } catch (final RejectedExecutionException ree) { log.debug("Revalidation for [" + uri + "] not scheduled: " + ree); } } }
@Override public void process(HttpRequest request, HttpContext context) { HttpHost host = HttpClientContext.adapt(context).getTargetHost(); TraceContext parent = (TraceContext) context.getAttribute(TraceContext.class.getName()); Span span; try (Scope scope = currentTraceContext.maybeScope(parent)) { span = handler.nextSpan(request); } HttpRequestWrapper requestWrapper = HttpRequestWrapper.wrap(request, host); parseTargetAddress(requestWrapper, span); handler.handleSend(injector, request, requestWrapper, span); context.setAttribute(Span.class.getName(), span); context.setAttribute(Scope.class.getName(), currentTraceContext.newScope(span.context())); } }
CloseableHttpResponse handleBackendResponse( final HttpRoute route, final HttpRequestWrapper request, final HttpClientContext context, final HttpExecutionAware execAware, final Date requestDate, final Date responseDate, final CloseableHttpResponse backendResponse) throws IOException { log.trace("Handling Backend response"); responseCompliance.ensureProtocolCompliance(request, backendResponse); final HttpHost target = context.getTargetHost(); final boolean cacheable = responseCachingPolicy.isResponseCacheable(request, backendResponse); responseCache.flushInvalidatedCacheEntriesFor(target, request, backendResponse); if (cacheable && !alreadyHaveNewerCacheEntry(target, request, backendResponse)) { storeRequestIfModifiedSinceFor304Response(request, backendResponse); return responseCache.cacheAndReturnResponse(target, request, backendResponse, requestDate, responseDate); } if (!cacheable) { try { responseCache.flushCacheEntriesFor(target, request); } catch (final IOException ioe) { log.warn("Unable to flush invalid cache entries", ioe); } } return backendResponse; }
private CloseableHttpResponse handleCacheMiss( final HttpRoute route, final HttpRequestWrapper request, final HttpClientContext context, final HttpExecutionAware execAware) throws IOException, HttpException { final HttpHost target = context.getTargetHost(); recordCacheMiss(target, request); if (!mayCallBackend(request)) { return Proxies.enhanceResponse( new BasicHttpResponse( HttpVersion.HTTP_1_1, HttpStatus.SC_GATEWAY_TIMEOUT, "Gateway Timeout")); } final Map<String, Variant> variants = getExistingCacheVariants(target, request); if (variants != null && variants.size() > 0) { return negotiateResponseFromVariants(route, request, context, execAware, variants); } return callBackend(route, request, context, execAware); }
final HttpExecutionAware execAware, final HttpCacheEntry entry) throws IOException, HttpException { final HttpHost target = context.getTargetHost(); recordCacheHit(target, request); CloseableHttpResponse out = null;
final HttpExecutionAware execAware) throws IOException, HttpException { final HttpHost target = context.getTargetHost(); final String via = generateViaHeader(request.getOriginal()); request.addHeader("Via",via); flushEntriesInvalidatedByRequest(context.getTargetHost(), request);