@Override protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { registerAsyncResultInterceptors(request); super.service(request, response); if (request.getAsyncContext() != null) { MockAsyncContext asyncContext; if (request.getAsyncContext() instanceof MockAsyncContext) { asyncContext = (MockAsyncContext) request.getAsyncContext(); } else { MockHttpServletRequest mockRequest = WebUtils.getNativeRequest(request, MockHttpServletRequest.class); Assert.notNull(mockRequest, "Expected MockHttpServletRequest"); asyncContext = (MockAsyncContext) mockRequest.getAsyncContext(); Assert.notNull(asyncContext, () -> "Outer request wrapper " + request.getClass().getName() + " has an AsyncContext," + "but it is not a MockAsyncContext, while the nested " + mockRequest.getClass().getName() + " does not have an AsyncContext at all."); } CountDownLatch dispatchLatch = new CountDownLatch(1); asyncContext.addDispatchHandler(dispatchLatch::countDown); getMvcResult(request).setAsyncDispatchLatch(dispatchLatch); } }
@Override public void returnResultAsync(Result result, Context context) { resultHandler.handleResult(result, context); request.getAsyncContext().complete(); } }
@Override void handleAsync(HttpServerHandler<HttpServletRequest, HttpServletResponse> handler, HttpServletRequest request, HttpServletResponse response, Span span) { if (span.isNoop()) return; // don't add overhead when we aren't httpTracing TracingAsyncListener listener = new TracingAsyncListener(handler, span); request.getAsyncContext().addListener(listener, request, response); }
@Override public void end() { if (!committed) { if (req.isAsyncStarted()) { AsyncContext ctx = req.getAsyncContext(); ctx.complete(); } else { close(); } committed = true; } }
private AsyncContext getAsyncContext() { final AsyncContext asyncContext; if (request.isAsyncStarted()) { asyncContext = request.getAsyncContext(); try { asyncContext.setTimeout(NEVER_TIMEOUT_VALUE); } catch (IllegalStateException ex) { // Let's hope the time out is set properly, otherwise JAX-RS AsyncResponse time-out support // may not work as expected... At least we can log this at fine level... LOGGER.log(Level.FINE, LocalizationMessages.SERVLET_ASYNC_CONTEXT_ALREADY_STARTED(), ex); } } else { asyncContext = request.startAsync(request, response); // Tell underlying asyncContext to never time out. asyncContext.setTimeout(NEVER_TIMEOUT_VALUE); } return asyncContext; }
private AsyncContext getAsyncContext() { final AsyncContext asyncContext; if (request.isAsyncStarted()) { asyncContext = request.getAsyncContext(); try { asyncContext.setTimeout(NEVER_TIMEOUT_VALUE); } catch (IllegalStateException ex) { // Let's hope the time out is set properly, otherwise JAX-RS AsyncResponse time-out support // may not work as expected... At least we can log this at fine level... LOGGER.log(Level.FINE, LocalizationMessages.SERVLET_ASYNC_CONTEXT_ALREADY_STARTED(), ex); } } else { asyncContext = request.startAsync(request, response); // Tell underlying asyncContext to never time out. asyncContext.setTimeout(NEVER_TIMEOUT_VALUE); } return asyncContext; }
public void inject(final ActionRequest actionRequest, final Targets targets) { final HttpServletRequest servletRequest = actionRequest.getHttpServletRequest(); final HttpServletResponse servletResponse = actionRequest.getHttpServletResponse(); targets.forEachTargetAndIn(madvocScope, (target, in) -> { final Class inType = in.type(); Object value = null; if (inType == HttpServletRequest.class) { value = servletRequest; } else if (inType == ServletRequest.class) { value = servletRequest; } else if (inType == HttpServletResponse.class) { value = servletResponse; } else if (inType == ServletResponse.class) { value = servletResponse; } else if (inType == HttpSession.class) { value = servletRequest.getSession(); } else if (inType == ServletContext.class) { value = servletRequest.getServletContext(); } else if (inType == AsyncContext.class) { value = servletRequest.getAsyncContext(); } else if (inType == ActionRequest.class) { value = actionRequest; } if (value != null) { target.writeValue(in, value, true); } }); }
@Override public AsyncContext getAsyncContext() { AsyncContext ac; if (AtmosphereResource.TRANSPORT.WEBSOCKET == resource().transport()) { noopsAsyncContextStarted = true; ac = new NoOpsAsyncContext(getRequest(), resource().getResponse().getResponse()); } else { ac = b.request.getAsyncContext(); } return isCompletionAware() ? new CompletionAwareAsyncContext(ac, (CompletionAware)resource().getResponse()) : ac; }
@Override public AsyncContext getAsyncContext() { return getRequest().getAsyncContext(); }
/** * Returns the async context for this request. * * @return the async context for this request. */ @Override public AsyncContext getAsyncContext() { return delegate.getAsyncContext(); }
@Override public AsyncContext getAsyncContext() { return request.getAsyncContext(); }
protected AsyncContext getAsyncContext(HttpServletRequest request) { try { return request.getAsyncContext(); } catch (Throwable x) { if (_logger.isDebugEnabled()) { _logger.debug("Could not retrieve AsyncContext for " + request, x); } return null; } }
httpServletRequest.getAsyncContext().complete();
@Override public AsyncContext getAsyncContext() { return get().getAsyncContext(); }
/** * Returns the async context for the request * * @since Servlet 3.0 */ public AsyncContext getAsyncContext() { return getRequest().getAsyncContext(); }
private void setupAsyncContextWorkflow() { listenerCapturingAsyncContext = mock(AsyncContext.class); capturedAsyncListeners = new ArrayList<>(); doReturn(listenerCapturingAsyncContext).when(requestMock).getAsyncContext(); doReturn(true).when(requestMock).isAsyncStarted(); doAnswer(invocation -> { capturedAsyncListeners.add((AsyncListener) invocation.getArguments()[0]); return null; }).when(listenerCapturingAsyncContext).addListener( any(AsyncListener.class), any(ServletRequest.class), any(ServletResponse.class) ); }
/** * 开启异步 * * @return */ private AsyncContext startAsync() { HttpServletRequest request = (HttpServletRequest) get(FrameworkServlet.REQUEST); HttpServletResponse response = (HttpServletResponse) get(FrameworkServlet.RESPONSE); return request.isAsyncStarted() ? request.getAsyncContext() : request .startAsync(request, response); }
@Override public SseEventSink createContext(Message message) { final HttpServletRequest request = (HttpServletRequest)message.get(AbstractHTTPDestination.HTTP_REQUEST); if (request == null) { throw new IllegalStateException("Unable to retrieve HTTP request from the context"); } final MessageBodyWriter<OutboundSseEvent> writer = new OutboundSseEventBodyWriter( ServerProviderFactory.getInstance(message), message.getExchange()); final AsyncResponse async = new AsyncResponseImpl(message); return new SseEventSinkImpl(writer, async, request.getAsyncContext()); } }
protected void onProxyResponseSuccess(HttpServletRequest clientRequest, HttpServletResponse proxyResponse, Response serverResponse) { if (_log.isDebugEnabled()) _log.debug("{} proxying successful", getRequestId(clientRequest)); AsyncContext asyncContext = clientRequest.getAsyncContext(); asyncContext.complete(); }
@Override public SseEventSink createContext(Message message) { final HttpServletRequest request = (HttpServletRequest)message.get(AbstractHTTPDestination.HTTP_REQUEST); if (request == null) { throw new IllegalStateException("Unable to retrieve HTTP request from the context"); } final MessageBodyWriter<OutboundSseEvent> writer = new OutboundSseEventBodyWriter( ServerProviderFactory.getInstance(message), message.getExchange()); final AsyncResponse async = new AsyncResponseImpl(message); return new SseEventSinkImpl(writer, async, request.getAsyncContext()); } }