Examples of org.eclipse.jetty.client.util.InputStreamResponseListener

org.eclipse.jetty.client.util.InputStreamResponseListener
for the response headers to arrive Response response = listener.get(5, TimeUnit.SECONDS); if (response.getStatus() == 200) { // Obtain the input stream on the response content try (InputStream input = listener.getInputStream()) { // Read the response content } }
The {@link HttpClient} implementation (the producer) will feed the input streamasynchronously while the application (the consumer) is reading from it. Chunks of content are maintained in a queue, and it is possible to specify a maximum buffer size for the bytes held in the queue, by default 16384 bytes.
If the consumer is faster than the producer, then the consumer will block with the typical {@link InputStream#read()} semantic.If the consumer is slower than the producer, then the producer will block until the client consumes.

    protected void sendRequest(final Request request, final ExecutionObserver obs,
                               final OperationDefinition operationDefinition) {
        final String url = String.valueOf(request.getURI());
        final long startTime = System.currentTimeMillis();


        InputStreamResponseListener listener = new InputStreamResponseListener() {
            @Override
            public void onHeaders(final Response response) {
                super.onHeaders(response);


                // can only get this once, so let's makes sure..

View Full Code Here

        // apply filters
        request = applyRequestFilters(request);


        // create jetty request and response listener
        HttpRequest jettyRequest = buildJettyRequest(request);
        InputStreamResponseListener listener = new InputStreamResponseListener(maxContentLength)
        {
            @Override
            public void onContent(Response response, ByteBuffer content)
            {
                // ignore empty blocks
                if (content.remaining() == 0) {
                    return;
                }
                super.onContent(response, content);
            }
        };


        // fire the request
        jettyRequest.send(listener);


        // wait for response to begin
        Response response;
        try {
            response = listener.get(httpClient.getIdleTimeout(), TimeUnit.MILLISECONDS);
        }
        catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return responseHandler.handleException(request, e);
        }
        catch (TimeoutException e) {
            return responseHandler.handleException(request, e);
        }
        catch (ExecutionException e) {
            Throwable cause = e.getCause();
            if (cause instanceof Exception) {
                return responseHandler.handleException(request, (Exception) cause);
            }
            else {
                return responseHandler.handleException(request, new RuntimeException(cause));
            }
        }


        // process response
        long responseStart = System.nanoTime();


        JettyResponse jettyResponse = null;
        T value;
        try {
            jettyResponse = new JettyResponse(response, listener.getInputStream());
            value = responseHandler.handle(request, jettyResponse);
        }
        finally {
            recordRequestComplete(stats, request, requestStart, jettyResponse, responseStart);
        }

View Full Code Here

                }
            }
        });


        HttpClient client = prepareClient();
        InputStreamResponseListener listener = new InputStreamResponseListener();
        int port = serverConnector.getLocalPort();
        client.newRequest("localhost", port).send(listener);


        // Make the proxy request fail; given the small content, the
        // proxy-to-client response is not committed yet so it will be reset.
        TimeUnit.MILLISECONDS.sleep(2 * proxyTimeout);


        Response response = listener.get(5, TimeUnit.SECONDS);
        Assert.assertEquals(504, response.getStatus());


        // Make sure there is no content, as the proxy-to-client response has been reset.
        InputStream input = listener.getInputStream();
        Assert.assertEquals(-1, input.read());


        chunk1Latch.countDown();


        // Result succeeds because a 504 is a valid HTTP response.
        Result result = listener.await(5, TimeUnit.SECONDS);
        Assert.assertTrue(result.isSucceeded());


        // Make sure the proxy does not receive chunk2.
        Assert.assertEquals(-1, input.read());

View Full Code Here

                }
            }
        });


        HttpClient client = prepareClient();
        InputStreamResponseListener listener = new InputStreamResponseListener();
        int port = serverConnector.getLocalPort();
        client.newRequest("localhost", port).send(listener);


        Response response = listener.get(5, TimeUnit.SECONDS);
        Assert.assertEquals(200, response.getStatus());


        InputStream input = listener.getInputStream();
        for (int i = 0; i < chunk1.length; ++i)
            Assert.assertEquals(chunk1[i] & 0xFF, input.read());


        TimeUnit.MILLISECONDS.sleep(2 * proxyTimeout);

View Full Code Here

    public void testResponseInputStream() throws Exception
    {
        HttpClient client = new HttpClient();
        client.start();


        InputStreamResponseListener listener = new InputStreamResponseListener();
        // Send asynchronously with the InputStreamResponseListener
        client.newRequest("localhost", 8080).send(listener);


        // Call to the listener's get() blocks until the headers arrived
        Response response = listener.get(5, TimeUnit.SECONDS);


        // Now check the response information that arrived to decide whether to read the content
        if (response.getStatus() == 200)
        {
            byte[] buffer = new byte[256];
            try (InputStream input = listener.getInputStream())
            {
                while (true)
                {
                    int read = input.read(buffer);
                    if (read < 0)

View Full Code Here

                baseRequest.setHandled(true);
                response.getOutputStream().write(data);
            }
        });


        InputStreamResponseListener listener = new InputStreamResponseListener();
        client.newRequest("localhost", connector.getLocalPort())
                .scheme(scheme)
                .send(listener);
        Response response = listener.get(5, TimeUnit.SECONDS);
        Assert.assertNotNull(response);
        Assert.assertEquals(200, response.getStatus());


        InputStream input = listener.getInputStream();
        Assert.assertNotNull(input);


        int length = 0;
        while (input.read() == value)
        {
            if (length % 100 == 0)
                Thread.sleep(1);
            ++length;
        }


        Assert.assertEquals(data.length, length);


        Result result = listener.await(5, TimeUnit.SECONDS);
        Assert.assertNotNull(result);
        Assert.assertFalse(result.isFailed());
        Assert.assertSame(response, result.getResponse());
    }

View Full Code Here

                baseRequest.setHandled(true);
                response.getOutputStream().write(data);
            }
        });


        InputStreamResponseListener listener = new InputStreamResponseListener();
        client.newRequest("localhost", connector.getLocalPort())
                .scheme(scheme)
                .send(listener);
        Response response = listener.get(5, TimeUnit.SECONDS);
        Assert.assertNotNull(response);
        Assert.assertEquals(200, response.getStatus());


        InputStream input = listener.getInputStream();
        Assert.assertNotNull(input);


        for (byte b : data)
        {
            int read = input.read();
            assertTrue(read >= 0);
            Assert.assertEquals(b & 0xFF, read);
        }


        Assert.assertEquals(-1, input.read());


        Result result = listener.await(5, TimeUnit.SECONDS);
        Assert.assertNotNull(result);
        Assert.assertFalse(result.isFailed());
        Assert.assertSame(response, result.getResponse());
    }

View Full Code Here

                // ...then shutdown output
                baseRequest.getHttpChannel().getEndPoint().shutdownOutput();
            }
        });


        InputStreamResponseListener listener = new InputStreamResponseListener();
        client.newRequest("localhost", connector.getLocalPort())
                .scheme(scheme)
                .send(listener);
        Response response = listener.get(5, TimeUnit.SECONDS);
        Assert.assertNotNull(response);
        Assert.assertEquals(200, response.getStatus());


        InputStream input = listener.getInputStream();
        Assert.assertNotNull(input);


        int length = 0;
        try
        {
            length = 0;
            while (input.read() == value)
            {
                if (length % 100 == 0)
                    Thread.sleep(1);
                ++length;
            }
            fail();
        }
        catch (IOException expected)
        {
        }


        Assert.assertEquals(data.length, length);


        Result result = listener.await(5, TimeUnit.SECONDS);
        Assert.assertNotNull(result);
        Assert.assertTrue(result.isFailed());
    }

View Full Code Here

                baseRequest.setHandled(true);
                IO.copy(request.getInputStream(), response.getOutputStream());
            }
        });


        InputStreamResponseListener listener = new InputStreamResponseListener();
        InputStream stream = listener.getInputStream();
        // Close the stream immediately
        stream.close();


        client.newRequest("localhost", connector.getLocalPort())
                .scheme(scheme)
                .content(new BytesContentProvider(new byte[]{0, 1, 2, 3}))
                .send(listener);
        Response response = listener.get(5, TimeUnit.SECONDS);
        Assert.assertEquals(200, response.getStatus());


        stream.read(); // Throws
    }

View Full Code Here

            }
        });


        final CountDownLatch waitLatch = new CountDownLatch(1);
        final CountDownLatch waitedLatch = new CountDownLatch(1);
        InputStreamResponseListener listener = new InputStreamResponseListener(1)
        {
            @Override
            protected boolean await()
            {
                waitLatch.countDown();
                boolean result = super.await();
                waitedLatch.countDown();
                return result;
            }
        };
        client.newRequest("localhost", connector.getLocalPort())
                .scheme(scheme)
                .send(listener);
        Response response = listener.get(5, TimeUnit.SECONDS);
        Assert.assertEquals(200, response.getStatus());


        InputStream stream = listener.getInputStream();
        // Wait until we block
        Assert.assertTrue(waitLatch.await(5, TimeUnit.SECONDS));
        // Close the stream
        stream.close();
        closeLatch.countDown();

View Full Code Here

0 1

TOP

Related Classes of org.eclipse.jetty.client.util.InputStreamResponseListener

com.betfair.cougar.client.AsyncHttpExecutable

com.facebook.presto.jdbc.internal.airlift.http.client.jetty.JettyHttpClient

com.proofpoint.http.client.jetty.JettyHttpClient

io.airlift.http.client.jetty.JettyHttpClient

org.eclipse.jetty.client.api.Usage

org.eclipse.jetty.client.HttpClientStreamTest

org.eclipse.jetty.proxy.ProxyServletTest

java.io.InputStream

java.util.concurrent.ExecutionException

java.io.InterruptedIOException

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.