@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 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 testDummyNetServerMetrics() { NetServer server = vertx.createNetServer(new NetServerOptions()); assertFalse(server.isMetricsEnabled()); }
void startEchoServer(SocketAddress address, Handler<AsyncResult<NetServer>> listenHandler) { Handler<NetSocket> serverHandler = socket -> socket.handler(socket::write); server.connectHandler(serverHandler).listen(address, listenHandler); }
@Override public void start() throws Exception { vertx.createNetServer().connectHandler(sock -> { RecordParser parser = RecordParser.newDelimited("\n", sock); parser .endHandler(v -> sock.close()) .exceptionHandler(t -> { t.printStackTrace(); sock.close(); }) .handler(buffer -> { String name = buffer.toString("UTF-8"); sock.write("Hello " + name + "\n", "UTF-8"); }); }).listen(1234); System.out.println("Echo server is now listening"); } }
setClusterViewChangedHandler(haManager); clusterManager.<String, ClusterNodeInfo>getAsyncMultiMap(SUBS_MAP_NAME, ar1 -> { if (ar1.succeeded()) { subs = ar1.result(); server = vertx.createNetServer(getServerOptions()); server.connectHandler(getServerHandler()); server.listen(asyncResult -> { if (asyncResult.succeeded()) { int serverPort = getClusterPublicPort(options, server.actualPort()); String serverHost = getClusterPublicHost(options); serverID = new ServerID(serverPort, serverHost);
/** * test socks4a proxy for accessing arbitrary server port. */ @Test public void testWithSocks4aProxy() throws Exception { NetClientOptions clientOptions = new NetClientOptions() .setProxyOptions(new ProxyOptions().setType(ProxyType.SOCKS4).setPort(11080)); NetClient client = vertx.createNetClient(clientOptions); server.connectHandler(sock -> { }); proxy = new Socks4Proxy(null); proxy.start(vertx); server.listen(1234, "localhost", ar -> { assertTrue(ar.succeeded()); client.connect(1234, "localhost", ar2 -> { if (ar2.failed()) { log.warn("failed", ar2.cause()); } assertTrue(ar2.succeeded()); // make sure we have gone through the proxy assertEquals("localhost:1234", proxy.getLastUri()); testComplete(); }); }); await(); }
private void doTestClientWebsocketConnectionCloseOnBadResponse(boolean keepAliveInOptions) throws Throwable { final Exception serverGotCloseException = new Exception(); netServer = vertx.createNetServer().connectHandler(sock -> { final Buffer fullReq = Buffer.buffer(230); sock.handler(b -> { fullReq.appendBuffer(b); String reqPart = b.toString(); if (fullReq.toString().contains("\r\n\r\n")) { try { sock.write(Buffer.buffer(resp.getBytes("ASCII"))); } catch (UnsupportedEncodingException e) { addResult(e); sock.closeHandler(v -> { addResult(serverGotCloseException); }); }).listen(ar -> { if (ar.failed()) { addResult(ar.cause()); return; NetServer server = ar.result(); int port = server.actualPort(); client = vertx.createHttpClient(opts).websocket(port, "localhost", "/", ws -> { addResult(new AssertionError("Websocket unexpectedly connected")); ws.close();
NetServerOptions options = new NetServerOptions(); options.setHost("localhost").setPort(PORT); server = vertx.createNetServer(options); server.connectHandler(socket -> { socket.handler(buffer -> { Buffer expectedInit = username == null ? clientInit : clientInitAuth; if (!buffer.equals(expectedInit)) { if (!buffer2.getBuffer(0, clientRequest.length()).equals(clientRequest)) { throw new IllegalStateException("expected " + toHex(clientRequest) + ", got " + toHex(buffer2)); int addressType = buffer2.getUnsignedByte(3); String host; int port; socket.handler(null); lastUri = host + ":" + port; Pump.pump(clientSocket, socket).start(); } else { log.error("exception", result.cause()); }); CompletableFuture<Void> fut = new CompletableFuture<>(); server.listen(ar -> {
CountDownLatch latch1 = new CountDownLatch(workers.size() - 1); workers.get(0).runOnContext(v -> { NetServer server = vertx.createNetServer(); server.connectHandler(so -> { so.handler(buf -> { assertEquals("hello", buf.toString()); testComplete(); }); }); server.listen(testAddress, ar -> { assertTrue(ar.succeeded()); }); awaitLatch(latch1); NetClient client = vertx.createNetClient(); client.connect(testAddress, ar -> { assertTrue(ar.succeeded()); NetSocket so = ar.result(); so.write(Buffer.buffer("hello")); }); await();
@Test public void sendFileClientToServer() throws Exception { File fDir = testFolder.newFolder(); String content = TestUtils.randomUnicodeString(10000); File file = setupFile(fDir.toString(), "some-file.txt", content); Buffer expected = Buffer.buffer(content); Buffer received = Buffer.buffer(); server.connectHandler(sock -> { sock.handler(buff -> { received.appendBuffer(buff); if (received.length() == expected.length()) { assertEquals(expected, received); testComplete(); } }); // Send some data to the client to trigger the sendfile sock.write("foo"); }); server.listen(testAddress, ar -> { assertTrue(ar.succeeded()); client.connect(testAddress, ar2 -> { assertTrue(ar2.succeeded()); NetSocket sock = ar2.result(); sock.handler(buf -> { sock.sendFile(file.getAbsolutePath()); }); }); }); await(); }
NetServerOptions options = new NetServerOptions(); options.setHost("localhost").setPort(PORT); server = vertx.createNetServer(options); server.connectHandler(socket -> { socket.handler(buffer -> { if (!buffer.getBuffer(0, clientRequest.length()).equals(clientRequest)) { throw new IllegalStateException("expected " + toHex(clientRequest) + ", got " + toHex(buffer)); int port = buffer.getUnsignedShort(2); NetClient netClient = vertx.createNetClient(new NetClientOptions()); netClient.connect(port, host, result -> { if (result.succeeded()) { NetSocket clientSocket = result.result(); Pump.pump(clientSocket, socket).start(); } else { log.error("exception", result.cause()); }); CompletableFuture<Void> fut = new CompletableFuture<>(); server.listen(ar -> {
void run(boolean shouldPass) { server.close(); NetServerOptions options = new NetServerOptions(); if (!startTLS) { X509Certificate[] certs = socket.peerCertificateChain(); if (clientCert != Cert.NONE) { assertNotNull(certs); server.exceptionHandler(err -> complete()); Handler<NetSocket> serverHandler = socket -> { indicatedServerName = socket.indicatedServerName(); if (socket.isSsl()) { certificateChainChecker.accept(socket); server.connectHandler(serverHandler).listen(address, ar -> { assertTrue(ar.succeeded()); client.close(); NetClientOptions clientOptions = new NetClientOptions(); if (!startTLS) { clientOptions.setSsl(true); clientOptions.setTrustAll(true); final Buffer received = Buffer.buffer(); final NetSocket socket = ar2.result();
@Test public void testWriteSameBufferMoreThanOnce() throws Exception { server.connectHandler(socket -> { Buffer received = Buffer.buffer(); socket.handler(buff -> { received.appendBuffer(buff); if (received.toString().equals("foofoo")) { testComplete(); } }); }).listen(testAddress, ar -> { assertTrue(ar.succeeded()); client.connect(testAddress, result -> { NetSocket socket = result.result(); Buffer buff = Buffer.buffer("foo"); socket.write(buff); socket.write(buff); }); }); await(); }
@Test public void testListenInvalidHost() { server.close(); server = vertx.createNetServer(new NetServerOptions().setPort(1234).setHost("uhqwduhqwudhqwuidhqwiudhqwudqwiuhd")); server.connectHandler(netSocket -> { }).listen(ar -> { assertTrue(ar.failed()); assertFalse(ar.succeeded()); assertNotNull(ar.cause()); testComplete(); }); await(); }
ExecutorService exec = Executors.newFixedThreadPool(1); try { server.connectHandler(so -> { so.handler(buff -> { assertEquals(256, buff.length()); CountDownLatch latch = new CountDownLatch(1); exec.execute(() -> { latch.countDown(); so.write(expected); }); try { AtomicInteger done = new AtomicInteger(); for (int i = 0;i < num;i++) { client.connect(testAddress, ar -> { if (ar.succeeded()) { NetSocket so = ar.result(); so.handler(buff -> { assertEquals(expected, buff); so.close(); so.write(TestUtils.randomBuffer(256)); } else { ar.cause().printStackTrace();
@Test public void testReadStreamPauseResume() { server.close(); server = vertx.createNetServer(new NetServerOptions().setAcceptBacklog(1)); ReadStream<NetSocket> socketStream = server.connectStream(); AtomicBoolean paused = new AtomicBoolean(); socketStream.handler(so -> { assertTrue(!paused.get()); so.write("hello"); so.close(); }); server.listen(testAddress, ar -> { assertTrue(ar.succeeded()); paused.set(true); socketStream.pause(); client.connect(testAddress, ar2 -> { assertTrue(ar2.succeeded()); NetSocket so2 = ar2.result(); so2.handler(buffer -> { fail(); }); paused.set(false); socketStream.resume(); client.connect(testAddress, ar3 -> { Buffer buffer = Buffer.buffer();
this.server = this.vertx.createNetServer(); this.client = this.vertx.createNetClient(); this.server.connectHandler(socket -> { this.serverSocket.handler(buffer -> { this.clientSocket.localAddress().host(), this.clientSocket.localAddress().port(), this.clientSocket.remoteAddress().host(), this.clientSocket.remoteAddress().port())); this.server.listen(SERVER_PORT, SERVER_HOST, serverFuture.completer()); this.client.connect(this.mqttServerPort, this.mqttServerHost, clientFuture.completer()); if (ar.succeeded()) { log.info(String.format("Proxy server started on port %d", serverFuture.result().actualPort())); log.info("Error connecting proxy client", clientFuture.cause()); startHandler.handle(Future.failedFuture(ar.cause()));
CompletableFuture<Void> test1 = new CompletableFuture<>(); vertx.resolveAddress("localhost", ar -> { if (ar.succeeded()) { InetAddress resolved = ar.result(); if (resolved.equals(localhost)) { test1.complete(null); test1.completeExceptionally(ar.cause()); NetServer server = vertx.createNetServer(new NetServerOptions().setPort(1234).setHost(localhost.getHostAddress())); try { server.connectHandler(so -> { so.write("hello").end(); }); server.listen(ar -> { if (ar.succeeded()) { test3.complete(null); client.connect(1234, "localhost", ar -> { if (ar.succeeded()) { test4.complete(null); test4.get(10, TimeUnit.SECONDS); } finally { server.close();
@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(); }