Search in sources :

Example 1 with ManagedClientConnection

use of org.apache.http.conn.ManagedClientConnection in project robovm by robovm.

the class RequestAddCookies method process.

public void process(final HttpRequest request, final HttpContext context) throws HttpException, IOException {
    if (request == null) {
        throw new IllegalArgumentException("HTTP request may not be null");
    }
    if (context == null) {
        throw new IllegalArgumentException("HTTP context may not be null");
    }
    // Obtain cookie store
    CookieStore cookieStore = (CookieStore) context.getAttribute(ClientContext.COOKIE_STORE);
    if (cookieStore == null) {
        this.log.info("Cookie store not available in HTTP context");
        return;
    }
    // Obtain the registry of cookie specs
    CookieSpecRegistry registry = (CookieSpecRegistry) context.getAttribute(ClientContext.COOKIESPEC_REGISTRY);
    if (registry == null) {
        this.log.info("CookieSpec registry not available in HTTP context");
        return;
    }
    // Obtain the target host (required)
    HttpHost targetHost = (HttpHost) context.getAttribute(ExecutionContext.HTTP_TARGET_HOST);
    if (targetHost == null) {
        throw new IllegalStateException("Target host not specified in HTTP context");
    }
    // Obtain the client connection (required)
    ManagedClientConnection conn = (ManagedClientConnection) context.getAttribute(ExecutionContext.HTTP_CONNECTION);
    if (conn == null) {
        throw new IllegalStateException("Client connection not specified in HTTP context");
    }
    String policy = HttpClientParams.getCookiePolicy(request.getParams());
    if (this.log.isDebugEnabled()) {
        this.log.debug("CookieSpec selected: " + policy);
    }
    URI requestURI;
    if (request instanceof HttpUriRequest) {
        requestURI = ((HttpUriRequest) request).getURI();
    } else {
        try {
            requestURI = new URI(request.getRequestLine().getUri());
        } catch (URISyntaxException ex) {
            throw new ProtocolException("Invalid request URI: " + request.getRequestLine().getUri(), ex);
        }
    }
    String hostName = targetHost.getHostName();
    int port = targetHost.getPort();
    if (port < 0) {
        port = conn.getRemotePort();
    }
    CookieOrigin cookieOrigin = new CookieOrigin(hostName, port, requestURI.getPath(), conn.isSecure());
    // Get an instance of the selected cookie policy
    CookieSpec cookieSpec = registry.getCookieSpec(policy, request.getParams());
    // Get all cookies available in the HTTP state
    List<Cookie> cookies = new ArrayList<Cookie>(cookieStore.getCookies());
    // Find cookies matching the given origin
    List<Cookie> matchedCookies = new ArrayList<Cookie>();
    for (Cookie cookie : cookies) {
        if (cookieSpec.match(cookie, cookieOrigin)) {
            if (this.log.isDebugEnabled()) {
                this.log.debug("Cookie " + cookie + " match " + cookieOrigin);
            }
            matchedCookies.add(cookie);
        }
    }
    // Generate Cookie request headers
    if (!matchedCookies.isEmpty()) {
        List<Header> headers = cookieSpec.formatCookies(matchedCookies);
        for (Header header : headers) {
            request.addHeader(header);
        }
    }
    int ver = cookieSpec.getVersion();
    if (ver > 0) {
        boolean needVersionHeader = false;
        for (Cookie cookie : matchedCookies) {
            if (ver != cookie.getVersion()) {
                needVersionHeader = true;
            }
        }
        if (needVersionHeader) {
            Header header = cookieSpec.getVersionHeader();
            if (header != null) {
                // Advertise cookie version support
                request.addHeader(header);
            }
        }
    }
    // Stick the CookieSpec and CookieOrigin instances to the HTTP context
    // so they could be obtained by the response interceptor
    context.setAttribute(ClientContext.COOKIE_SPEC, cookieSpec);
    context.setAttribute(ClientContext.COOKIE_ORIGIN, cookieOrigin);
}
Also used : HttpUriRequest(org.apache.http.client.methods.HttpUriRequest) Cookie(org.apache.http.cookie.Cookie) ProtocolException(org.apache.http.ProtocolException) ManagedClientConnection(org.apache.http.conn.ManagedClientConnection) ArrayList(java.util.ArrayList) URISyntaxException(java.net.URISyntaxException) URI(java.net.URI) CookieStore(org.apache.http.client.CookieStore) Header(org.apache.http.Header) HttpHost(org.apache.http.HttpHost) CookieSpec(org.apache.http.cookie.CookieSpec) CookieOrigin(org.apache.http.cookie.CookieOrigin) CookieSpecRegistry(org.apache.http.cookie.CookieSpecRegistry)

Example 2 with ManagedClientConnection

use of org.apache.http.conn.ManagedClientConnection in project jersey by jersey.

the class HelloWorldTest method testConnectionClosingOnExceptionsForErrorResponses.

/**
     * JERSEY-2157 reproducer.
     * <p>
     * The test ensures that entities of the error responses which cause
     * WebApplicationException being thrown by a JAX-RS client are buffered
     * and that the underlying input connections are automatically released
     * in such case.
     */
@Test
public void testConnectionClosingOnExceptionsForErrorResponses() {
    final BasicClientConnectionManager cm = new BasicClientConnectionManager();
    final AtomicInteger connectionCounter = new AtomicInteger(0);
    final ClientConfig config = new ClientConfig().property(ApacheClientProperties.CONNECTION_MANAGER, new ClientConnectionManager() {

        @Override
        public SchemeRegistry getSchemeRegistry() {
            return cm.getSchemeRegistry();
        }

        @Override
        public ClientConnectionRequest requestConnection(final HttpRoute route, final Object state) {
            connectionCounter.incrementAndGet();
            final ClientConnectionRequest wrappedRequest = cm.requestConnection(route, state);
            /**
                         * To explain the following long piece of code:
                         *
                         * All the code does is to just create a wrapper implementations
                         * for the AHC connection management interfaces.
                         *
                         * The only really important piece of code is the
                         * {@link org.apache.http.conn.ManagedClientConnection#releaseConnection()} implementation,
                         * where the connectionCounter is decremented when a managed connection instance
                         * is released by AHC runtime. In our test, this is expected to happen
                         * as soon as the exception is created for an error response
                         * (as the error response entity gets buffered in
                         * {@link org.glassfish.jersey.client.JerseyInvocation#convertToException(javax.ws.rs.core.Response)}).
                         */
            return new ClientConnectionRequest() {

                @Override
                public ManagedClientConnection getConnection(long timeout, TimeUnit tunit) throws InterruptedException, ConnectionPoolTimeoutException {
                    final ManagedClientConnection wrappedConnection = wrappedRequest.getConnection(timeout, tunit);
                    return new ManagedClientConnection() {

                        @Override
                        public boolean isSecure() {
                            return wrappedConnection.isSecure();
                        }

                        @Override
                        public HttpRoute getRoute() {
                            return wrappedConnection.getRoute();
                        }

                        @Override
                        public SSLSession getSSLSession() {
                            return wrappedConnection.getSSLSession();
                        }

                        @Override
                        public void open(HttpRoute route, HttpContext context, HttpParams params) throws IOException {
                            wrappedConnection.open(route, context, params);
                        }

                        @Override
                        public void tunnelTarget(boolean secure, HttpParams params) throws IOException {
                            wrappedConnection.tunnelTarget(secure, params);
                        }

                        @Override
                        public void tunnelProxy(HttpHost next, boolean secure, HttpParams params) throws IOException {
                            wrappedConnection.tunnelProxy(next, secure, params);
                        }

                        @Override
                        public void layerProtocol(HttpContext context, HttpParams params) throws IOException {
                            wrappedConnection.layerProtocol(context, params);
                        }

                        @Override
                        public void markReusable() {
                            wrappedConnection.markReusable();
                        }

                        @Override
                        public void unmarkReusable() {
                            wrappedConnection.unmarkReusable();
                        }

                        @Override
                        public boolean isMarkedReusable() {
                            return wrappedConnection.isMarkedReusable();
                        }

                        @Override
                        public void setState(Object state) {
                            wrappedConnection.setState(state);
                        }

                        @Override
                        public Object getState() {
                            return wrappedConnection.getState();
                        }

                        @Override
                        public void setIdleDuration(long duration, TimeUnit unit) {
                            wrappedConnection.setIdleDuration(duration, unit);
                        }

                        @Override
                        public boolean isResponseAvailable(int timeout) throws IOException {
                            return wrappedConnection.isResponseAvailable(timeout);
                        }

                        @Override
                        public void sendRequestHeader(HttpRequest request) throws HttpException, IOException {
                            wrappedConnection.sendRequestHeader(request);
                        }

                        @Override
                        public void sendRequestEntity(HttpEntityEnclosingRequest request) throws HttpException, IOException {
                            wrappedConnection.sendRequestEntity(request);
                        }

                        @Override
                        public HttpResponse receiveResponseHeader() throws HttpException, IOException {
                            return wrappedConnection.receiveResponseHeader();
                        }

                        @Override
                        public void receiveResponseEntity(HttpResponse response) throws HttpException, IOException {
                            wrappedConnection.receiveResponseEntity(response);
                        }

                        @Override
                        public void flush() throws IOException {
                            wrappedConnection.flush();
                        }

                        @Override
                        public void close() throws IOException {
                            wrappedConnection.close();
                        }

                        @Override
                        public boolean isOpen() {
                            return wrappedConnection.isOpen();
                        }

                        @Override
                        public boolean isStale() {
                            return wrappedConnection.isStale();
                        }

                        @Override
                        public void setSocketTimeout(int timeout) {
                            wrappedConnection.setSocketTimeout(timeout);
                        }

                        @Override
                        public int getSocketTimeout() {
                            return wrappedConnection.getSocketTimeout();
                        }

                        @Override
                        public void shutdown() throws IOException {
                            wrappedConnection.shutdown();
                        }

                        @Override
                        public HttpConnectionMetrics getMetrics() {
                            return wrappedConnection.getMetrics();
                        }

                        @Override
                        public InetAddress getLocalAddress() {
                            return wrappedConnection.getLocalAddress();
                        }

                        @Override
                        public int getLocalPort() {
                            return wrappedConnection.getLocalPort();
                        }

                        @Override
                        public InetAddress getRemoteAddress() {
                            return wrappedConnection.getRemoteAddress();
                        }

                        @Override
                        public int getRemotePort() {
                            return wrappedConnection.getRemotePort();
                        }

                        @Override
                        public void releaseConnection() throws IOException {
                            connectionCounter.decrementAndGet();
                            wrappedConnection.releaseConnection();
                        }

                        @Override
                        public void abortConnection() throws IOException {
                            wrappedConnection.abortConnection();
                        }

                        @Override
                        public String getId() {
                            return wrappedConnection.getId();
                        }

                        @Override
                        public void bind(Socket socket) throws IOException {
                            wrappedConnection.bind(socket);
                        }

                        @Override
                        public Socket getSocket() {
                            return wrappedConnection.getSocket();
                        }
                    };
                }

                @Override
                public void abortRequest() {
                    wrappedRequest.abortRequest();
                }
            };
        }

        @Override
        public void releaseConnection(ManagedClientConnection conn, long keepalive, TimeUnit tunit) {
            cm.releaseConnection(conn, keepalive, tunit);
        }

        @Override
        public void closeExpiredConnections() {
            cm.closeExpiredConnections();
        }

        @Override
        public void closeIdleConnections(long idletime, TimeUnit tunit) {
            cm.closeIdleConnections(idletime, tunit);
        }

        @Override
        public void shutdown() {
            cm.shutdown();
        }
    });
    config.connectorProvider(new ApacheConnectorProvider());
    final Client client = ClientBuilder.newClient(config);
    final WebTarget rootTarget = client.target(getBaseUri()).path(ROOT_PATH);
    // Test that connection is getting closed properly for error responses.
    try {
        final String response = rootTarget.path("error").request().get(String.class);
        fail("Exception expected. Received: " + response);
    } catch (InternalServerErrorException isee) {
    // do nothing - connection should be closed properly by now
    }
    // Fail if the previous connection has not been closed automatically.
    assertEquals(0, connectionCounter.get());
    try {
        final String response = rootTarget.path("error2").request().get(String.class);
        fail("Exception expected. Received: " + response);
    } catch (InternalServerErrorException isee) {
        assertEquals("Received unexpected data.", "Error2.", isee.getResponse().readEntity(String.class));
        // Test buffering:
        // second read would fail if entity was not buffered
        assertEquals("Unexpected data in the entity buffer.", "Error2.", isee.getResponse().readEntity(String.class));
    }
    assertEquals(0, connectionCounter.get());
}
Also used : ClientConnectionRequest(org.apache.http.conn.ClientConnectionRequest) ConnectionPoolTimeoutException(org.apache.http.conn.ConnectionPoolTimeoutException) HttpConnectionMetrics(org.apache.http.HttpConnectionMetrics) HttpHost(org.apache.http.HttpHost) SchemeRegistry(org.apache.http.conn.scheme.SchemeRegistry) HttpEntityEnclosingRequest(org.apache.http.HttpEntityEnclosingRequest) TimeUnit(java.util.concurrent.TimeUnit) HttpException(org.apache.http.HttpException) ClientConfig(org.glassfish.jersey.client.ClientConfig) Client(javax.ws.rs.client.Client) HttpRequest(org.apache.http.HttpRequest) ManagedClientConnection(org.apache.http.conn.ManagedClientConnection) SSLSession(javax.net.ssl.SSLSession) HttpContext(org.apache.http.protocol.HttpContext) HttpResponse(org.apache.http.HttpResponse) IOException(java.io.IOException) PoolingHttpClientConnectionManager(org.apache.http.impl.conn.PoolingHttpClientConnectionManager) BasicClientConnectionManager(org.apache.http.impl.conn.BasicClientConnectionManager) ClientConnectionManager(org.apache.http.conn.ClientConnectionManager) HttpClientConnectionManager(org.apache.http.conn.HttpClientConnectionManager) HttpRoute(org.apache.http.conn.routing.HttpRoute) HttpParams(org.apache.http.params.HttpParams) AtomicInteger(java.util.concurrent.atomic.AtomicInteger) BasicClientConnectionManager(org.apache.http.impl.conn.BasicClientConnectionManager) InternalServerErrorException(javax.ws.rs.InternalServerErrorException) WebTarget(javax.ws.rs.client.WebTarget) InetAddress(java.net.InetAddress) Socket(java.net.Socket) JerseyTest(org.glassfish.jersey.test.JerseyTest) Test(org.junit.Test)

Example 3 with ManagedClientConnection

use of org.apache.http.conn.ManagedClientConnection in project robovm by robovm.

the class DefaultUserTokenHandler method getUserToken.

public Object getUserToken(final HttpContext context) {
    Principal userPrincipal = null;
    AuthState targetAuthState = (AuthState) context.getAttribute(ClientContext.TARGET_AUTH_STATE);
    if (targetAuthState != null) {
        userPrincipal = getAuthPrincipal(targetAuthState);
        if (userPrincipal == null) {
            AuthState proxyAuthState = (AuthState) context.getAttribute(ClientContext.PROXY_AUTH_STATE);
            userPrincipal = getAuthPrincipal(proxyAuthState);
        }
    }
    if (userPrincipal == null) {
        ManagedClientConnection conn = (ManagedClientConnection) context.getAttribute(ExecutionContext.HTTP_CONNECTION);
        if (conn.isOpen()) {
            SSLSession sslsession = conn.getSSLSession();
            if (sslsession != null) {
                userPrincipal = sslsession.getLocalPrincipal();
            }
        }
    }
    return userPrincipal;
}
Also used : ManagedClientConnection(org.apache.http.conn.ManagedClientConnection) AuthState(org.apache.http.auth.AuthState) SSLSession(javax.net.ssl.SSLSession) Principal(java.security.Principal)

Example 4 with ManagedClientConnection

use of org.apache.http.conn.ManagedClientConnection in project XobotOS by xamarin.

the class RequestAddCookies method process.

public void process(final HttpRequest request, final HttpContext context) throws HttpException, IOException {
    if (request == null) {
        throw new IllegalArgumentException("HTTP request may not be null");
    }
    if (context == null) {
        throw new IllegalArgumentException("HTTP context may not be null");
    }
    // Obtain cookie store
    CookieStore cookieStore = (CookieStore) context.getAttribute(ClientContext.COOKIE_STORE);
    if (cookieStore == null) {
        this.log.info("Cookie store not available in HTTP context");
        return;
    }
    // Obtain the registry of cookie specs
    CookieSpecRegistry registry = (CookieSpecRegistry) context.getAttribute(ClientContext.COOKIESPEC_REGISTRY);
    if (registry == null) {
        this.log.info("CookieSpec registry not available in HTTP context");
        return;
    }
    // Obtain the target host (required)
    HttpHost targetHost = (HttpHost) context.getAttribute(ExecutionContext.HTTP_TARGET_HOST);
    if (targetHost == null) {
        throw new IllegalStateException("Target host not specified in HTTP context");
    }
    // Obtain the client connection (required)
    ManagedClientConnection conn = (ManagedClientConnection) context.getAttribute(ExecutionContext.HTTP_CONNECTION);
    if (conn == null) {
        throw new IllegalStateException("Client connection not specified in HTTP context");
    }
    String policy = HttpClientParams.getCookiePolicy(request.getParams());
    if (this.log.isDebugEnabled()) {
        this.log.debug("CookieSpec selected: " + policy);
    }
    URI requestURI;
    if (request instanceof HttpUriRequest) {
        requestURI = ((HttpUriRequest) request).getURI();
    } else {
        try {
            requestURI = new URI(request.getRequestLine().getUri());
        } catch (URISyntaxException ex) {
            throw new ProtocolException("Invalid request URI: " + request.getRequestLine().getUri(), ex);
        }
    }
    String hostName = targetHost.getHostName();
    int port = targetHost.getPort();
    if (port < 0) {
        port = conn.getRemotePort();
    }
    CookieOrigin cookieOrigin = new CookieOrigin(hostName, port, requestURI.getPath(), conn.isSecure());
    // Get an instance of the selected cookie policy
    CookieSpec cookieSpec = registry.getCookieSpec(policy, request.getParams());
    // Get all cookies available in the HTTP state
    List<Cookie> cookies = new ArrayList<Cookie>(cookieStore.getCookies());
    // Find cookies matching the given origin
    List<Cookie> matchedCookies = new ArrayList<Cookie>();
    for (Cookie cookie : cookies) {
        if (cookieSpec.match(cookie, cookieOrigin)) {
            if (this.log.isDebugEnabled()) {
                this.log.debug("Cookie " + cookie + " match " + cookieOrigin);
            }
            matchedCookies.add(cookie);
        }
    }
    // Generate Cookie request headers
    if (!matchedCookies.isEmpty()) {
        List<Header> headers = cookieSpec.formatCookies(matchedCookies);
        for (Header header : headers) {
            request.addHeader(header);
        }
    }
    int ver = cookieSpec.getVersion();
    if (ver > 0) {
        boolean needVersionHeader = false;
        for (Cookie cookie : matchedCookies) {
            if (ver != cookie.getVersion()) {
                needVersionHeader = true;
            }
        }
        if (needVersionHeader) {
            Header header = cookieSpec.getVersionHeader();
            if (header != null) {
                // Advertise cookie version support
                request.addHeader(header);
            }
        }
    }
    // Stick the CookieSpec and CookieOrigin instances to the HTTP context
    // so they could be obtained by the response interceptor
    context.setAttribute(ClientContext.COOKIE_SPEC, cookieSpec);
    context.setAttribute(ClientContext.COOKIE_ORIGIN, cookieOrigin);
}
Also used : HttpUriRequest(org.apache.http.client.methods.HttpUriRequest) Cookie(org.apache.http.cookie.Cookie) ProtocolException(org.apache.http.ProtocolException) ManagedClientConnection(org.apache.http.conn.ManagedClientConnection) ArrayList(java.util.ArrayList) URISyntaxException(java.net.URISyntaxException) URI(java.net.URI) CookieStore(org.apache.http.client.CookieStore) Header(org.apache.http.Header) HttpHost(org.apache.http.HttpHost) CookieSpec(org.apache.http.cookie.CookieSpec) CookieOrigin(org.apache.http.cookie.CookieOrigin) CookieSpecRegistry(org.apache.http.cookie.CookieSpecRegistry)

Example 5 with ManagedClientConnection

use of org.apache.http.conn.ManagedClientConnection in project XobotOS by xamarin.

the class DefaultUserTokenHandler method getUserToken.

public Object getUserToken(final HttpContext context) {
    Principal userPrincipal = null;
    AuthState targetAuthState = (AuthState) context.getAttribute(ClientContext.TARGET_AUTH_STATE);
    if (targetAuthState != null) {
        userPrincipal = getAuthPrincipal(targetAuthState);
        if (userPrincipal == null) {
            AuthState proxyAuthState = (AuthState) context.getAttribute(ClientContext.PROXY_AUTH_STATE);
            userPrincipal = getAuthPrincipal(proxyAuthState);
        }
    }
    if (userPrincipal == null) {
        ManagedClientConnection conn = (ManagedClientConnection) context.getAttribute(ExecutionContext.HTTP_CONNECTION);
        if (conn.isOpen()) {
            SSLSession sslsession = conn.getSSLSession();
            if (sslsession != null) {
                userPrincipal = sslsession.getLocalPrincipal();
            }
        }
    }
    return userPrincipal;
}
Also used : ManagedClientConnection(org.apache.http.conn.ManagedClientConnection) AuthState(org.apache.http.auth.AuthState) SSLSession(javax.net.ssl.SSLSession) Principal(java.security.Principal)

Aggregations

ManagedClientConnection (org.apache.http.conn.ManagedClientConnection)7 SSLSession (javax.net.ssl.SSLSession)4 HttpHost (org.apache.http.HttpHost)4 URI (java.net.URI)3 URISyntaxException (java.net.URISyntaxException)3 Principal (java.security.Principal)3 ArrayList (java.util.ArrayList)3 Header (org.apache.http.Header)3 ProtocolException (org.apache.http.ProtocolException)3 AuthState (org.apache.http.auth.AuthState)3 CookieStore (org.apache.http.client.CookieStore)3 HttpUriRequest (org.apache.http.client.methods.HttpUriRequest)3 Cookie (org.apache.http.cookie.Cookie)3 CookieOrigin (org.apache.http.cookie.CookieOrigin)3 CookieSpec (org.apache.http.cookie.CookieSpec)3 CookieSpecRegistry (org.apache.http.cookie.CookieSpecRegistry)3 IOException (java.io.IOException)1 InetAddress (java.net.InetAddress)1 Socket (java.net.Socket)1 TimeUnit (java.util.concurrent.TimeUnit)1