protected void startServer(SocketAddress remoteAddress, Context context, NetServer server) throws Exception { CountDownLatch latch = new CountDownLatch(1); context.runOnContext(v -> { server.listen(remoteAddress, onSuccess(s -> latch.countDown())); }); awaitLatch(latch); }
void clientCloseHandlers(boolean closeFromClient) { client.connect(testAddress, onSuccess(so -> { AtomicInteger counter = new AtomicInteger(0); so.endHandler(v -> assertEquals(1, counter.incrementAndGet())); so.closeHandler(v -> { assertEquals(2, counter.incrementAndGet()); testComplete(); }); if (closeFromClient) { so.close(); } })); }
@Test public void testWriteHandlerSuccess() throws Exception { CompletableFuture<Void> close = new CompletableFuture<>(); server.connectHandler(socket -> { socket.pause(); close.thenAccept(v -> { socket.resume(); }); }); startServer(); client.connect(testAddress, onSuccess(so -> { writeUntilFull(so, v -> { so.write(Buffer.buffer("lost buffer"), onSuccess(ack -> testComplete())); close.complete(null); }); })); await(); }
@Test public void testClosingVertxCloseSharedServers() throws Exception { int numServers = 2; Vertx vertx = Vertx.vertx(getOptions()); List<NetServerImpl> servers = new ArrayList<>(); for (int i = 0;i < numServers;i++) { NetServer server = vertx.createNetServer().connectHandler(so -> { fail(); }); startServer(server); servers.add((NetServerImpl) server); } CountDownLatch latch = new CountDownLatch(1); vertx.close(onSuccess(v -> { latch.countDown(); })); awaitLatch(latch); servers.forEach(server -> { assertTrue(server.isClosed()); }); }
@Test public void testWorkerServer() throws Exception { String expected = TestUtils.randomAlphaString(2000); vertx.deployVerticle(new AbstractVerticle() { @Override public void start(Future<Void> startFuture) throws Exception { NetServer server = vertx.createNetServer(); server.connectHandler(so -> { Buffer received = Buffer.buffer(); so.handler(received::appendBuffer); so.closeHandler(v -> { assertEquals(expected, received.toString()); testComplete(); }); try { Thread.sleep(500); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }); server.listen(testAddress, ar -> startFuture.handle(ar.mapEmpty())); } }, new DeploymentOptions().setWorker(true), onSuccess(v -> { client.connect(testAddress, onSuccess(so -> { so.write(expected).close(); })); })); await(); }
private TestLoggerFactory testLogging() throws Exception { return TestUtils.testLogging(() -> { server.connectHandler(so -> { so.write("fizzbuzz").end(); }); server.listen(testAddress, onSuccess(v1 -> { client.connect(testAddress, onSuccess(so -> { so.closeHandler(v2 -> testComplete()); })); })); await(); }); }
@Test // This tests using NetSocket.writeHandlerID (on the server side) // Send some data and make sure it is fanned out to all connections public void testFanout() throws Exception { int numConnections = 10; Set<String> connections = new ConcurrentHashSet<>(); server.connectHandler(socket -> { connections.add(socket.writeHandlerID()); if (connections.size() == numConnections) { for (String actorID : connections) { vertx.eventBus().publish(actorID, Buffer.buffer("some data")); } } socket.closeHandler(v -> { connections.remove(socket.writeHandlerID()); }); }); startServer(); CountDownLatch receivedLatch = new CountDownLatch(numConnections); for (int i = 0; i < numConnections; i++) { client.connect(testAddress, onSuccess(socket -> { socket.handler(data -> { receivedLatch.countDown(); }); })); } assertTrue(receivedLatch.await(10, TimeUnit.SECONDS)); testComplete(); }
@Test public void testWriteHandlerFailure() throws Exception { CompletableFuture<Void> close = new CompletableFuture<>(); server.connectHandler(socket -> { socket.pause(); close.thenAccept(v -> { socket.close(); }); }); startServer(); client.connect(testAddress, onSuccess(so -> { writeUntilFull(so, v -> { so.write(Buffer.buffer("lost buffer"), onFailure(err -> { testComplete(); })); close.complete(null); }); })); await(); }
@Test public void testListenTwice() { server.connectHandler(sock -> { }); server.listen(testAddress, onSuccess(s -> { try { server.listen(testAddress, res -> {}); fail("Should throw exception"); } catch (IllegalStateException e) { // OK testComplete(); } catch (Exception e) { fail(e.getMessage()); } })); await(); }
@Test public void testServerDrainHandler() { drainingServer(s -> { client.connect(testAddress, onSuccess(sock -> { sock.pause(); setHandlers(sock); sock.handler(buf -> {}); })); }); await(); }
@Test public void testSetHandlerAfterListen() { server.connectHandler(sock -> { }); server.listen(testAddress, onSuccess(v -> testComplete())); try { server.connectHandler(sock -> { }); fail("Should throw exception"); } catch (IllegalStateException e) { // OK } await(); }
private void reconnectAttempts(int attempts) { client.close(); client = vertx.createNetClient(new NetClientOptions().setReconnectAttempts(attempts).setReconnectInterval(10)); //The server delays starting for a a few seconds, but it should still connect client.connect(testAddress, onSuccess(so -> testComplete())); // Start the server after a delay vertx.setTimer(2000, id -> startEchoServer(testAddress, s -> {})); await(); }
@Test public void testClientLocalAddress() { String expectedAddress = TestUtils.loopbackAddress(); NetClientOptions clientOptions = new NetClientOptions().setLocalAddress(expectedAddress); client.close(); client = vertx.createNetClient(clientOptions); server.connectHandler(sock -> { assertEquals(expectedAddress, sock.remoteAddress().host()); sock.close(); }); server.listen(1234, "localhost", onSuccess(v -> { client.connect(1234, "localhost", onSuccess(socket -> { socket.closeHandler(v2 -> { testComplete(); }); })); })); await(); }
@Test public void testRemoteAddress() { server.connectHandler(socket -> { SocketAddress addr = socket.remoteAddress(); assertEquals("127.0.0.1", addr.host()); socket.close(); }).listen(1234, "localhost", ar -> { assertTrue(ar.succeeded()); vertx.createNetClient(new NetClientOptions()).connect(1234, "localhost", onSuccess(socket -> { SocketAddress addr = socket.remoteAddress(); assertEquals("127.0.0.1", addr.host()); assertEquals(addr.port(), 1234); socket.closeHandler(v -> testComplete()); })); }); await(); }
@Test public void testCloseCompletionHandlerNotCalledWhenActualServerFailed() { server.close(); server = vertx.createNetServer( new NetServerOptions() .setSsl(true) .setPemKeyCertOptions(new PemKeyCertOptions().setKeyPath("invalid"))) .connectHandler(c -> { }); try { server.listen(10000, r -> fail()); } catch (Exception ignore) { // Expected } server.close(onSuccess(v -> { testComplete(); })); await(); }
}); startServer(); client.connect(testAddress, onSuccess(so -> { NetSocketInternal soi = (NetSocketInternal) so; soi.write(Buffer.buffer("Hello World"));
@Test public void testClientDrainHandler() { pausingServer((s) -> { client.connect(testAddress, onSuccess(sock -> { assertFalse(sock.writeQueueFull()); sock.setWriteQueueMaxSize(1000); Buffer buff = TestUtils.randomBuffer(10000); vertx.setPeriodic(1, id -> { sock.write(buff.copy()); if (sock.writeQueueFull()) { vertx.cancelTimer(id); sock.drainHandler(v -> { assertFalse(sock.writeQueueFull()); testComplete(); }); // Tell the server to resume vertx.eventBus().send("server_resume", ""); } }); })); }); await(); }
}); startServer(); client.connect(testAddress, onSuccess(so -> { vertx.setTimer(1000, id -> { so.close();