Examples with ServletOutputStream javax.servlet.ServletOutputStream used on opensource projects

Example 1 with ServletOutputStream

use of javax.servlet.ServletOutputStream in project jetty.project by eclipse.

the class AsyncMiddleManServletTest method testProxyResponseWriteFails.

private void testProxyResponseWriteFails(final int writeCount) throws Exception {
    startServer(new HttpServlet() {

        @Override
        protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            ServletOutputStream output = response.getOutputStream();
            output.write(new byte[512]);
            output.flush();
            output.write(new byte[512]);
        }
    });
    startProxy(new AsyncMiddleManServlet() {

        private int count;

        @Override
        protected void writeProxyResponseContent(ServletOutputStream output, ByteBuffer content) throws IOException {
            if (++count < writeCount)
                super.writeProxyResponseContent(output, content);
            else
                throw new IOException("explicitly_thrown_by_test");
        }
    });
    startClient();
    ContentResponse response = client.newRequest("localhost", serverConnector.getLocalPort()).timeout(5, TimeUnit.SECONDS).send();
    Assert.assertEquals(502, response.getStatus());
}

Example 2 with ServletOutputStream

use of javax.servlet.ServletOutputStream in project jetty.project by eclipse.

the class AsyncMiddleManServletTest method testAfterContentTransformerInputStreamReset.

private void testAfterContentTransformerInputStreamReset(final boolean overflow) throws Exception {
    final byte[] data = new byte[] { 'c', 'o', 'f', 'f', 'e', 'e' };
    startServer(new HttpServlet() {

        @Override
        protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            // Write the content in two chunks.
            int chunk = data.length / 2;
            ServletOutputStream output = response.getOutputStream();
            output.write(data, 0, chunk);
            sleep(1000);
            output.write(data, chunk, data.length - chunk);
        }
    });
    startProxy(new AsyncMiddleManServlet() {

        @Override
        protected ContentTransformer newServerResponseContentTransformer(HttpServletRequest clientRequest, HttpServletResponse proxyResponse, Response serverResponse) {
            return new AfterContentTransformer() {

                {
                    setMaxInputBufferSize(overflow ? data.length / 2 : data.length * 2);
                }

                @Override
                public boolean transform(Source source, Sink sink) throws IOException {
                    // Consume the stream once.
                    InputStream input = source.getInputStream();
                    IO.copy(input, IO.getNullStream());
                    // Reset the stream and re-read it.
                    input.reset();
                    IO.copy(input, sink.getOutputStream());
                    return true;
                }
            };
        }
    });
    startClient();
    ContentResponse response = client.newRequest("localhost", serverConnector.getLocalPort()).timeout(5, TimeUnit.SECONDS).send();
    Assert.assertEquals(HttpStatus.OK_200, response.getStatus());
    Assert.assertArrayEquals(data, response.getContent());
}

Example 3 with ServletOutputStream

use of javax.servlet.ServletOutputStream in project jetty.project by eclipse.

the class ProxyServletTest method testProxyRequestFailureInTheMiddleOfProxyingSmallContent.

@Test
public void testProxyRequestFailureInTheMiddleOfProxyingSmallContent() throws Exception {
    final CountDownLatch chunk1Latch = new CountDownLatch(1);
    final int chunk1 = 'q';
    final int chunk2 = 'w';
    startServer(new HttpServlet() {

        @Override
        protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            ServletOutputStream output = response.getOutputStream();
            output.write(chunk1);
            response.flushBuffer();
            // Wait for the client to receive this chunk.
            await(chunk1Latch, 5000);
            // Send second chunk, must not be received by proxy.
            output.write(chunk2);
        }

        private boolean await(CountDownLatch latch, long ms) throws IOException {
            try {
                return latch.await(ms, TimeUnit.MILLISECONDS);
            } catch (InterruptedException x) {
                throw new InterruptedIOException();
            }
        }
    });
    final long proxyTimeout = 1000;
    Map<String, String> proxyParams = new HashMap<>();
    proxyParams.put("timeout", String.valueOf(proxyTimeout));
    startProxy(proxyParams);
    startClient();
    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());
    HttpDestinationOverHTTP destination = (HttpDestinationOverHTTP) client.getDestination("http", "localhost", port);
    DuplexConnectionPool connectionPool = (DuplexConnectionPool) destination.getConnectionPool();
    Assert.assertEquals(0, connectionPool.getIdleConnections().size());
}

Example 4 with ServletOutputStream

use of javax.servlet.ServletOutputStream in project jetty.project by eclipse.

the class AsyncMiddleManServletTest method testTransformGzippedHead.

@Test
public void testTransformGzippedHead() throws Exception {
    startServer(new HttpServlet() {

        @Override
        protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            response.setHeader(HttpHeader.CONTENT_ENCODING.asString(), "gzip");
            String sample = "<a href=\"http://webtide.com/\">Webtide</a>\n<a href=\"http://google.com\">Google</a>\n";
            byte[] bytes = sample.getBytes(StandardCharsets.UTF_8);
            ServletOutputStream out = response.getOutputStream();
            out.write(gzip(bytes));
            // create a byte buffer larger enough to create 2 (or more) transforms.
            byte[] randomFiller = new byte[64 * 1024];
            /* fill with nonsense
                 * Using random data to ensure compressed buffer size is large
                 * enough to trigger at least 2 transform() events.
                 */
            new Random().nextBytes(randomFiller);
            out.write(gzip(randomFiller));
        }
    });
    startProxy(new AsyncMiddleManServlet() {

        @Override
        protected ContentTransformer newServerResponseContentTransformer(HttpServletRequest clientRequest, HttpServletResponse proxyResponse, Response serverResponse) {
            return new GZIPContentTransformer(new HeadTransformer());
        }
    });
    startClient();
    ContentResponse response = client.newRequest("localhost", serverConnector.getLocalPort()).header(HttpHeader.CONTENT_ENCODING, "gzip").timeout(5, TimeUnit.SECONDS).send();
    Assert.assertEquals(200, response.getStatus());
    String expectedStr = "<a href=\"http://webtide.com/\">Webtide</a>";
    byte[] expected = expectedStr.getBytes(StandardCharsets.UTF_8);
    Assert.assertArrayEquals(expected, response.getContent());
}

Example 5 with ServletOutputStream

use of javax.servlet.ServletOutputStream in project jetty.project by eclipse.

the class AsyncMiddleManServletTest method testDownstreamTransformationBufferedGzipped.

@Test
public void testDownstreamTransformationBufferedGzipped() throws Exception {
    startServer(new HttpServlet() {

        @Override
        protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            response.setHeader(HttpHeader.CONTENT_ENCODING.asString(), "gzip");
            ServletInputStream input = request.getInputStream();
            ServletOutputStream output = response.getOutputStream();
            int read;
            while ((read = input.read()) >= 0) {
                output.write(read);
                output.flush();
            }
        }
    });
    startProxy(new AsyncMiddleManServlet() {

        @Override
        protected ContentTransformer newServerResponseContentTransformer(HttpServletRequest clientRequest, HttpServletResponse proxyResponse, Response serverResponse) {
            return new GZIPContentTransformer(new BufferingContentTransformer());
        }
    });
    startClient();
    byte[] bytes = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".getBytes(StandardCharsets.UTF_8);
    ContentResponse response = client.newRequest("localhost", serverConnector.getLocalPort()).header(HttpHeader.CONTENT_ENCODING, "gzip").content(new BytesContentProvider(gzip(bytes))).timeout(5, TimeUnit.SECONDS).send();
    Assert.assertEquals(200, response.getStatus());
    Assert.assertArrayEquals(bytes, response.getContent());
}