Examples with ClientConfig org.glassfish.jersey.client.ClientConfig used on opensource projects

Example 81 with ClientConfig

use of org.glassfish.jersey.client.ClientConfig in project athenz by yahoo.

the class ZTSClient method initClient.

private void initClient(final String serverUrl, Principal identity, final String domainName, final String serviceName, final ServiceIdentityProvider siaProvider) {
    ztsUrl = (serverUrl == null) ? confZtsUrl : serverUrl;
    if (!isEmpty(ztsUrl)) {
        if (!ztsUrl.endsWith("/zts/v1")) {
            if (ztsUrl.charAt(ztsUrl.length() - 1) != '/') {
                ztsUrl += '/';
            }
            ztsUrl += "zts/v1";
        }
    }
    // determine to see if we need a host verifier for our ssl connections
    HostnameVerifier hostnameVerifier = null;
    if (!isEmpty(x509CertDNSName)) {
        hostnameVerifier = new AWSHostNameVerifier(x509CertDNSName);
    }
    if (sslContext == null) {
        sslContext = createSSLContext();
    }
    // setup our client config object with timeouts
    final JacksonJsonProvider jacksonJsonProvider = new JacksonJaxbJsonProvider().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    final ClientConfig config = new ClientConfig(jacksonJsonProvider);
    PoolingHttpClientConnectionManager connManager = createConnectionManager(sslContext, hostnameVerifier);
    if (connManager != null) {
        config.property(ApacheClientProperties.CONNECTION_MANAGER, connManager);
    }
    config.connectorProvider(new ApacheConnectorProvider());
    if (proxyUrl != null) {
        config.property(ClientProperties.PROXY_URI, proxyUrl);
    }
    ClientBuilder builder = getClientBuilder();
    if (sslContext != null) {
        builder = builder.sslContext(sslContext);
        enablePrefetch = true;
    }
    // JerseyClientBuilder::withConfig() replaces the existing config with the new client
    // config. Hence the client config should be added to the builder before the timeouts.
    // Otherwise the timeout settings would be overridden.
    Client rsClient = builder.withConfig(config).hostnameVerifier(hostnameVerifier).readTimeout(reqReadTimeout, TimeUnit.MILLISECONDS).connectTimeout(reqConnectTimeout, TimeUnit.MILLISECONDS).build();
    ztsClient = new ZTSRDLGeneratedClient(ztsUrl, rsClient);
    principal = identity;
    domain = domainName;
    service = serviceName;
    this.siaProvider = siaProvider;
    if (principal != null) {
        domain = principal.getDomain();
        service = principal.getName();
        ztsClient.addCredentials(identity.getAuthority().getHeader(), identity.getCredentials());
    }
}

Example 82 with ClientConfig

use of org.glassfish.jersey.client.ClientConfig in project jersey by jersey.

the class AuthTest method testPreemptiveAuthPost.

@Test
public void testPreemptiveAuthPost() {
    CredentialsProvider credentialsProvider = new org.apache.http.impl.client.BasicCredentialsProvider();
    credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials("name", "password"));
    ClientConfig cc = new ClientConfig();
    cc.property(ApacheClientProperties.CREDENTIALS_PROVIDER, credentialsProvider).property(ApacheClientProperties.PREEMPTIVE_BASIC_AUTHENTICATION, true);
    cc.connectorProvider(new ApacheConnectorProvider());
    Client client = ClientBuilder.newClient(cc);
    WebTarget r = client.target(getBaseUri());
    assertEquals("POST", r.request().post(Entity.text("POST"), String.class));
}

Example 83 with ClientConfig

use of org.glassfish.jersey.client.ClientConfig in project jersey by jersey.

the class AuthTest method testAuthInteractivePost.

@Test
@Ignore("JERSEY-1750: Cannot retry request with a non-repeatable request entity. How to buffer the entity?" + " Allow repeatable write in jersey?")
public void testAuthInteractivePost() {
    CredentialsProvider credentialsProvider = new org.apache.http.impl.client.BasicCredentialsProvider();
    credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials("name", "password"));
    ClientConfig cc = new ClientConfig();
    cc.property(ApacheClientProperties.CREDENTIALS_PROVIDER, credentialsProvider);
    cc.connectorProvider(new ApacheConnectorProvider());
    Client client = ClientBuilder.newClient(cc);
    WebTarget r = client.target(getBaseUri()).path("test");
    assertEquals("POST", r.request().post(Entity.text("POST"), String.class));
}

Example 84 with ClientConfig

use of org.glassfish.jersey.client.ClientConfig 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());
}

Example 85 with ClientConfig

use of org.glassfish.jersey.client.ClientConfig in project jersey by jersey.

the class HttpMethodTest method testPostChunked.

@Test
public void testPostChunked() {
    ClientConfig cc = new ClientConfig().property(ClientProperties.CHUNKED_ENCODING_SIZE, 1024).connectorProvider(new ApacheConnectorProvider());
    Client client = ClientBuilder.newClient(cc);
    WebTarget r = getWebTarget(client);
    assertEquals("POST", r.request().post(Entity.text("POST"), String.class));
    Response cr = r.request().post(Entity.text("POST"));
    assertTrue(cr.hasEntity());
    cr.close();
}