Example usage for org.apache.http.client.protocol HttpClientContext CREDS_PROVIDER

List of usage examples for org.apache.http.client.protocol HttpClientContext CREDS_PROVIDER

Introduction

In this page you can find the example usage for org.apache.http.client.protocol HttpClientContext CREDS_PROVIDER.

Prototype

String CREDS_PROVIDER

To view the source code for org.apache.http.client.protocol HttpClientContext CREDS_PROVIDER.

Click Source Link

Document

Attribute name of a org.apache.http.client.CredentialsProvider object that represents the actual credentials provider.

Usage

From source file:org.apache.camel.component.http4.PreemptiveAuthInterceptor.java

public void process(final HttpRequest request, final HttpContext context) throws HttpException, IOException {
    AuthState authState = (AuthState) context.getAttribute(HttpClientContext.TARGET_AUTH_STATE);
    // If no auth scheme avaialble yet, try to initialize it preemptively
    if (authState.getAuthScheme() == null) {
        AuthScheme authScheme = (AuthScheme) context.getAttribute("preemptive-auth");
        CredentialsProvider credsProvider = (CredentialsProvider) context
                .getAttribute(HttpClientContext.CREDS_PROVIDER);
        if (authScheme != null) {
            Credentials creds = credsProvider.getCredentials(AuthScope.ANY);
            if (creds == null) {
                throw new HttpException("No credentials for preemptive authentication");
            }/*from  w  w w  .  j  a v a  2s.c o m*/
            authState.update(authScheme, creds);
        }
    }

}

From source file:com.sangupta.jerry.http.HttpExecutor.java

/**
 * Execute the given web request and return the obtained raw web response.
 * /*from  w  ww . j a va2 s  . c o  m*/
 * @param webRequest
 *            the {@link WebRequest} to be executed
 * 
 * @return the {@link WebRawResponse} obtained after execution
 * 
 * @throws IOException
 *             if something fails
 * 
 * @throws ClientProtocolException
 *             if something fails
 */
public WebRawResponse execute(WebRequest webRequest) throws ClientProtocolException, IOException {
    // sharing the context may lead to circular redirects in case
    // of redirections from two request objects towards a single
    // URI - like hitting http://google.com twice leads to circular
    // redirects in the second request
    HttpContext localHttpContext = new BasicHttpContext();

    localHttpContext.setAttribute(HttpClientContext.CREDS_PROVIDER, this.credentialsProvider);
    localHttpContext.setAttribute(HttpClientContext.AUTH_CACHE, this.authCache);
    localHttpContext.setAttribute(HttpClientContext.COOKIE_STORE, this.cookieStore);

    // localHttpContext.removeAttribute(DefaultRedirectStrategy.REDIRECT_LOCATIONS);

    HttpRequestBase httpRequest = webRequest.getHttpRequest();
    httpRequest.reset();
    return new WebRawResponse(this.client.execute(httpRequest, localHttpContext), localHttpContext);
}

From source file:org.eclipse.rdf4j.http.client.SPARQLProtocolSession.java

protected void setUsernameAndPasswordForUrl(String username, String password, String url) {

    if (username != null && password != null) {
        logger.debug("Setting username '{}' and password for server at {}.", username, url);
        java.net.URI requestURI = java.net.URI.create(url);
        String host = requestURI.getHost();
        int port = requestURI.getPort();
        AuthScope scope = new AuthScope(host, port);
        UsernamePasswordCredentials cred = new UsernamePasswordCredentials(username, password);
        CredentialsProvider credsProvider = new BasicCredentialsProvider();
        credsProvider.setCredentials(scope, cred);
        httpContext.setCredentialsProvider(credsProvider);
        AuthCache authCache = new BasicAuthCache();
        BasicScheme basicAuth = new BasicScheme();
        HttpHost httpHost = new HttpHost(requestURI.getHost(), requestURI.getPort(), requestURI.getScheme());
        authCache.put(httpHost, basicAuth);
        httpContext.setAuthCache(authCache);
    } else {//from  www  .j  av a2 s.c  o  m
        httpContext.removeAttribute(HttpClientContext.AUTH_CACHE);
        httpContext.removeAttribute(HttpClientContext.CREDS_PROVIDER);
    }
}

From source file:com.gargoylesoftware.htmlunit.HttpWebConnection.java

/**
 * Creates an <tt>HttpMethod</tt> instance according to the specified parameters.
 * @param webRequest the request/*from   w w w . j ava 2  s . c o  m*/
 * @param httpClientBuilder the httpClientBuilder that will be configured
 * @return the <tt>HttpMethod</tt> instance constructed according to the specified parameters
 * @throws IOException
 * @throws URISyntaxException
 */
@SuppressWarnings("deprecation")
private HttpUriRequest makeHttpMethod(final WebRequest webRequest, final HttpClientBuilder httpClientBuilder)
        throws IOException, URISyntaxException {

    final String charset = webRequest.getCharset();

    // Make sure that the URL is fully encoded. IE actually sends some Unicode chars in request
    // URLs; because of this we allow some Unicode chars in URLs. However, at this point we're
    // handing things over the HttpClient, and HttpClient will blow up if we leave these Unicode
    // chars in the URL.
    final URL url = UrlUtils.encodeUrl(webRequest.getUrl(), false, charset);

    // URIUtils.createURI is deprecated but as of httpclient-4.2.1, URIBuilder doesn't work here as it encodes path
    // what shouldn't happen here
    URI uri = URIUtils.createURI(url.getProtocol(), url.getHost(), url.getPort(), url.getPath(),
            escapeQuery(url.getQuery()), null);
    if (getVirtualHost() != null) {
        uri = URI.create(getVirtualHost());
    }
    final HttpRequestBase httpMethod = buildHttpMethod(webRequest.getHttpMethod(), uri);
    setProxy(httpMethod, webRequest);
    if (!(httpMethod instanceof HttpEntityEnclosingRequest)) {
        // this is the case for GET as well as TRACE, DELETE, OPTIONS and HEAD
        if (!webRequest.getRequestParameters().isEmpty()) {
            final List<NameValuePair> pairs = webRequest.getRequestParameters();
            final org.apache.http.NameValuePair[] httpClientPairs = NameValuePair.toHttpClient(pairs);
            final String query = URLEncodedUtils.format(Arrays.asList(httpClientPairs), charset);
            uri = URIUtils.createURI(url.getProtocol(), url.getHost(), url.getPort(), url.getPath(), query,
                    null);
            httpMethod.setURI(uri);
        }
    } else { // POST as well as PUT and PATCH
        final HttpEntityEnclosingRequest method = (HttpEntityEnclosingRequest) httpMethod;

        if (webRequest.getEncodingType() == FormEncodingType.URL_ENCODED && method instanceof HttpPost) {
            final HttpPost postMethod = (HttpPost) method;
            if (webRequest.getRequestBody() == null) {
                final List<NameValuePair> pairs = webRequest.getRequestParameters();
                final org.apache.http.NameValuePair[] httpClientPairs = NameValuePair.toHttpClient(pairs);
                final String query = URLEncodedUtils.format(Arrays.asList(httpClientPairs), charset);
                final StringEntity urlEncodedEntity = new StringEntity(query, charset);
                urlEncodedEntity.setContentType(URLEncodedUtils.CONTENT_TYPE);
                postMethod.setEntity(urlEncodedEntity);
            } else {
                final String body = StringUtils.defaultString(webRequest.getRequestBody());
                final StringEntity urlEncodedEntity = new StringEntity(body, charset);
                urlEncodedEntity.setContentType(URLEncodedUtils.CONTENT_TYPE);
                postMethod.setEntity(urlEncodedEntity);
            }
        } else if (FormEncodingType.MULTIPART == webRequest.getEncodingType()) {
            final Charset c = getCharset(charset, webRequest.getRequestParameters());
            final MultipartEntityBuilder builder = MultipartEntityBuilder.create().setLaxMode();
            builder.setCharset(c);

            for (final NameValuePair pair : webRequest.getRequestParameters()) {
                if (pair instanceof KeyDataPair) {
                    buildFilePart((KeyDataPair) pair, builder);
                } else {
                    builder.addTextBody(pair.getName(), pair.getValue(),
                            ContentType.create("text/plain", charset));
                }
            }
            method.setEntity(builder.build());
        } else { // for instance a PUT or PATCH request
            final String body = webRequest.getRequestBody();
            if (body != null) {
                method.setEntity(new StringEntity(body, charset));
            }
        }
    }

    configureHttpProcessorBuilder(httpClientBuilder, webRequest);

    // Tell the client where to get its credentials from
    // (it may have changed on the webClient since last call to getHttpClientFor(...))
    final CredentialsProvider credentialsProvider = webClient_.getCredentialsProvider();

    // if the used url contains credentials, we have to add this
    final Credentials requestUrlCredentials = webRequest.getUrlCredentials();
    if (null != requestUrlCredentials && webClient_.getBrowserVersion().hasFeature(URL_AUTH_CREDENTIALS)) {
        final URL requestUrl = webRequest.getUrl();
        final AuthScope authScope = new AuthScope(requestUrl.getHost(), requestUrl.getPort());
        // updating our client to keep the credentials for the next request
        credentialsProvider.setCredentials(authScope, requestUrlCredentials);
        httpContext_.removeAttribute(HttpClientContext.TARGET_AUTH_STATE);
    }

    // if someone has set credentials to this request, we have to add this
    final Credentials requestCredentials = webRequest.getCredentials();
    if (null != requestCredentials) {
        final URL requestUrl = webRequest.getUrl();
        final AuthScope authScope = new AuthScope(requestUrl.getHost(), requestUrl.getPort());
        // updating our client to keep the credentials for the next request
        credentialsProvider.setCredentials(authScope, requestCredentials);
        httpContext_.removeAttribute(HttpClientContext.TARGET_AUTH_STATE);
    }
    httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
    httpContext_.removeAttribute(HttpClientContext.CREDS_PROVIDER);

    return httpMethod;
}

From source file:com.ibm.team.build.internal.hjplugin.util.HttpUtils.java

/**
 * For Basic auth, configure the context to do pre-emptive auth with the
 * credentials given.//ww  w  . j av a 2 s  . co m
 * @param httpContext The context in use for the requests.
 * @param serverURI The RTC server we will be authenticating against
 * @param userId The userId to login with
 * @param password The password for the User
 * @param listener A listen to log messages to, Not required
 * @throws IOException Thrown if anything goes wrong
 */
private static void handleBasicAuthChallenge(HttpClientContext httpContext, String serverURI, String userId,
        String password, TaskListener listener) throws IOException {

    URI uri;
    try {
        uri = new URI(serverURI);
    } catch (URISyntaxException e) {
        throw new IOException(Messages.HttpUtils_invalid_server(serverURI), e);
    }
    HttpHost target = new HttpHost(uri.getHost(), uri.getPort(), uri.getScheme());
    CredentialsProvider credsProvider = new BasicCredentialsProvider();
    credsProvider.setCredentials(new AuthScope(target.getHostName(), target.getPort()),
            new UsernamePasswordCredentials(userId, password));
    httpContext.setAttribute(HttpClientContext.CREDS_PROVIDER, credsProvider);

    // Create AuthCache instance
    AuthCache authCache = new BasicAuthCache();
    // Generate BASIC scheme object and add it to the local auth cache
    BasicScheme basicAuth = new BasicScheme();
    authCache.put(target, basicAuth);

    // Add AuthCache to the execution context
    httpContext.setAuthCache(authCache);
}

From source file:org.apache.http.impl.client.InternalHttpClient.java

private void setupContext(final HttpClientContext context) {
    if (context.getAttribute(HttpClientContext.TARGET_AUTH_STATE) == null) {
        context.setAttribute(HttpClientContext.TARGET_AUTH_STATE, new AuthState());
    }//from   w  ww . j  a v  a 2 s  .  c o  m
    if (context.getAttribute(HttpClientContext.PROXY_AUTH_STATE) == null) {
        context.setAttribute(HttpClientContext.PROXY_AUTH_STATE, new AuthState());
    }
    if (context.getAttribute(HttpClientContext.AUTHSCHEME_REGISTRY) == null) {
        context.setAttribute(HttpClientContext.AUTHSCHEME_REGISTRY, this.authSchemeRegistry);
    }
    if (context.getAttribute(HttpClientContext.COOKIESPEC_REGISTRY) == null) {
        context.setAttribute(HttpClientContext.COOKIESPEC_REGISTRY, this.cookieSpecRegistry);
    }
    if (context.getAttribute(HttpClientContext.COOKIE_STORE) == null) {
        context.setAttribute(HttpClientContext.COOKIE_STORE, this.cookieStore);
    }
    if (context.getAttribute(HttpClientContext.CREDS_PROVIDER) == null) {
        context.setAttribute(HttpClientContext.CREDS_PROVIDER, this.credentialsProvider);
    }
    if (context.getAttribute(HttpClientContext.REQUEST_CONFIG) == null) {
        context.setAttribute(HttpClientContext.REQUEST_CONFIG, this.defaultConfig);
    }
}