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

Example 36 with AsyncEvent

use of javax.servlet.AsyncEvent in project rest.li by linkedin.

the class AbstractAsyncR2StreamServlet method service.

@Override
public void service(final HttpServletRequest req, final HttpServletResponse resp) throws ServletException, IOException {
    final AsyncContext ctx = req.startAsync(req, resp);
    ctx.setTimeout(_timeout);
    final WrappedAsyncContext wrappedCtx = new WrappedAsyncContext(ctx);
    final AsyncEventIOHandler ioHandler = new AsyncEventIOHandler(req.getInputStream(), resp.getOutputStream(), wrappedCtx, MAX_BUFFERED_CHUNKS);
    final RequestContext requestContext = ServletHelper.readRequestContext(req);
    final StreamRequest streamRequest;
    try {
        streamRequest = ServletHelper.readFromServletRequest(req, ioHandler);
    } catch (URISyntaxException e) {
        ServletHelper.writeToServletError(resp, RestStatus.BAD_REQUEST, e.toString());
        wrappedCtx.complete();
        return;
    }
    final AtomicBoolean startedResponding = new AtomicBoolean(false);
    ctx.addListener(new AsyncListener() {

        @Override
        public void onTimeout(AsyncEvent event) throws IOException {
            LOG.error("Server timeout for request: " + formatURI(req.getRequestURI()));
            if (startedResponding.compareAndSet(false, true)) {
                LOG.info("Returning server timeout response");
                ServletHelper.writeToServletError(resp, RestStatus.INTERNAL_SERVER_ERROR, "Server timeout");
            } else {
                req.setAttribute(ASYNC_IOEXCEPTION, new ServletException("Server timeout"));
            }
            ioHandler.exitLoop();
            wrappedCtx.complete();
        }

        @Override
        public void onStartAsync(AsyncEvent event) throws IOException {
        // Nothing to do here
        }

        @Override
        public void onError(AsyncEvent event) throws IOException {
            LOG.error("Server error for request: " + formatURI(req.getRequestURI()));
            if (startedResponding.compareAndSet(false, true)) {
                LOG.info("Returning server error response");
                ServletHelper.writeToServletError(resp, RestStatus.INTERNAL_SERVER_ERROR, "Server error");
            } else {
                req.setAttribute(ASYNC_IOEXCEPTION, new ServletException("Server error"));
            }
            ioHandler.exitLoop();
            wrappedCtx.complete();
        }

        @Override
        public void onComplete(AsyncEvent event) throws IOException {
            Object exception = req.getAttribute(ASYNC_IOEXCEPTION);
            if (exception != null) {
                throw new IOException((Throwable) exception);
            }
        }
    });
    final TransportCallback<StreamResponse> callback = new TransportCallback<StreamResponse>() {

        @Override
        public void onResponse(final TransportResponse<StreamResponse> response) {
            if (startedResponding.compareAndSet(false, true)) {
                ctx.start(new Runnable() {

                    @Override
                    public void run() {
                        try {
                            StreamResponse streamResponse = ServletHelper.writeResponseHeadersToServletResponse(response, resp);
                            streamResponse.getEntityStream().setReader(ioHandler);
                            ioHandler.loop();
                        } catch (Exception e) {
                            req.setAttribute(ASYNC_IOEXCEPTION, e);
                            wrappedCtx.complete();
                        }
                    }
                });
            } else {
                LOG.error("Dropped a response; this is mostly like because that AsyncContext timeout or error had already happened");
            }
        }
    };
    // we have to use a new thread and let this thread return to pool. otherwise the timeout won't start
    ctx.start(new Runnable() {

        @Override
        public void run() {
            try {
                getDispatcher().handleRequest(streamRequest, requestContext, callback);
                ioHandler.loop();
            } catch (Exception e) {
                req.setAttribute(ASYNC_IOEXCEPTION, e);
                wrappedCtx.complete();
            }
        }
    });
}

Example 37 with AsyncEvent

use of javax.servlet.AsyncEvent in project spring-framework by spring-projects.

the class StandardServletAsyncWebRequestTests method startAsyncAfterCompleted.

@Test
public void startAsyncAfterCompleted() throws Exception {
    this.asyncRequest.onComplete(new AsyncEvent(new MockAsyncContext(this.request, this.response)));
    try {
        this.asyncRequest.startAsync();
        fail("expected exception");
    } catch (IllegalStateException ex) {
        assertEquals("Async processing has already completed", ex.getMessage());
    }
}

Example 38 with AsyncEvent

use of javax.servlet.AsyncEvent in project undertow by undertow-io.

the class AsyncContextImpl method onAsyncError.

private void onAsyncError(final Throwable t) {
    final boolean setupRequired = SecurityActions.currentServletRequestContext() == null;
    servletRequestContext.getCurrentServletContext().invokeRunnable(servletRequestContext.getExchange(), new Runnable() {

        @Override
        public void run() {
            setupRequestContext(setupRequired);
            try {
                for (final BoundAsyncListener listener : asyncListeners) {
                    AsyncEvent event = new AsyncEvent(AsyncContextImpl.this, listener.servletRequest, listener.servletResponse, t);
                    try {
                        listener.asyncListener.onError(event);
                    } catch (IOException e) {
                        UndertowServletLogger.REQUEST_LOGGER.ioExceptionDispatchingAsyncEvent(e);
                    }
                }
            } finally {
                tearDownRequestContext(setupRequired);
            }
        }
    });
}

Example 39 with AsyncEvent

use of javax.servlet.AsyncEvent in project java-chassis by ServiceComb.

the class TestRestAsyncListener method testOnTimeout.

@Test
public void testOnTimeout() throws IOException {
    boolean status = true;
    try {
        RestAsyncListener restasynclistener = new RestAsyncListener();
        AsyncEvent event = Mockito.mock(AsyncEvent.class);
        AsyncContext asynccontext = Mockito.mock(AsyncContext.class);
        Mockito.when(event.getAsyncContext()).thenReturn(asynccontext);
        ServletResponse response = Mockito.mock(ServletResponse.class);
        Mockito.when(asynccontext.getResponse()).thenReturn(response);
        PrintWriter out = Mockito.mock(PrintWriter.class);
        Mockito.when(response.getWriter()).thenReturn(out);
        restasynclistener.onTimeout(event);
        restasynclistener.onComplete(event);
        restasynclistener.onError(event);
        restasynclistener.onStartAsync(event);
        Assert.assertNotNull(restasynclistener);
    } catch (Exception e) {
        status = false;
        Assert.assertNotNull(e);
    }
    Assert.assertTrue(status);
}