@Override public ReadStream<T> endHandler(Handler<Void> endHandler) { delegate.endHandler(endHandler); return this; } }
@Override public JsonParser handler(Handler<JsonEvent> handler) { eventHandler = handler; if (stream != null) { if (handler != null) { stream.endHandler(v -> end()); stream.exceptionHandler(err -> { if (exceptionHandler != null) { exceptionHandler.handle(err); } }); stream.handler(this); } else { stream.handler(null); stream.endHandler(null); stream.exceptionHandler(null); } } return this; }
@Override public RecordParser handler(Handler<Buffer> handler) { eventHandler = handler; if (stream != null) { if (handler != null) { stream.endHandler(v -> end()); stream.exceptionHandler(err -> { if (exceptionHandler != null) { exceptionHandler.handle(err); } }); stream.handler(this); } else { stream.handler(null); stream.endHandler(null); stream.exceptionHandler(null); } } return this; }
@Test public void testTimerStreamExceptionDuringHandle() throws Exception { vertx.runOnContext(v -> { ReadStream<Long> timer = vertx.timerStream(200); AtomicBoolean handled = new AtomicBoolean(); timer.handler(l -> { assertFalse(handled.get()); handled.set(true); throw new RuntimeException(); }); timer.endHandler(v2 -> { assertTrue(handled.get()); testComplete(); }); }); await(); }
@Test public void testTimerStreamSetHandlerSchedulesTheTimer() throws Exception { vertx.runOnContext(v -> { ReadStream<Long> timer = vertx.timerStream(200); AtomicBoolean handled = new AtomicBoolean(); timer.handler(l -> { assertFalse(handled.get()); handled.set(true); }); timer.endHandler(v2 -> { assertTrue(handled.get()); testComplete(); }); }); await(); }
@Test public void testClosingServerClosesWebSocketStreamEndHandler() { this.server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)); ReadStream<ServerWebSocket> stream = server.websocketStream(); AtomicBoolean closed = new AtomicBoolean(); stream.endHandler(v -> closed.set(true)); stream.handler(ws -> { }); server.listen(ar -> { assertTrue(ar.succeeded()); assertFalse(closed.get()); server.close(v -> { assertTrue(ar.succeeded()); assertTrue(closed.get()); testComplete(); }); }); await(); }
@Test public void testClosingServerClosesRequestStreamEndHandler() { this.server = vertx.createHttpServer(new HttpServerOptions().setPort(HttpTestBase.DEFAULT_HTTP_PORT)); ReadStream<HttpServerRequest> stream = server.requestStream(); AtomicBoolean closed = new AtomicBoolean(); stream.endHandler(v -> closed.set(true)); stream.handler(req -> {}); server.listen(ar -> { assertTrue(ar.succeeded()); assertFalse(closed.get()); server.close(v -> { assertTrue(ar.succeeded()); assertTrue(closed.get()); testComplete(); }); }); await(); }
}); rs.exceptionHandler(t -> fail(t.getMessage())); rs.endHandler(v -> { ended.set(true); checkEnd.run();
Pump p = Pump.pump(rs, ws); p.start(); rs.endHandler(v -> { arr.result().close(car -> { if (car.failed()) {
ThreadLocal<Object> stack = new ThreadLocal<>(); stack.set(true); stream.endHandler(v -> { assertTrue(Vertx.currentContext().isEventLoopContext()); assertNull(stack.get());
ThreadLocal<Object> stack = new ThreadLocal<>(); stack.set(true); stream.endHandler(v -> { assertTrue(Vertx.currentContext().isEventLoopContext()); assertNull(stack.get());
private void testCloseCallHandlers(boolean local) { String path = "/some/path"; server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)).websocketHandler(ws -> { if (!local) { ws.close(); } }); AtomicInteger doneCount = new AtomicInteger(); server.listen(ar -> { assertTrue(ar.succeeded()); client.websocketStream(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, path, null). endHandler(done -> doneCount.incrementAndGet()). handler(ws -> { assertEquals(0, doneCount.get()); boolean[] closed = new boolean[1]; ws.closeHandler(v -> { closed[0] = true; assertEquals(1, doneCount.get()); testComplete(); }); if (local) { vertx.runOnContext(v -> { ws.close(); }); } }); }); await(); }
@Override public ReadStream<T> endHandler(Handler<Void> endHandler) { delegate.endHandler(endHandler); return this; } }
@Test public void testMultipleServerClose() { this.server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)); AtomicInteger times = new AtomicInteger(); // We assume the endHandler and the close completion handler are invoked in the same context task ThreadLocal stack = new ThreadLocal(); stack.set(true); server.websocketStream().endHandler(v -> { assertNull(stack.get()); assertTrue(Vertx.currentContext().isEventLoopContext()); times.incrementAndGet(); }); server.close(ar1 -> { assertNull(stack.get()); assertTrue(Vertx.currentContext().isEventLoopContext()); server.close(ar2 -> { server.close(ar3 -> { assertEquals(1, times.get()); testComplete(); }); }); }); await(); }
@Test public void testMultipleServerClose() { this.server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)); AtomicInteger times = new AtomicInteger(); // We assume the endHandler and the close completion handler are invoked in the same context task ThreadLocal stack = new ThreadLocal(); stack.set(true); server.requestStream().endHandler(v -> { assertNull(stack.get()); assertTrue(Vertx.currentContext().isEventLoopContext()); times.incrementAndGet(); }); server.close(ar1 -> { assertNull(stack.get()); assertTrue(Vertx.currentContext().isEventLoopContext()); server.close(ar2 -> { server.close(ar3 -> { assertEquals(1, times.get()); testComplete(); }); }); }); await(); }
@Test public void testMultipleServerClose() { this.server = vertx.createNetServer(); AtomicInteger times = new AtomicInteger(); // We assume the endHandler and the close completion handler are invoked in the same context task ThreadLocal stack = new ThreadLocal(); stack.set(true); server.connectStream().endHandler(v -> { assertNull(stack.get()); assertTrue(Vertx.currentContext().isEventLoopContext()); times.incrementAndGet(); }); server.close(ar1 -> { assertNull(stack.get()); assertTrue(Vertx.currentContext().isEventLoopContext()); server.close(ar2 -> { server.close(ar3 -> { assertEquals(1, times.get()); testComplete(); }); }); }); await(); }
ThreadLocal<Object> stack = new ThreadLocal<>(); stack.set(true); stream.endHandler(v -> { assertTrue(Vertx.currentContext().isEventLoopContext()); assertNull(stack.get());
@Test public void testTimerPause() throws Exception { vertx.runOnContext(v -> { ReadStream<Long> timer = vertx.timerStream(10); timer.handler(l -> fail()); timer.endHandler(l -> testComplete()); timer.pause(); }); await(); }
public <T> CompletableFuture<T> saveAs(Function<Buffer, T> converter) { CompletableFuture<T> future = new CompletableFuture<>(); Buffer buffer = Buffer.buffer(); // if readStream.resume() not run on correct eventloop, will: // 1.create a context task to save last chunk data to buffer // 2.activate connection to read new data // but maybe 2 will run before 1, that will cause lost data or get incorrect data context.runOnContext(V -> { readStream.exceptionHandler(future::completeExceptionally); readStream.handler(buffer::appendBuffer); readStream.endHandler(v -> future.complete(converter.apply(buffer))); readStream.resume(); }); return future; }
@Test public void testTimerPause() throws Exception { vertx.runOnContext(v -> { ReadStream<Long> timer = vertx.timerStream(10); timer.handler(l -> fail()); timer.endHandler(l -> testComplete()); timer.pause(); }); await(); }