Search in sources :

Example 21 with HttpEntityEnclosingRequest

use of org.apache.http.HttpEntityEnclosingRequest in project moco by dreamhead.

the class MocoRequestAction method doExecute.

private void doExecute(final CloseableHttpClient client, final Request request) throws IOException {
    HttpRequestBase targetRequest = createRequest(url, method, request);
    if (targetRequest instanceof HttpEntityEnclosingRequest && content.isPresent()) {
        ((HttpEntityEnclosingRequest) targetRequest).setEntity(asEntity(content.get(), request));
    }
    client.execute(targetRequest);
}
Also used : HttpRequestBase(org.apache.http.client.methods.HttpRequestBase) HttpEntityEnclosingRequest(org.apache.http.HttpEntityEnclosingRequest)

Example 22 with HttpEntityEnclosingRequest

use of org.apache.http.HttpEntityEnclosingRequest in project elasticsearch by elastic.

the class RequestLoggerTests method testTraceRequest.

public void testTraceRequest() throws IOException, URISyntaxException {
    HttpHost host = new HttpHost("localhost", 9200, randomBoolean() ? "http" : "https");
    String expectedEndpoint = "/index/type/_api";
    URI uri;
    if (randomBoolean()) {
        uri = new URI(expectedEndpoint);
    } else {
        uri = new URI("index/type/_api");
    }
    HttpUriRequest request = randomHttpRequest(uri);
    String expected = "curl -iX " + request.getMethod() + " '" + host + expectedEndpoint + "'";
    boolean hasBody = request instanceof HttpEntityEnclosingRequest && randomBoolean();
    String requestBody = "{ \"field\": \"value\" }";
    if (hasBody) {
        expected += " -d '" + requestBody + "'";
        HttpEntityEnclosingRequest enclosingRequest = (HttpEntityEnclosingRequest) request;
        HttpEntity entity;
        switch(randomIntBetween(0, 4)) {
            case 0:
                entity = new StringEntity(requestBody, ContentType.APPLICATION_JSON);
                break;
            case 1:
                entity = new InputStreamEntity(new ByteArrayInputStream(requestBody.getBytes(StandardCharsets.UTF_8)), ContentType.APPLICATION_JSON);
                break;
            case 2:
                entity = new NStringEntity(requestBody, ContentType.APPLICATION_JSON);
                break;
            case 3:
                entity = new NByteArrayEntity(requestBody.getBytes(StandardCharsets.UTF_8), ContentType.APPLICATION_JSON);
                break;
            case 4:
                // Evil entity without a charset
                entity = new StringEntity(requestBody, ContentType.create("application/json", (Charset) null));
                break;
            default:
                throw new UnsupportedOperationException();
        }
        enclosingRequest.setEntity(entity);
    }
    String traceRequest = RequestLogger.buildTraceRequest(request, host);
    assertThat(traceRequest, equalTo(expected));
    if (hasBody) {
        //check that the body is still readable as most entities are not repeatable
        String body = EntityUtils.toString(((HttpEntityEnclosingRequest) request).getEntity(), StandardCharsets.UTF_8);
        assertThat(body, equalTo(requestBody));
    }
}
Also used : HttpUriRequest(org.apache.http.client.methods.HttpUriRequest) HttpEntity(org.apache.http.HttpEntity) URI(java.net.URI) InputStreamEntity(org.apache.http.entity.InputStreamEntity) NStringEntity(org.apache.http.nio.entity.NStringEntity) StringEntity(org.apache.http.entity.StringEntity) NStringEntity(org.apache.http.nio.entity.NStringEntity) NByteArrayEntity(org.apache.http.nio.entity.NByteArrayEntity) ByteArrayInputStream(java.io.ByteArrayInputStream) HttpHost(org.apache.http.HttpHost) HttpEntityEnclosingRequest(org.apache.http.HttpEntityEnclosingRequest)

Example 23 with HttpEntityEnclosingRequest

use of org.apache.http.HttpEntityEnclosingRequest in project elasticsearch by elastic.

the class RemoteScrollableHitSourceTests method sourceWithMockedRemoteCall.

/**
     * Creates a hit source that doesn't make the remote request and instead returns data from some files. Also requests are always returned
     * synchronously rather than asynchronously.
     */
@SuppressWarnings("unchecked")
private RemoteScrollableHitSource sourceWithMockedRemoteCall(boolean mockRemoteVersion, ContentType contentType, String... paths) throws Exception {
    URL[] resources = new URL[paths.length];
    for (int i = 0; i < paths.length; i++) {
        resources[i] = Thread.currentThread().getContextClassLoader().getResource("responses/" + paths[i].replace("fail:", ""));
        if (resources[i] == null) {
            throw new IllegalArgumentException("Couldn't find [" + paths[i] + "]");
        }
    }
    CloseableHttpAsyncClient httpClient = mock(CloseableHttpAsyncClient.class);
    when(httpClient.<HttpResponse>execute(any(HttpAsyncRequestProducer.class), any(HttpAsyncResponseConsumer.class), any(HttpClientContext.class), any(FutureCallback.class))).thenAnswer(new Answer<Future<HttpResponse>>() {

        int responseCount = 0;

        @Override
        public Future<HttpResponse> answer(InvocationOnMock invocationOnMock) throws Throwable {
            // Throw away the current thread context to simulate running async httpclient's thread pool
            threadPool.getThreadContext().stashContext();
            HttpAsyncRequestProducer requestProducer = (HttpAsyncRequestProducer) invocationOnMock.getArguments()[0];
            FutureCallback<HttpResponse> futureCallback = (FutureCallback<HttpResponse>) invocationOnMock.getArguments()[3];
            HttpEntityEnclosingRequest request = (HttpEntityEnclosingRequest) requestProducer.generateRequest();
            URL resource = resources[responseCount];
            String path = paths[responseCount++];
            ProtocolVersion protocolVersion = new ProtocolVersion("http", 1, 1);
            if (path.startsWith("fail:")) {
                String body = Streams.copyToString(new InputStreamReader(request.getEntity().getContent(), StandardCharsets.UTF_8));
                if (path.equals("fail:rejection.json")) {
                    StatusLine statusLine = new BasicStatusLine(protocolVersion, RestStatus.TOO_MANY_REQUESTS.getStatus(), "");
                    BasicHttpResponse httpResponse = new BasicHttpResponse(statusLine);
                    futureCallback.completed(httpResponse);
                } else {
                    futureCallback.failed(new RuntimeException(body));
                }
            } else {
                StatusLine statusLine = new BasicStatusLine(protocolVersion, 200, "");
                HttpResponse httpResponse = new BasicHttpResponse(statusLine);
                httpResponse.setEntity(new InputStreamEntity(FileSystemUtils.openFileURLStream(resource), contentType));
                futureCallback.completed(httpResponse);
            }
            return null;
        }
    });
    return sourceWithMockedClient(mockRemoteVersion, httpClient);
}
Also used : InputStreamReader(java.io.InputStreamReader) BasicHttpResponse(org.apache.http.message.BasicHttpResponse) HttpResponse(org.apache.http.HttpResponse) HttpAsyncResponseConsumer(org.apache.http.nio.protocol.HttpAsyncResponseConsumer) HttpClientContext(org.apache.http.client.protocol.HttpClientContext) Matchers.containsString(org.hamcrest.Matchers.containsString) ProtocolVersion(org.apache.http.ProtocolVersion) URL(java.net.URL) BasicStatusLine(org.apache.http.message.BasicStatusLine) InputStreamEntity(org.apache.http.entity.InputStreamEntity) StatusLine(org.apache.http.StatusLine) BasicStatusLine(org.apache.http.message.BasicStatusLine) BasicHttpResponse(org.apache.http.message.BasicHttpResponse) HttpAsyncRequestProducer(org.apache.http.nio.protocol.HttpAsyncRequestProducer) InvocationOnMock(org.mockito.invocation.InvocationOnMock) HttpEntityEnclosingRequest(org.apache.http.HttpEntityEnclosingRequest) CloseableHttpAsyncClient(org.apache.http.impl.nio.client.CloseableHttpAsyncClient) ScheduledFuture(java.util.concurrent.ScheduledFuture) Future(java.util.concurrent.Future) FutureCallback(org.apache.http.concurrent.FutureCallback)

Example 24 with HttpEntityEnclosingRequest

use of org.apache.http.HttpEntityEnclosingRequest 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 25 with HttpEntityEnclosingRequest

use of org.apache.http.HttpEntityEnclosingRequest in project camel by apache.

the class BasicValidationHandler method handle.

public void handle(final HttpRequest request, final HttpResponse response, final HttpContext context) throws HttpException, IOException {
    if (expectedMethod != null && !expectedMethod.equals(request.getRequestLine().getMethod())) {
        response.setStatusCode(HttpStatus.SC_METHOD_FAILURE);
        return;
    }
    if (!validateQuery(request)) {
        response.setStatusCode(HttpStatus.SC_BAD_REQUEST);
        return;
    }
    if (expectedContent != null) {
        HttpEntity entity = ((HttpEntityEnclosingRequest) request).getEntity();
        String content = EntityUtils.toString(entity);
        if (!expectedContent.equals(content)) {
            response.setStatusCode(HttpStatus.SC_BAD_REQUEST);
            return;
        }
    }
    response.setStatusCode(HttpStatus.SC_OK);
    if (responseContent != null) {
        response.setEntity(new StringEntity(responseContent, "ASCII"));
    }
}
Also used : StringEntity(org.apache.http.entity.StringEntity) HttpEntity(org.apache.http.HttpEntity) HttpEntityEnclosingRequest(org.apache.http.HttpEntityEnclosingRequest)

Aggregations

HttpEntityEnclosingRequest (org.apache.http.HttpEntityEnclosingRequest)38 HttpEntity (org.apache.http.HttpEntity)24 HttpResponse (org.apache.http.HttpResponse)14 HttpUriRequest (org.apache.http.client.methods.HttpUriRequest)12 Header (org.apache.http.Header)11 ProtocolVersion (org.apache.http.ProtocolVersion)11 HttpRequest (org.apache.http.HttpRequest)10 URI (java.net.URI)7 ByteArrayOutputStream (java.io.ByteArrayOutputStream)5 RequestWrapper (org.apache.http.impl.client.RequestWrapper)5 IOException (java.io.IOException)4 HttpException (org.apache.http.HttpException)4 InputStreamEntity (org.apache.http.entity.InputStreamEntity)4 ProtocolException (java.net.ProtocolException)3 Iterator (java.util.Iterator)3 HttpHost (org.apache.http.HttpHost)3 ProtocolException (org.apache.http.ProtocolException)3 HttpPost (org.apache.http.client.methods.HttpPost)3 HttpRequestBase (org.apache.http.client.methods.HttpRequestBase)3 AbstractHttpEntity (org.apache.http.entity.AbstractHttpEntity)3