@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 -> {
@Override public void start() throws Exception { NetClient client = vertx.createNetClient(); client.connect(testAddress, onSuccess(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(); } })); } }, new DeploymentOptions().setWorker(true));
@Test public void testClientNetSocketCloseRemovesFromThePool() throws Exception { testHttpClientResponseThrowsExceptionInHandler(null, (resp, latch) -> { NetSocket socket = resp.netSocket(); socket.closeHandler(v -> { latch.countDown(); }); socket.close(); }); }
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(); } })); }
void serverCloseHandlers(boolean closeFromServer, Handler<AsyncResult<NetServer>> listenHandler) { server.connectHandler((sock) -> { AtomicInteger counter = new AtomicInteger(0); sock.endHandler(v -> assertEquals(1, counter.incrementAndGet())); sock.closeHandler(v -> { assertEquals(2, counter.incrementAndGet()); testComplete(); }); if (closeFromServer) { sock.close(); } }).listen(testAddress, listenHandler); }
void setHandlers(NetSocket sock) { Handler<Message<Buffer>> resumeHandler = m -> sock.resume(); MessageConsumer reg = vertx.eventBus().<Buffer>consumer("client_resume").handler(resumeHandler); sock.closeHandler(v -> reg.unregister()); }
@Test public void testServerIdleTimeout() { server.close(); NetServerOptions netServerOptions = new NetServerOptions(); netServerOptions.setIdleTimeout(1000); netServerOptions.setIdleTimeoutUnit(TimeUnit.MILLISECONDS); server = vertx.createNetServer(netServerOptions); server.connectHandler(s -> {}).listen(testAddress, ar -> { assertTrue(ar.succeeded()); client.connect(testAddress, res -> { assertTrue(res.succeeded()); NetSocket socket = res.result(); socket.closeHandler(v -> testComplete()); }); }); await(); }
@Test public void testRequestHandlerNotCalledInvalidRequest() { server.requestHandler(req -> { fail(); }); server.listen(onSuccess(s -> { vertx.createNetClient(new NetClientOptions()).connect(8080, "127.0.0.1", onSuccess(socket -> { socket.closeHandler(r -> { testComplete(); }); socket.write("GET HTTP1/1\r\n"); // trigger another write to be sure we detect that the other peer has closed the connection. socket.write("X-Header: test\r\n"); })); })); await(); }
@Test public void testClientIdleTimeout() { client.close(); NetClientOptions netClientOptions = new NetClientOptions(); netClientOptions.setIdleTimeout(1000); netClientOptions.setIdleTimeoutUnit(TimeUnit.MILLISECONDS); client = vertx.createNetClient(netClientOptions); server.connectHandler(s -> { }).listen(testAddress, ar -> { assertTrue(ar.succeeded()); client.connect(testAddress, res -> { assertTrue(res.succeeded()); NetSocket socket = res.result(); socket.closeHandler(v -> testComplete()); }); }); await(); }
void pausingServer(Handler<AsyncResult<NetServer>> listenHandler) { server.connectHandler(sock -> { sock.pause(); Handler<Message<Buffer>> resumeHandler = (m) -> sock.resume(); MessageConsumer reg = vertx.eventBus().<Buffer>consumer("server_resume").handler(resumeHandler); sock.closeHandler(v -> reg.unregister()); }).listen(testAddress, listenHandler); }
@Test public void testListenOnPortNoHandler() { server.connectHandler(NetSocket::close); server.listen(1234, onSuccess(ns -> { client.connect(1234, "localhost", onSuccess(so -> { so.closeHandler(v -> { testComplete(); }); })); })); await(); }
@Test public void testListen() { server.connectHandler(NetSocket::close); server.listen(testAddress, onSuccess(ns -> { client.connect(testAddress, onSuccess(so -> { so.closeHandler(v -> { testComplete(); }); })); })); await(); }
@Test public void testIdleTimeoutWithPartialH2CRequest() throws Exception { server.close(); server = vertx.createHttpServer(new HttpServerOptions() .setPort(DEFAULT_HTTP_PORT) .setHost(DEFAULT_HTTP_HOST) .setIdleTimeout(1)); server.requestHandler(req -> { testComplete(); }); startServer(); NetClient client = vertx.createNetClient(); client.connect(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, onSuccess(so -> { so.closeHandler(v -> { testComplete(); }); })); await(); }
private synchronized void connected(NetSocket socket) { this.socket = socket; connected = true; socket.exceptionHandler(t -> close()); socket.closeHandler(v -> close()); socket.handler(data -> { // Got a pong back vertx.cancelTimer(timeoutID); schedulePing(); }); // Start a pinger schedulePing(); if (pending != null) { if (log.isDebugEnabled()) { log.debug("Draining the queue for server " + serverID); } for (ClusteredMessage message : pending) { Buffer data = message.encodeToWire(); if (metrics != null) { metrics.messageWritten(message.address(), data.length()); } socket.write(data); } } pending = null; }
@Test public void testIdleTimeoutInfiniteSkipOfControlCharactersState() throws Exception { server.close(); server = vertx.createHttpServer(new HttpServerOptions() .setPort(DEFAULT_HTTP_PORT) .setHost(DEFAULT_HTTP_HOST) .setIdleTimeout(1)); server.requestHandler(req -> { testComplete(); }); startServer(); NetClient client = vertx.createNetClient(); client.connect(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, onSuccess(so -> { long id = vertx.setPeriodic(1, timerID -> { so.write(Buffer.buffer().setInt(0, 0xD)); }); so.closeHandler(v -> { vertx.cancelTimer(id); testComplete(); }); })); 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 public void testTLSHostnameCertCheckIncorrect() { server.close(); server = vertx.createNetServer(new NetServerOptions().setSsl(true).setPort(4043) .setKeyCertOptions(Cert.SERVER_JKS_ROOT_CA.get())); server.connectHandler(netSocket -> netSocket.close()).listen(ar -> { NetClientOptions options = new NetClientOptions() .setHostnameVerificationAlgorithm("HTTPS") .setTrustOptions(Trust.SERVER_JKS_ROOT_CA.get()); NetClient client = vertx.createNetClient(options); client.connect(4043, "127.0.0.1", arSocket -> { if (arSocket.succeeded()) { NetSocket ns = arSocket.result(); ns.closeHandler(v -> { testComplete(); }); ns.upgradeToSsl(v -> { fail("this test should fail"); }); } else { fail(ar.cause()); } }); }); 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(); }
private void testNetServer(VertxOptions options) { vertx = Vertx.vertx(options); NetServer server = vertx.createNetServer(); server.connectHandler(so -> { so.handler(buff -> { assertEquals("ping", buff.toString()); so.write("pong"); }); so.closeHandler(v -> { testComplete(); }); }); server.listen(1234, onSuccess(v -> { NetClient client = vertx.createNetClient(); client.connect(1234, "localhost", onSuccess(so -> { so.write("ping"); so.handler(buff -> { assertEquals("pong", buff.toString()); so.close(); }); })); })); 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(); }