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

Example 16 with AsyncListener

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

the class OnCompleteServlet method doGet.

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    final AsyncContext ctx = req.startAsync();
    ctx.addListener(new AsyncListener() {

        @Override
        public void onComplete(AsyncEvent event) throws IOException {
            QUEUE.add("onComplete");
        }

        @Override
        public void onTimeout(AsyncEvent event) throws IOException {
            QUEUE.add("onTimeout");
        }

        @Override
        public void onError(AsyncEvent event) throws IOException {
            QUEUE.add("onError");
        }

        @Override
        public void onStartAsync(AsyncEvent event) throws IOException {
            QUEUE.add("onStartAsync");
        }
    });
    Thread thread = new Thread(new Runnable() {

        @Override
        public void run() {
            ctx.dispatch("/message");
        }
    });
    thread.start();
}

Example 17 with AsyncListener

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

the class CompleteAsyncServlet method doGet.

@Override
protected void doGet(final HttpServletRequest req, final HttpServletResponse resp) throws ServletException, IOException {
    req.startAsync();
    req.getAsyncContext().addListener(new AsyncListener() {

        @Override
        public void onComplete(AsyncEvent event) throws IOException {
            TestListener.addMessage("onComplete");
        }

        @Override
        public void onTimeout(AsyncEvent event) throws IOException {
        }

        @Override
        public void onError(AsyncEvent event) throws IOException {
        }

        @Override
        public void onStartAsync(AsyncEvent event) throws IOException {
            TestListener.addMessage("onStartAsync");
        }
    });
    req.getAsyncContext().complete();
    resp.getWriter().write("asynccomplete");
}

Example 18 with AsyncListener

use of javax.servlet.AsyncListener in project tomee by apache.

the class OpenEJBAsyncContext method onError.

private void onError(final Throwable ignored) {
    for (final AsyncListener listener : listeners) {
        try {
            listener.onError(event);
        } catch (final IOException t) {
            throw new OpenEJBRuntimeException(t);
        }
    }
    try {
        HttpServletResponse.class.cast(response).sendError(HttpURLConnection.HTTP_INTERNAL_ERROR);
        commit();
    } catch (final IOException e) {
    // no-op
    }
}

Example 19 with AsyncListener

use of javax.servlet.AsyncListener in project tomee by apache.

the class OpenEJBAsyncContext method destroy.

public static void destroy() {
    if (es == null) {
        return;
    }
    es.shutdownNow();
    for (final OpenEJBAsyncContext ctx : new ArrayList<>(INITIALIZED)) {
        if (ctx.lastTouch + ctx.getTimeout() < System.currentTimeMillis()) {
            for (final AsyncListener listener : ctx.listeners) {
                try {
                    listener.onTimeout(ctx.event);
                } catch (final IOException t) {
                    throw new OpenEJBRuntimeException(t);
                }
            }
            ctx.complete();
        }
    }
    INITIALIZED.clear();
}

Example 20 with AsyncListener

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

the class AbstractAsyncR2Servlet method service.

@Override
public void service(final HttpServletRequest req, final HttpServletResponse resp) throws ServletException, IOException {
    RequestContext requestContext = ServletHelper.readRequestContext(req);
    RestRequest restRequest;
    try {
        restRequest = readFromServletRequest(req);
    } catch (URISyntaxException e) {
        writeToServletError(resp, RestStatus.BAD_REQUEST, e.toString());
        return;
    }
    final AsyncContext ctx = req.startAsync(req, resp);
    ctx.setTimeout(_timeout);
    ctx.addListener(new AsyncListener() {

        @Override
        public void onTimeout(AsyncEvent event) throws IOException {
            AsyncContext ctx = event.getAsyncContext();
            writeToServletError((HttpServletResponse) ctx.getResponse(), RestStatus.INTERNAL_SERVER_ERROR, "Server Timeout");
            ctx.complete();
        }

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

        @Override
        public void onError(AsyncEvent event) throws IOException {
            writeToServletError((HttpServletResponse) event.getSuppliedResponse(), RestStatus.INTERNAL_SERVER_ERROR, "Server Error");
            ctx.complete();
        }

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

        @Override
        public void onResponse(final TransportResponse<RestResponse> response) {
            // TransportCallback is usually invoked by non-servlet threads; hence we cannot assume that it's ok to
            // do blocking IO there. As a result, we should use AsyncContext.start() to do blocking IO using the
            // container/servlet threads. This still maintains the advantage of Async, meaning servlet thread is not
            // blocking-wait when the response is not ready.
            ctx.start(new Runnable() {

                @Override
                public void run() {
                    try {
                        writeToServletResponse(response, (HttpServletResponse) ctx.getResponse());
                    } catch (IOException e) {
                        req.setAttribute(TRANSPORT_CALLBACK_IOEXCEPTION, e);
                    } finally {
                        ctx.complete();
                    }
                }
            });
        }
    };
    getDispatcher().handleRequest(restRequest, requestContext, callback);
}