private void testHttpServerRequestDecodeError(Handler<NetSocket> bodySender, Handler<List<Throwable>> errorsChecker) throws Exception { AtomicReference<NetSocket> current = new AtomicReference<>(); server.requestHandler(req -> { List<Throwable> errors = new ArrayList<>(); Handler<Throwable> handler = err -> { errors.add(err); if (errors.size() == 2) { errorsChecker.handle(errors); testComplete(); } }; req.exceptionHandler(handler); bodySender.handle(current.get()); }); startServer(); NetClient client = vertx.createNetClient(); client.connect(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, onSuccess(so -> { current.set(so); so.write("POST /somepath HTTP/1.1\r\n"); so.write("Transfer-Encoding: chunked\r\n"); so.write("\r\n"); })); await(); }
@Test public void testHttpClientRequestTimeoutResetsTheConnection() throws Exception { waitFor(3); server.requestHandler(req -> { AtomicBoolean errored = new AtomicBoolean(); req.exceptionHandler(err -> { if (errored.compareAndSet(false, true)) { complete(); } }); }); startServer(); HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onFailure(err -> { complete(); })); AtomicBoolean errored = new AtomicBoolean(); req.exceptionHandler(err -> { if (errored.compareAndSet(false, true)) { complete(); } }); CountDownLatch latch = new CountDownLatch(1); req.setChunked(true).sendHead(version -> latch.countDown()); awaitLatch(latch); req.setTimeout(100); await(); }
@Override public HttpServerRequest exceptionHandler(Handler<Throwable> handler) { return delegate.exceptionHandler(handler); }
AtomicInteger respExceptionHandlerCount = new AtomicInteger(); AtomicInteger respEndHandlerCount = new AtomicInteger(); req.exceptionHandler(err -> { assertEquals(1, reqExceptionHandlerCount.incrementAndGet()); assertEquals(1, respExceptionHandlerCount.get());
}); AtomicBoolean errored = new AtomicBoolean(); req.exceptionHandler(err -> { if (errored.compareAndSet(false, true)) { assertEquals(err.getClass(), StreamResetException.class);
@Test public void testNoExceptionHandlerCalledWhenResponseEnded() throws Exception { server.requestHandler(req -> { HttpServerResponse resp = req.response(); req.exceptionHandler(this::fail); resp.exceptionHandler(err -> { err.printStackTrace(); }); resp.end(); }).listen(DEFAULT_HTTP_PORT, onSuccess(s -> { client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { resp.endHandler(v -> { vertx.setTimer(100, tid -> testComplete()); }); resp.exceptionHandler(t -> { fail("Should not be called"); }); })).exceptionHandler(t -> { fail("Should not be called"); }).end(); })); await(); }
@Test public void testClientResetServerStreamDuringResponse() throws Exception { server.requestHandler(req -> { req.exceptionHandler(err -> { assertEquals(err.getClass(), StreamResetException.class); }); AtomicLong reset = new AtomicLong(); req.response().exceptionHandler(err -> { if (err instanceof StreamResetException) { reset.set(((StreamResetException) err).getCode()); } }); req.response().closeHandler(v -> { assertEquals(10L, reset.get()); testComplete(); }); req.response().setChunked(true).write(Buffer.buffer("some-data")); }); startServer(); client.get(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", onSuccess(resp -> { resp.exceptionHandler(this::fail); resp.request().reset(10); assertIllegalStateException(() -> resp.request().write(Buffer.buffer())); assertIllegalStateException(resp.request()::end); })).end(Buffer.buffer("hello")); await(); }
server.requestHandler(req -> { HttpConnection conn = req.connection(); req.exceptionHandler(err -> { assertFalse(Thread.holdsLock(conn)); complete();
private void setupMetrics(final HttpServerRequest request) { request.exceptionHandler(event -> { if (debug) { exceptionCount++; } logger.info("EXCEPTION", event); }); request.endHandler(event -> { if (debug) { closeCount++; } logger.info("REQUEST OVER"); }); }
private void setupMetrics(final HttpServerRequest request) { request.exceptionHandler(event -> { if (debug) { exceptionCount++; } logger.info("EXCEPTION", event); }); request.endHandler(event -> { if (debug) { closeCount++; } logger.info("REQUEST OVER"); }); }
private void testHttpServerRequestDecodeError(Handler<NetSocket> bodySender, Handler<List<Throwable>> errorsChecker) throws Exception { AtomicReference<NetSocket> current = new AtomicReference<>(); server.requestHandler(req -> { List<Throwable> errors = new ArrayList<>(); Handler<Throwable> handler = err -> { errors.add(err); if (errors.size() == 2) { errorsChecker.handle(errors); testComplete(); } }; req.exceptionHandler(handler); bodySender.handle(current.get()); }); startServer(); NetClient client = vertx.createNetClient(); client.connect(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, onSuccess(so -> { current.set(so); so.write("POST /somepath HTTP/1.1\r\n"); so.write("Transfer-Encoding: chunked\r\n"); so.write("\r\n"); })); await(); }
context.request().exceptionHandler(t -> { deleteFileUploads(); context.fail(t);
@Test public void testHttpClientRequestTimeoutResetsTheConnection() throws Exception { waitFor(2); server.requestHandler(req -> { AtomicBoolean errored = new AtomicBoolean(); req.exceptionHandler(err -> { if (errored.compareAndSet(false, true)) { complete(); } }); }); startServer(); HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> fail("Response should not be handled")); req.exceptionHandler(err -> { complete(); }); CountDownLatch latch = new CountDownLatch(1); req.sendHead(version -> latch.countDown()); awaitLatch(latch); req.setTimeout(100); await(); }
}); context.request().exceptionHandler(t -> { deleteFileUploads(); context.fail(t);
AtomicInteger respExceptionHandlerCount = new AtomicInteger(); AtomicInteger respEndHandlerCount = new AtomicInteger(); req.exceptionHandler(err -> { assertEquals(1, reqExceptionHandlerCount.incrementAndGet()); assertEquals(1, respExceptionHandlerCount.get());
@Test public void testClientResetServerStreamDuringResponse() throws Exception { server.requestHandler(req -> { req.exceptionHandler(err -> { assertEquals(err.getClass(), StreamResetException.class); }); AtomicLong reset = new AtomicLong(); req.response().exceptionHandler(err -> { if (err instanceof StreamResetException) { reset.set(((StreamResetException) err).getCode()); } }); req.response().closeHandler(v -> { assertEquals(10L, reset.get()); testComplete(); }); req.response().setChunked(true).write(Buffer.buffer("some-data")); }); startServer(); HttpClientRequest req = client.get(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath"); req.handler(resp -> { resp.exceptionHandler(this::fail); req.reset(10); assertIllegalStateException(() -> req.write(Buffer.buffer())); assertIllegalStateException(req::end); }).end(Buffer.buffer("hello")); await(); }
}); AtomicBoolean errored = new AtomicBoolean(); req.exceptionHandler(err -> { if (errored.compareAndSet(false, true)) { assertEquals(err.getClass(), StreamResetException.class);
@Test public void testNoExceptionHandlerCalledWhenResponseEnded() throws Exception { server.requestHandler(req -> { HttpServerResponse resp = req.response(); req.exceptionHandler(this::fail); resp.exceptionHandler(err -> { err.printStackTrace(); }); resp.end(); }).listen(DEFAULT_HTTP_PORT, onSuccess(s -> { client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> { resp.endHandler(v -> { vertx.setTimer(100, tid -> testComplete()); }); resp.exceptionHandler(t -> { fail("Should not be called"); }); }).exceptionHandler(t -> { fail("Should not be called"); }).end(); })); await(); }
server.requestHandler(req -> { HttpConnection conn = req.connection(); req.exceptionHandler(err -> { assertFalse(Thread.holdsLock(conn)); complete();
try { req.endHandler(null); req.exceptionHandler(null); req.handler(null); req.bodyHandler(null);