@Override boolean isAsync(HttpServletRequest request) { return request.isAsyncStarted(); }
@Override public boolean isStarted() { return (this.asyncContext != null && this.request.getServletRequest().isAsyncStarted()); }
@Override public boolean isAsyncStarted() { return (this.asyncContext != null && getRequest().isAsyncStarted()); }
private static void assertAsyncStarted(HttpServletRequest request) { assertEquals("Async started", true, request.isAsyncStarted()); }
/** * Assert that asynchronous processing was not started. * @see #asyncStarted() */ public ResultMatcher asyncNotStarted() { return result -> { HttpServletRequest request = result.getRequest(); assertEquals("Async started", false, request.isAsyncStarted()); }; }
@Override public boolean isAsyncStarted() { return (this.asyncContext != null && getRequest().isAsyncStarted()); }
@Override public boolean isStarted() { return (this.asyncContext != null && this.request.getServletRequest().isAsyncStarted()); }
@Override public boolean isAsyncStarted() { if (AtmosphereResource.TRANSPORT.WEBSOCKET == resource().transport()) { return noopsAsyncContextStarted; } try { return b.request.isAsyncStarted(); } catch (Throwable ex) { logger.trace("", ex); return false; } }
protected void printAsyncResult(MvcResult result) throws Exception { HttpServletRequest request = result.getRequest(); this.printer.printValue("Async started", request.isAsyncStarted()); Object asyncResult = null; try { asyncResult = result.getAsyncResult(0); } catch (IllegalStateException ex) { // Not set } this.printer.printValue("Async result", asyncResult); }
private void startAsyncIfNeedIt() { HttpServletRequest req = nreq.servletRequest(); if (!req.isAsyncStarted()) { req.startAsync(); } } }
@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 void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException { ErrorWrapperResponse wrapped = new ErrorWrapperResponse(response); try { chain.doFilter(request, wrapped); if (wrapped.hasErrorToSend()) { handleErrorStatus(request, response, wrapped.getStatus(), wrapped.getMessage()); response.flushBuffer(); } else if (!request.isAsyncStarted() && !response.isCommitted()) { response.flushBuffer(); } } catch (Throwable ex) { Throwable exceptionToHandle = ex; if (ex instanceof NestedServletException) { exceptionToHandle = ((NestedServletException) ex).getRootCause(); } handleException(request, response, wrapped, exceptionToHandle); response.flushBuffer(); } }
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; }
CounterError.bindRequest(httpRequest); chain.doFilter(wrappedRequest, wrappedResponse); if (servletApi2 || !httpRequest.isAsyncStarted()) { wrappedResponse.flushBuffer();
@Override public boolean isAsyncStarted() { return getRequest().isAsyncStarted(); }
@Override public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { if (!request.isAsyncStarted()) { stopLongTaskTimers(LongTaskTimingContext.get(request)); } }
private void filterAndRecordMetrics(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws IOException, ServletException { TimingContext timingContext = TimingContext.get(request); if (timingContext == null) { timingContext = startAndAttachTimingContext(request); } try { filterChain.doFilter(request, response); if (!request.isAsyncStarted()) { // Only record when async processing has finished or never been started. // If async was started by something further down the chain we wait // until the second filter invocation (but we'll be using the // TimingContext that was attached to the first) Throwable exception = (Throwable) request .getAttribute(DispatcherServlet.EXCEPTION_ATTRIBUTE); record(timingContext, response, request, exception); } } catch (NestedServletException ex) { response.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value()); record(timingContext, response, request, ex.getCause()); throw ex; } }
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) ); }
@Test public void testDoFilterSync() throws IOException, ServletException { OcHttpServletFilter filter = new OcHttpServletFilter(); when(mockRequest.isAsyncStarted()).thenReturn(false); when(mockResponse.getHeader("")).thenReturn(""); when(mockResponse.getHeader(CONTENT_LENGTH)).thenReturn("10"); when(mockRequest.getContentLength()).thenReturn(10); filter.doFilter(mockRequest, mockResponse, mockChain); verify(mockRequest).getContentLength(); }