@Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { // Only set the status on the first call (the dispatch will trigger // another call to this Servlet) if (resp.getStatus() != HttpServletResponse.SC_BAD_REQUEST) { resp.setStatus(HttpServletResponse.SC_BAD_REQUEST); AsyncContext ac = req.startAsync(); ac.dispatch(); } }
public void service(HttpServletRequest request, HttpServletResponse response) { if (transport == null) { transport = CseContext.getInstance().getTransportManager().findTransport(Const.RESTFUL); } // 异步场景 final AsyncContext asyncCtx = request.startAsync(); asyncCtx.addListener(restAsyncListener); asyncCtx.setTimeout(ServletConfig.getServerTimeout()); HttpServletRequestEx requestEx = new StandardHttpServletRequestEx(request); HttpServletResponseEx responseEx = new StandardHttpServletResponseEx(response); RestServletProducerInvocation restProducerInvocation = new RestServletProducerInvocation(); restProducerInvocation.invoke(transport, requestEx, responseEx, httpServerFilters); }
@Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { track("doGet-"); AsyncContext ctx = req.startAsync(); ctx.setTimeout(3000); ctx.addListener(new TrackingListener(true, false, "/async")); String loopsParam = req.getParameter("loops"); Integer loopsAttr = (Integer) req.getAttribute("loops"); int loops = 0; if (loopsAttr != null) { loops = loopsAttr.intValue(); } else if (loopsParam != null) { loops = Integer.parseInt(loopsParam); } if (loops > 1) { loops--; req.setAttribute("loops", Integer.valueOf(loops)); ctx.dispatch(); } else throw new ServletException(); }
protected void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html;charset=UTF-8"); try (PrintWriter output = response.getWriter()) { output.println("<html>"); output.println("<head>"); output.println("<title>Reading asynchronously</title>"); output.println("</head>"); output.println("<body>"); output.println("<h1>Reading asynchronously</h1>"); AsyncContext context = request.startAsync(); ServletInputStream input = request.getInputStream(); input.setReadListener(new ReadingListener(input, context)); output.println("</body>"); output.println("</html>"); } }
@Override protected void doGet(HttpServletRequest req, final HttpServletResponse resp) throws ServletException, IOException { final AsyncContext ctx = req.startAsync(); ctx.start(new Runnable() { @Override public void run() { try { Thread.sleep(THREAD_SLEEP_TIME); resp.setHeader("A", "xyz"); resp.setContentType("text/plain"); resp.setContentLength("OK".getBytes().length); resp.getWriter().print("OK"); ctx.complete(); } catch (Exception e) { e.printStackTrace(); } } }); }
@Override protected void onProxyResponseFailure(final HttpServletRequest clientRequest, final HttpServletResponse proxyResponse, final Response serverResponse, final Throwable failure) { _log.warn(failure.toString()); if (proxyResponse.isCommitted()) { // Parent behavior super.onProxyResponseFailure(clientRequest, proxyResponse, serverResponse, failure); } else { proxyResponse.resetBuffer(); if (failure instanceof TimeoutException) { proxyResponse.setStatus(HttpServletResponse.SC_GATEWAY_TIMEOUT); } else { // Unavailable business server as JSON response proxyResponse.setStatus(HttpServletResponse.SC_SERVICE_UNAVAILABLE); proxyResponse.setContentType("application/json"); try { proxyResponse.getOutputStream().write("{\"code\":\"business-down\"}".getBytes(StandardCharsets.UTF_8)); } catch (final IOException ioe) { _log.warn("Broken proxy stream", ioe); } } proxyResponse.setHeader(HttpHeader.CONNECTION.asString(), HttpHeaderValue.CLOSE.asString()); final AsyncContext asyncContext = clientRequest.getAsyncContext(); asyncContext.complete(); } }
public static void main(String[] args) { Javalin app = Javalin.create().port(5454).start(); app.get("/test-custom", ctx -> { AsyncContext asyncContext = ctx.request().startAsync(); simulateAsyncTask(() -> { ctx.status(418); asyncContext.complete(); }); }); app.get("/test-async", ctx -> ctx.async(() -> { CompletableFuture<Void> future = new CompletableFuture<>(); simulateAsyncTask(() -> { ctx.status(418); future.complete(null); }); return future; })); }
@Override protected void doGet(final HttpServletRequest req, final HttpServletResponse resp) throws ServletException, IOException { final AsyncContext async = req.startAsync(); // Just for debugging async.setTimeout(100000); ExecutorService executor = Executors.newSingleThreadExecutor(); executor.submit(new Runnable() { @Override public void run() { async.dispatch("/ServletC"); } }); executor.shutdown(); }
@Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { TestAsyncContextImpl.track("AsyncErrorPageGet-"); final AsyncContext ctxt = req.getAsyncContext(); switch(mode) { case COMPLETE: TestAsyncContextImpl.track("Complete-"); ctxt.complete(); break; case DISPATCH: TestAsyncContextImpl.track("Dispatch-"); ctxt.dispatch("/error/nonasync"); break; case NO_COMPLETE: TestAsyncContextImpl.track("NoOp-"); break; default: // Impossible break; } }
@Override protected void doPut(HttpServletRequest req, final HttpServletResponse resp) throws ServletException, IOException { final AsyncContext ac = req.startAsync(); ac.start(new Runnable() { @Override public void run() { resp.setContentType("text/plain"); resp.setCharacterEncoding("UTF-8"); try { resp.getWriter().print("OK"); } catch (IOException e) { // Should never happen. Test will fail if it does. } ac.complete(); } }); }
/** * Method for stream initialization * @param clientUri - Client Uri * @param request - The servlet request object * @param response - The servlet Response Object */ private void init(String clientUri,HttpServletRequest request, HttpServletResponse response){ LOG.info("Response Stream Inititated"); try{ HttpSession session = request.getSession(); session.setMaxInactiveInterval(72*60*60); EventClient client = new EventClient(); client.connectToClient(clientUri); response.setHeader("Content-Type", "text/event-stream"); response.setHeader("Cache-Control", "no-cache, no-store"); response.setHeader("Connection", "keep-alive"); AsyncContext asyncContext = request.startAsync(request,response); asyncContext.setTimeout(72*60*60*1000); asyncContext.getResponse().setBufferSize(1200); try { asyncContext.getResponse().flushBuffer(); } catch (IOException e1) { ErrorLog.logError(e1.getMessage(),e1.getStackTrace()); } ServletContext servletContext = request.getServletContext(); Map<String,AsyncContext> responseStreams = (ConcurrentHashMap<String,AsyncContext>) servletContext.getAttribute("responseStreams"); responseStreams.put(clientUri,asyncContext); } catch (Exception e){ ErrorLog.logError(e.getMessage(),e.getStackTrace()); } }
@Override protected void doDispatch(final HttpServletRequest request, final HttpServletResponse response) throws Exception { final AsyncContext ac = request.startAsync(request, response); ac.setTimeout(TIME_OUT); // FIXME: convert to Lambda FutureTask task = new FutureTask(new Runnable() { @Override public void run() { try { logger.debug("Dispatching request " + request); AsyncDispatcherServlet.super.doDispatch(request, response); logger.debug("doDispatch returned from processing request " + request); ac.complete(); } catch (Exception ex) { logger.error("Error in async request", ex); } } }, null); ac.addListener(new AsyncDispatcherServletListener(task)); exececutor.execute(task); }
@Test public void testAsyncServletRequestHasListenerAdded() throws IOException, ServletException { AWSXRayServletFilter servletFilter = new AWSXRayServletFilter("test"); AsyncContext asyncContext = Mockito.mock(AsyncContext.class); HttpServletRequest request = Mockito.mock(HttpServletRequest.class); Mockito.when(request.getRequestURL()).thenReturn(new StringBuffer("test_url")); Mockito.when(request.getMethod()).thenReturn("TEST_METHOD"); Mockito.when(request.isAsyncStarted()).thenReturn(true); Mockito.when(request.getAsyncContext()).thenReturn(asyncContext); HttpServletResponse response = Mockito.mock(HttpServletResponse.class); FilterChain chain = Mockito.mock(FilterChain.class); servletFilter.doFilter(request, response, chain); Mockito.verify(asyncContext, Mockito.times(1)).addListener(Mockito.any()); }
@Override protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { final AsyncContext asyncContext = request.startAsync(request, response); asyncContext.addListener(new TrackingListener(false, false, null)); asyncContext.start(new Runnable() { @Override public void run() { try { Thread.sleep(THREAD_SLEEP_TIME); TestAsyncContextImpl.track("Runnable-"); asyncContext.complete(); } catch (Exception e) { e.printStackTrace(); } } }); }
public void writeStock(AsyncContext actx, Stock stock) { HttpServletResponse response = (HttpServletResponse)actx.getResponse(); try { PrintWriter writer = response.getWriter(); writer.write("STOCK#");//make client parsing easier writer.write(stock.getSymbol()); writer.write("#"); writer.write(stock.getValueAsString()); writer.write("#"); writer.write(stock.getLastChangeAsString()); writer.write("#"); writer.write(String.valueOf(stock.getCnt())); writer.write("\n"); writer.flush(); response.flushBuffer(); }catch (IOException x) { try {actx.complete();}catch (Exception ignore){/* Ignore */} } }
@Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { req.getParameter(PARAM_NAME); AsyncContext actxt = req.startAsync(); actxt.addListener(new Bug54178AsyncListener()); actxt.complete(); }
@Override public void service(ServletRequest req, ServletResponse resp) throws ServletException, IOException { if (DispatcherType.ASYNC != req.getDispatcherType()) { AsyncContext asyncContext; if ("y".equals(req.getParameter(CUSTOM_REQ_RESP))) { asyncContext = req.startAsync( new ServletRequestWrapper(req), new ServletResponseWrapper(resp)); } else { asyncContext = req.startAsync(); } if ("y".equals(req.getParameter(EMPTY_DISPATCH))) { asyncContext.dispatch(); } else { asyncContext.dispatch("/target"); } try { asyncContext.dispatch("/nonExistingServlet"); TestAsyncContextImpl.track("FAIL"); } catch (IllegalStateException e) { TestAsyncContextImpl.track("OK"); } } else { TestAsyncContextImpl.track("DispatchingGenericServletGet-"); } }
@Test public void testGetAsyncContext() { AsyncContext asyncContext = Deencapsulation.getField(VertxServerRequestToHttpServletRequest.class, "EMPTY_ASYNC_CONTEXT"); Assert.assertSame(asyncContext, request.getAsyncContext()); }
@Override protected void doGet(final HttpServletRequest req, final HttpServletResponse resp) throws ServletException, IOException { String echo = req.getParameter("echo"); AsyncContext actxt = req.startAsync(); TestAsyncContextImpl.track("OK"); if (echo != null) { TestAsyncContextImpl.track("-" + echo); } // Speed up the test by reducing the timeout actxt.setTimeout(ASYNC_TIMEOUT); }
public static void compelete(AsyncContext asyncContext) { try { asyncContext.complete(); } catch (Exception e) { LOGGER.error("unexpect error", e); } }
@Override public AsyncContext getAsyncContext() { if (!isAsyncStarted()) { throw new IllegalStateException(sm.getString("request.notAsync")); } return asyncContext; }
@Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { if ("y".equals(req.getParameter(DISPATCH_CHECK))) { if (req.getDispatcherType() != DispatcherType.ASYNC) { track("WrongDispatcherType-"); } } track("DispatchingServletGet-"); final int iter = Integer.parseInt(req.getParameter(ITER_PARAM)) - 1; final AsyncContext ctxt = req.startAsync(); if (addTrackingListener) { TrackingListener listener = new TrackingListener(completeOnError, true, null); ctxt.addListener(listener); } Runnable run = new Runnable() { @Override public void run() { if (iter > 0) { ctxt.dispatch("/stage1?" + ITER_PARAM + "=" + iter + "&" + DISPATCH_CHECK + "=y"); } else { ctxt.dispatch("/stage2"); } } }; if ("y".equals(req.getParameter("useThread"))) { new Thread(run).start(); } else { run.run(); } }
@Test public void onProxyResponseFailureCommitted() throws IOException, ServletException { init(); final HttpServletResponse response = Mockito.mock(HttpServletResponse.class); final ServletOutputStream os = Mockito.mock(ServletOutputStream.class); Mockito.doThrow(new IOException()).when(os).write(ArgumentMatchers.any(byte[].class)); Mockito.when(response.getOutputStream()).thenReturn(os); Mockito.when(response.isCommitted()).thenReturn(true); final HttpServletRequest request = Mockito.mock(HttpServletRequest.class); final AsyncContext asyncContext = Mockito.mock(AsyncContext.class); Mockito.when(request.getAsyncContext()).thenReturn(asyncContext); servlet.onProxyResponseFailure(request, response, null, new Exception()); }
public void contextInitialized(ServletContextEvent sce) { Map<String, AsyncContext> notificationStreams = new ConcurrentHashMap<String, AsyncContext>(); sce.getServletContext().setAttribute("notificationStreams", notificationStreams); Thread thread = new Thread(new Runnable(){ @Override public void run() { String clientId = null; AsyncContext asyncContext = null; while(true) { try { Map.Entry<String, String> entry = blockingQueue.take(); clientId = entry.getKey(); asyncContext = notificationStreams.get(clientId); if(notificationStreams.get(entry.getKey()) != null){ ServletOutputStream out = asyncContext.getResponse().getOutputStream(); out.write(entry.getValue().getBytes()); out.flush(); asyncContext.getResponse().flushBuffer(); } } catch (Exception e){ ErrorLog.logError("Cannot write to client", e.getStackTrace()); asyncContext.complete(); notificationStreams.remove(clientId); break; } } } }); thread.start(); }
public void addTask(RequestInfo requestInfo, AsyncContext asyncContext) { int serviceType = requestInfo.getInterfaceInfo().getServiceType(); if (serviceType == InterfaceInfo.SERVICE_TYPE_HTTP) { executor.execute(new HttpTaskProcessor(requestInfo, asyncContext)); } else if (serviceType == InterfaceInfo.SERVICE_TYPE_SPRING) { executor.execute(new DubboTaskProcessor(requestInfo, asyncContext)); } }
@Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { AsyncContext actxt = req.startAsync(); resp.setStatus(status); actxt.complete(); }
@Test public void onProxyResponseFailureTimeout() throws IOException, ServletException { init(); final HttpServletResponse response = Mockito.mock(HttpServletResponse.class); final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); Mockito.when(response.getOutputStream()).thenReturn(new DelegatingServletOutputStream(byteArrayOutputStream)); final HttpServletRequest request = Mockito.mock(HttpServletRequest.class); final AsyncContext asyncContext = Mockito.mock(AsyncContext.class); Mockito.when(request.getAsyncContext()).thenReturn(asyncContext); servlet.onProxyResponseFailure(request, response, null, new TimeoutException()); Mockito.verify(response).setStatus(HttpServletResponse.SC_GATEWAY_TIMEOUT); }
@Test public void onProxyResponseFailure() throws IOException, ServletException { init(); final HttpServletResponse response = Mockito.mock(HttpServletResponse.class); final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); Mockito.when(response.getOutputStream()).thenReturn(new DelegatingServletOutputStream(byteArrayOutputStream)); final HttpServletRequest request = Mockito.mock(HttpServletRequest.class); final AsyncContext asyncContext = Mockito.mock(AsyncContext.class); Mockito.when(request.getAsyncContext()).thenReturn(asyncContext); servlet.onProxyResponseFailure(request, response, null, new Exception()); Mockito.verify(response).setStatus(HttpServletResponse.SC_SERVICE_UNAVAILABLE); Assert.assertEquals("{\"code\":\"business-down\"}", byteArrayOutputStream.toString(StandardCharsets.UTF_8.name())); }
@Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { Integer countObj = (Integer) req.getAttribute("count"); int count = 0; if (countObj != null) { count = countObj.intValue(); } count++; req.setAttribute("count", Integer.valueOf(count)); String encodedUri = req.getRequestURI(); UDecoder uDecoder = new UDecoder(); String decodedUri = uDecoder.convert(encodedUri, false); try { // Just here to trigger the error @SuppressWarnings("unused") URI u = new URI(encodedUri); } catch (URISyntaxException e) { throw new ServletException(e); } if (count > 3) { resp.setContentType("text/plain"); resp.getWriter().print("OK"); } else { AsyncContext ac = req.startAsync(); ac.dispatch(decodedUri); } }
@Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { if (bug55772IsSecondRequest) { Cookie[] cookies = req.getCookies(); if (cookies != null && cookies.length > 0) { for (Cookie cookie : req.getCookies()) { if (cookie.getName().equalsIgnoreCase("something.that.should.not.leak")) { bug55772RequestStateLeaked = true; } } } bug55772Latch3.countDown(); } else { req.getCookies(); // We have to do this so Tomcat will actually parse the cookies from the request } req.setAttribute("org.apache.catalina.ASYNC_SUPPORTED", Boolean.TRUE); AsyncContext asyncContext = req.startAsync(); asyncContext.setTimeout(5000); bug55772Latch1.countDown(); PrintWriter writer = asyncContext.getResponse().getWriter(); writer.print('\n'); writer.flush(); bug55772Latch2.countDown(); }
@Override public AsyncContext startAsync(ServletRequest servletRequest, ServletResponse servletResponse) throws IllegalStateException { this.asyncStarted = true; this.asyncContext = new AsyncContextImpl(servletRequest, servletResponse); return null; }
@Test public void testAWSXRayServletAsyncListenerEmitsSegmentWhenProcessingEvent() throws IOException, ServletException { AWSXRayServletFilter servletFilter = new AWSXRayServletFilter("test"); AsyncContext asyncContext = Mockito.mock(AsyncContext.class); HttpServletRequest request = Mockito.mock(HttpServletRequest.class); Mockito.when(request.getRequestURL()).thenReturn(new StringBuffer("test_url")); Mockito.when(request.getMethod()).thenReturn("TEST_METHOD"); Mockito.when(request.isAsyncStarted()).thenReturn(true); Mockito.when(request.getAsyncContext()).thenReturn(asyncContext); HttpServletResponse response = Mockito.mock(HttpServletResponse.class); FilterChain chain = Mockito.mock(FilterChain.class); AsyncEvent event = Mockito.mock(AsyncEvent.class); Mockito.when(event.getSuppliedRequest()).thenReturn(request); Mockito.when(event.getSuppliedResponse()).thenReturn(response); servletFilter.doFilter(request, response, chain); Entity currentEntity = AWSXRay.getTraceEntity(); Mockito.when(request.getAttribute("com.amazonaws.xray.entities.Entity")).thenReturn(currentEntity); AWSXRayServletAsyncListener listener = (AWSXRayServletAsyncListener) Whitebox.getInternalState(servletFilter, "listener"); listener.onComplete(event); Mockito.verify(AWSXRay.getGlobalRecorder().getEmitter(), Mockito.times(1)).sendSegment(Mockito.any()); }
@Override public AsyncContext startAsync() throws IllegalStateException { if (!isAsyncSupported()) { throw UndertowServletMessages.MESSAGES.startAsyncNotAllowed(); } else if (asyncStarted) { throw UndertowServletMessages.MESSAGES.asyncAlreadyStarted(); } asyncStarted = true; final ServletRequestContext servletRequestContext = exchange.getAttachment(ServletRequestContext.ATTACHMENT_KEY); return asyncContext = new AsyncContextImpl(exchange, servletRequestContext.getServletRequest(), servletRequestContext.getServletResponse(), servletRequestContext, false, asyncContext); }
