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

Example 1 with WriteListener

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

the class AsyncIOServletTest method testWriteFromOnDataAvailable.

@Test
public void testWriteFromOnDataAvailable() throws Exception {
    Queue<Throwable> errors = new ConcurrentLinkedQueue<>();
    CountDownLatch writeLatch = new CountDownLatch(1);
    start(new HttpServlet() {

        @Override
        protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            AsyncContext asyncContext = request.startAsync();
            request.getInputStream().setReadListener(new ReadListener() {

                @Override
                public void onDataAvailable() throws IOException {
                    ServletInputStream input = request.getInputStream();
                    ServletOutputStream output = response.getOutputStream();
                    while (input.isReady()) {
                        byte[] buffer = new byte[512];
                        int read = input.read(buffer);
                        if (read < 0) {
                            asyncContext.complete();
                            break;
                        }
                        if (output.isReady())
                            output.write(buffer, 0, read);
                        else
                            Assert.fail();
                    }
                }

                @Override
                public void onAllDataRead() throws IOException {
                    asyncContext.complete();
                }

                @Override
                public void onError(Throwable t) {
                    errors.offer(t);
                }
            });
            response.getOutputStream().setWriteListener(new WriteListener() {

                @Override
                public void onWritePossible() throws IOException {
                    writeLatch.countDown();
                }

                @Override
                public void onError(Throwable t) {
                    errors.offer(t);
                }
            });
        }
    });
    String content = "0123456789ABCDEF";
    DeferredContentProvider contentProvider = new DeferredContentProvider();
    contentProvider.offer(ByteBuffer.wrap(content.getBytes(StandardCharsets.UTF_8)));
    CountDownLatch clientLatch = new CountDownLatch(1);
    client.newRequest(newURI()).method(HttpMethod.POST).path(servletPath).content(contentProvider).send(new BufferingResponseListener() {

        @Override
        public void onComplete(Result result) {
            if (result.isSucceeded()) {
                Response response = result.getResponse();
                assertThat(response.getStatus(), Matchers.equalTo(HttpStatus.OK_200));
                assertThat(getContentAsString(), Matchers.equalTo(content));
                assertThat(errors, Matchers.hasSize(0));
                clientLatch.countDown();
            }
        }
    });
    assertTrue(writeLatch.await(5, TimeUnit.SECONDS));
    contentProvider.close();
    assertTrue(clientLatch.await(5, TimeUnit.SECONDS));
}

Example 2 with WriteListener

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

the class AsyncIOServletTest method testAsyncWriteThrows.

private void testAsyncWriteThrows(Throwable throwable) throws Exception {
    CountDownLatch latch = new CountDownLatch(1);
    start(new HttpServlet() {

        @Override
        protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            assertScope();
            AsyncContext asyncContext = request.startAsync(request, response);
            response.getOutputStream().setWriteListener(new WriteListener() {

                @Override
                public void onWritePossible() throws IOException {
                    assertScope();
                    if (throwable instanceof RuntimeException)
                        throw (RuntimeException) throwable;
                    if (throwable instanceof Error)
                        throw (Error) throwable;
                    throw new IOException(throwable);
                }

                @Override
                public void onError(Throwable t) {
                    assertScope();
                    latch.countDown();
                    response.setStatus(500);
                    asyncContext.complete();
                    Assert.assertSame(throwable, t);
                }
            });
        }
    });
    ContentResponse response = client.newRequest(newURI()).path(servletPath).timeout(5, TimeUnit.SECONDS).send();
    assertTrue(latch.await(5, TimeUnit.SECONDS));
    assertEquals(HttpStatus.INTERNAL_SERVER_ERROR_500, response.getStatus());
}

Example 3 with WriteListener

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

the class AsyncIOServletTest method testAsyncWriteClosed.

@Test
public void testAsyncWriteClosed() throws Exception {
    String text = "Now is the winter of our discontent. How Now Brown Cow. The quick brown fox jumped over the lazy dog.\n";
    for (int i = 0; i < 10; i++) text = text + text;
    byte[] data = text.getBytes(StandardCharsets.UTF_8);
    CountDownLatch errorLatch = new CountDownLatch(1);
    start(new HttpServlet() {

        @Override
        protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            assertScope();
            response.flushBuffer();
            AsyncContext async = request.startAsync();
            ServletOutputStream out = response.getOutputStream();
            out.setWriteListener(new WriteListener() {

                @Override
                public void onWritePossible() throws IOException {
                    assertScope();
                    // Wait for the failure to arrive to
                    // the server while we are about to write.
                    sleep(1000);
                    out.write(data);
                }

                @Override
                public void onError(Throwable t) {
                    assertScope();
                    async.complete();
                    errorLatch.countDown();
                }
            });
        }
    });
    CountDownLatch clientLatch = new CountDownLatch(1);
    client.newRequest(newURI()).path(servletPath).onResponseHeaders(response -> {
        if (response.getStatus() == HttpStatus.OK_200)
            response.abort(new IOException("explicitly_closed_by_test"));
    }).send(result -> {
        if (result.isFailed())
            clientLatch.countDown();
    });
    assertTrue(errorLatch.await(5, TimeUnit.SECONDS));
    assertTrue(clientLatch.await(5, TimeUnit.SECONDS));
}

Example 4 with WriteListener

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

the class ServerTimeoutsTest method testAsyncWriteIdleTimeoutFires.

@Test
public void testAsyncWriteIdleTimeoutFires() throws Exception {
    CountDownLatch handlerLatch = new CountDownLatch(1);
    start(new AbstractHandler() {

        @Override
        public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
            baseRequest.setHandled(true);
            AsyncContext asyncContext = request.startAsync();
            asyncContext.setTimeout(0);
            ServletOutputStream output = response.getOutputStream();
            output.setWriteListener(new WriteListener() {

                @Override
                public void onWritePossible() throws IOException {
                    output.write(new byte[64 * 1024 * 1024]);
                }

                @Override
                public void onError(Throwable failure) {
                    if (failure instanceof TimeoutException) {
                        asyncContext.complete();
                        handlerLatch.countDown();
                    }
                }
            });
        }
    });
    long idleTimeout = 2500;
    setServerIdleTimeout(idleTimeout);
    BlockingQueue<Callback> callbacks = new LinkedBlockingQueue<>();
    CountDownLatch resultLatch = new CountDownLatch(1);
    client.newRequest(newURI()).onResponseContentAsync((response, content, callback) -> {
        // Do not succeed the callback so the server will block writing.
        callbacks.offer(callback);
    }).send(result -> {
        if (result.isFailed())
            resultLatch.countDown();
    });
    // Async write should timeout.
    Assert.assertTrue(handlerLatch.await(2 * idleTimeout, TimeUnit.MILLISECONDS));
    // After the server stopped sending, consume on the client to read the early EOF.
    while (true) {
        Callback callback = callbacks.poll(1, TimeUnit.SECONDS);
        if (callback == null)
            break;
        callback.succeeded();
    }
    Assert.assertTrue(resultLatch.await(5, TimeUnit.SECONDS));
}

Example 5 with WriteListener

use of javax.servlet.WriteListener in project solo by b3log.

the class CaptchaProcessorTestCase method get.

/**
     * get.
     *
     * @throws Exception exception
     */
@Test(dependsOnMethods = "init")
public void get() throws Exception {
    final HttpServletRequest request = mock(HttpServletRequest.class);
    when(request.getServletContext()).thenReturn(mock(ServletContext.class));
    when(request.getRequestURI()).thenReturn("/captcha.do");
    when(request.getMethod()).thenReturn("GET");
    final MockDispatcherServlet dispatcherServlet = new MockDispatcherServlet();
    dispatcherServlet.init();
    final HttpServletResponse response = mock(HttpServletResponse.class);
    when(response.getOutputStream()).thenReturn(new ServletOutputStream() {

        private long size;

        @Override
        public boolean isReady() {
            return true;
        }

        @Override
        public void setWriteListener(final WriteListener writeListener) {
        }

        @Override
        public void write(int b) throws IOException {
            size++;
        }

        @Override
        public String toString() {
            return "size: " + String.valueOf(size);
        }
    });
    dispatcherServlet.service(request, response);
    Assert.assertTrue(StringUtils.startsWith(response.getOutputStream().toString(), "size: "));
}