@Test public void testListenOnWildcardPort() { server.close(); server = vertx.createNetServer(new NetServerOptions().setPort(0)); server.connectHandler((netSocket) -> { }).listen(ar -> { assertFalse(ar.failed()); assertTrue(ar.succeeded()); assertNull(ar.cause()); assertTrue(server.actualPort() > 1024); assertEquals(server, ar.result()); testComplete(); }); await(); }
@Test public void testConnectInvalidHost() { assertNullPointerException(() -> client.connect(80, null, res -> {})); client.connect(1234, "127.0.0.2", res -> { assertTrue(res.failed()); assertFalse(res.succeeded()); assertNotNull(res.cause()); testComplete(); }); await(); }
assertSame(serverConnectContext.get(), serverContext); } else { serverConnectContext.set(serverContext); CountDownLatch listenLatch = new CountDownLatch(1); AtomicReference<Context> listenContext = new AtomicReference<>(); server.listen(testAddress, onSuccess(v -> { listenContext.set(Vertx.currentContext()); listenLatch.countDown(); })); awaitLatch(listenLatch); contexts.add(Vertx.currentContext()); if (connectCount.incrementAndGet() == numConnections) { assertEquals(numConnections, contexts.size()); clientLatch.countDown(); awaitLatch(clientLatch); awaitLatch(serverLatch); assertTrue(ar.succeeded()); Context closeContext = Vertx.currentContext(); assertFalse(contexts.contains(closeContext)); assertNotSame(serverConnectContext.get(), closeContext); assertFalse(contexts.contains(listenContext.get())); assertSame(serverConnectContext.get(), listenContext.get()); testComplete(); });
@Test public void testServerCloseHandlersCloseFromServer() { serverCloseHandlers(true, s -> client.connect(testAddress, ar -> {})); await(); }
@Test public void testNoLogging() throws Exception { TestLoggerFactory factory = testLogging(); assertFalse(factory.hasName("io.netty.handler.logging.LoggingHandler")); }
@Test public void testClientWorkerMissBufferWhenBufferArriveBeforeConnectCallback() throws Exception { int size = getOptions().getWorkerPoolSize(); List<Context> workers = createWorkers(size + 1); CountDownLatch latch1 = new CountDownLatch(1); CountDownLatch latch2 = new CountDownLatch(size); server.connectHandler(so -> { try { awaitLatch(latch2); } catch (InterruptedException e) { fail(e.getMessage()); return; }); server.listen(testAddress, ar -> { assertTrue(ar.succeeded()); latch1.countDown(); }); awaitLatch(latch1); workers.get(0).runOnContext(v -> { NetClient client = vertx.createNetClient(); client.connect(testAddress, ar -> { assertTrue(ar.succeeded()); NetSocket so = ar.result(); so.handler(buf -> { assertEquals("hello", buf.toString()); testComplete(); }); });
assertEquals(NetworkOptions.DEFAULT_SEND_BUFFER_SIZE, options.getSendBufferSize()); int rand = TestUtils.randomPositiveInt(); assertEquals(options, options.setSendBufferSize(rand)); assertEquals(rand, options.getSendBufferSize()); assertIllegalArgumentException(() -> options.setSendBufferSize(0)); assertIllegalArgumentException(() -> options.setSendBufferSize(-123)); assertEquals(NetworkOptions.DEFAULT_RECEIVE_BUFFER_SIZE, options.getReceiveBufferSize()); rand = TestUtils.randomPositiveInt(); assertEquals(options, options.setReceiveBufferSize(rand)); assertEquals(rand, options.getReceiveBufferSize()); assertIllegalArgumentException(() -> options.setReceiveBufferSize(0)); assertIllegalArgumentException(() -> options.setReceiveBufferSize(-123)); assertTrue(options.isReuseAddress()); assertEquals(options, options.setReuseAddress(false)); assertFalse(options.isReuseAddress()); assertEquals(NetworkOptions.DEFAULT_TRAFFIC_CLASS, options.getTrafficClass()); rand = 23; assertEquals(options, options.setTrafficClass(rand)); assertEquals(rand, options.getTrafficClass()); assertIllegalArgumentException(() -> options.setTrafficClass(-2)); assertIllegalArgumentException(() -> options.setTrafficClass(256)); assertTrue(options.isTcpNoDelay()); assertEquals(options, options.setTcpNoDelay(false)); assertFalse(options.isTcpNoDelay());
private void testNetClientInternal_(HttpServerOptions options, boolean expectSSL) throws Exception { waitFor(2); HttpServer server = vertx.createHttpServer(options); server.requestHandler(req -> { req.response().end("Hello World"); }); CountDownLatch latch = new CountDownLatch(1); server.listen(onSuccess(v -> { latch.countDown(); })); awaitLatch(latch); client.connect(1234, "localhost", onSuccess(so -> { NetSocketInternal soInt = (NetSocketInternal) so; assertEquals(expectSSL, soInt.isSsl()); ChannelHandlerContext chctx = soInt.channelHandlerContext(); ChannelPipeline pipeline = chctx.pipeline(); pipeline.addBefore("handler", "http", new HttpClientCodec()); AtomicInteger status = new AtomicInteger(); soInt.handler(buff -> fail()); soInt.messageHandler(obj -> { switch (status.getAndIncrement()) { case 0: assertTrue(obj instanceof HttpResponse); HttpResponse resp = (HttpResponse) obj; assertEquals(200, resp.status().code()); break; case 1: assertTrue(obj instanceof LastHttpContent); ByteBuf content = ((LastHttpContent) obj).content(); assertEquals(!expectSSL, content.isDirect()); assertEquals(1, content.refCnt());
server.connectHandler(so -> { NetSocketInternal soi = (NetSocketInternal) so; soi.messageHandler(msg -> fail("Unexpected")); soi.handler(msg -> { ByteBuf byteBuf = msg.getByteBuf(); assertFalse(byteBuf.isDirect()); assertEquals(1, byteBuf.refCnt()); assertFalse(byteBuf.release()); assertEquals(1, byteBuf.refCnt()); soi.write(msg); }); }); startServer(); client.connect(testAddress, onSuccess(so -> { NetSocketInternal soi = (NetSocketInternal) so; soi.write(Buffer.buffer("Hello World")); soi.messageHandler(msg -> fail("Unexpected")); soi.handler(msg -> { ByteBuf byteBuf = msg.getByteBuf(); assertFalse(byteBuf.isDirect()); assertEquals(1, byteBuf.refCnt()); assertFalse(byteBuf.release()); assertEquals(1, byteBuf.refCnt()); assertEquals("Hello World", msg.toString()); testComplete(); }); })); 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()); }); }
assertEquals(sendBufferSize, options.getSendBufferSize()); assertEquals(receiverBufferSize, options.getReceiveBufferSize()); assertEquals(reuseAddress, options.isReuseAddress()); assertEquals(trafficClass, options.getTrafficClass()); assertEquals(tcpKeepAlive, options.isTcpKeepAlive()); assertEquals(tcpNoDelay, options.isTcpNoDelay()); assertEquals(soLinger, options.getSoLinger()); assertEquals(usePooledBuffers, options.isUsePooledBuffers()); assertEquals(idleTimeout, options.getIdleTimeout()); assertEquals(ssl, options.isSsl()); assertNotSame(keyStoreOptions, options.getKeyCertOptions()); assertEquals(ksPassword, ((JksOptions) options.getKeyCertOptions()).getPassword()); assertEquals(ksPath, ((JksOptions) options.getKeyCertOptions()).getPath()); assertNotSame(trustStoreOptions, options.getTrustOptions()); assertEquals(tsPassword, ((JksOptions) options.getTrustOptions()).getPassword()); assertEquals(tsPath, ((JksOptions) options.getTrustOptions()).getPath()); assertEquals(1, options.getEnabledCipherSuites().size()); assertTrue(options.getEnabledCipherSuites().contains(enabledCipher)); assertEquals(connectTimeout, options.getConnectTimeout()); assertEquals(trustAll, options.isTrustAll()); assertEquals(1, options.getCrlPaths().size()); assertEquals(crlPath, options.getCrlPaths().get(0)); assertEquals(reconnectAttempts, options.getReconnectAttempts()); assertEquals(reconnectInterval, options.getReconnectInterval()); assertEquals(useAlpn, options.isUseAlpn()); switch (sslEngine) { case "jdkSslEngineOptions": assertTrue(options.getSslEngineOptions() instanceof JdkSSLEngineOptions); break;
server.connectHandler(so -> { so.handler(buff -> { assertEquals(256, buff.length()); CountDownLatch latch = new CountDownLatch(1); exec.execute(() -> { }); try { awaitLatch(latch); } catch (InterruptedException e) { fail(e); startServer(); AtomicInteger done = new AtomicInteger(); for (int i = 0;i < num;i++) { NetSocket so = ar.result(); so.handler(buff -> { assertEquals(expected, buff); so.close(); int val = done.incrementAndGet(); if (val == num) { testComplete(); await(); } finally { exec.shutdown();
@Test public void testClientOptionsCopiedBeforeUse() { client.close(); NetClientOptions options = new NetClientOptions(); client = vertx.createNetClient(options); options.setSsl(true); // Now change something - but server should ignore this server.connectHandler(sock -> { testComplete(); }); server.listen(1234, "localhost", ar -> { assertTrue(ar.succeeded()); client.connect(1234, "localhost", ar2 -> { assertTrue(ar2.succeeded()); }); }); await(); }
@Test public void testListenTwice2() { server.connectHandler(sock -> { }); server.listen(testAddress, ar -> { assertTrue(ar.succeeded()); try { server.listen(testAddress, sock -> { }); fail("Should throw exception"); } catch (IllegalStateException e) { // OK } testComplete(); }); await(); }
latchListen.countDown(); } else { fail("Failed to bind server"); assertTrue(latchListen.await(10, TimeUnit.SECONDS)); } else { res.cause().printStackTrace(); fail("Failed to connect"); awaitLatch(latchClient); awaitLatch(latchConns); assertEquals(numServers, connectCount.size()); for (NetServer server : servers) { assertTrue(connectCount.containsKey(server)); assertEquals(numServers, connectCount.size()); for (int cnt : connectCount.values()) { assertEquals(numConnections / numServers, cnt); testComplete();
@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(); }
assertEquals(sendBufferSize, copy.getSendBufferSize()); assertEquals(receiverBufferSize, copy.getReceiveBufferSize()); assertEquals(reuseAddress, copy.isReuseAddress()); assertEquals(trafficClass, copy.getTrafficClass()); assertEquals(tcpNoDelay, copy.isTcpNoDelay()); assertEquals(tcpKeepAlive, copy.isTcpKeepAlive()); assertEquals(soLinger, copy.getSoLinger()); assertEquals(usePooledBuffers, copy.isUsePooledBuffers()); assertEquals(idleTimeout, copy.getIdleTimeout()); assertEquals(ssl, copy.isSsl()); assertNotSame(keyStoreOptions, copy.getKeyCertOptions()); assertEquals(ksPassword, ((JksOptions) copy.getKeyCertOptions()).getPassword()); assertNotSame(trustStoreOptions, copy.getTrustOptions()); assertEquals(tsPassword, ((JksOptions)copy.getTrustOptions()).getPassword()); assertEquals(1, copy.getEnabledCipherSuites().size()); assertTrue(copy.getEnabledCipherSuites().contains(enabledCipher)); assertEquals(1, copy.getCrlPaths().size()); assertEquals(crlPath, copy.getCrlPaths().get(0)); assertEquals(1, copy.getCrlValues().size()); assertEquals(crlValue, copy.getCrlValues().get(0)); assertEquals(port, copy.getPort()); assertEquals(host, copy.getHost()); assertEquals(acceptBacklog, copy.getAcceptBacklog()); assertEquals(useAlpn, copy.isUseAlpn()); assertEquals(sslEngine, copy.getSslEngineOptions()); assertEquals(sni, copy.isSni());
@Test public void testSharedServersRoundRobinButFirstStartAndStopServer() throws Exception { // Start and stop a server on the same port/host before hand to make sure it doesn't interact server.close(); CountDownLatch latch = new CountDownLatch(1); server = vertx.createNetServer(); server.connectHandler(sock -> { fail("Should not connect"); }).listen(testAddress, ar -> { if (ar.succeeded()) { latch.countDown(); } else { fail("Failed to bind server"); } }); awaitLatch(latch); CountDownLatch closeLatch = new CountDownLatch(1); server.close(ar -> { assertTrue(ar.succeeded()); closeLatch.countDown(); }); assertTrue(closeLatch.await(10, TimeUnit.SECONDS)); testSharedServersRoundRobin(); }
@Test public void testSniImplicitServerName() throws Exception { TLSTest test = new TLSTest() .clientTrust(Trust.SNI_JKS_HOST2) .address(SocketAddress.inetSocketAddress(4043, "host2.com")) .serverCert(Cert.SNI_JKS).sni(true); test.run(true); await(); assertEquals("host2.com", cnOf(test.clientPeerCert())); assertEquals("host2.com", test.indicatedServerName); }
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(); }