Refine search
}); startServer(); NetClient client = vertx.createNetClient(); try { CompletableFuture<MultiMap> result = new CompletableFuture<>(); client.connect(DEFAULT_HTTP_PORT, DEFAULT_HTTPS_HOST, ar -> { if (ar.succeeded()) { NetSocket so = ar.result(); so.write( method.name() + " / HTTP/1.1\r\n" + "Connection: close\r\n" + "\r\n"); Buffer body = Buffer.buffer(); so.exceptionHandler(result::completeExceptionally); so.handler(body::appendBuffer); so.endHandler(v -> { String content = body.toString(); int idx = content.indexOf("\r\n\r\n"); if (idx == content.length() - 4) { result.completeExceptionally(ar.cause()); client.close();
@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(); }
@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 -> {
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); }
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; }
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); socket.handler(buff -> { socket.write(buff); // echo the data if (startTLS) { if (upgradedServer.compareAndSet(false, true)) { indicatedServerName = socket.indicatedServerName(); assertFalse(socket.isSsl()); socket.exceptionHandler(err -> { if (shouldPass) { fail("Should not fail to connect"); socket.upgradeToSsl(v -> { certificateChainChecker.accept(socket); upgradedServerCount.incrementAndGet(); assertTrue(socket.isSsl()); }); } else { assertTrue(socket.isSsl()); assertEquals(1, upgradedServerCount.get());
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();
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)); log.debug("auth failed"); log.debug("writing: " + toHex(errorResponse)); socket.write(errorResponse); socket.close(); } else { String host; socket.handler(null); lastUri = host + ":" + port; NetClient netClient = vertx.createNetClient(new NetClientOptions()); netClient.connect(port, host, result -> { if (result.succeeded()) { log.debug("writing: " + toHex(connectResponse)); socket.write(connectResponse); log.debug("connected, starting pump"); NetSocket clientSocket = result.result(); socket.closeHandler(v -> clientSocket.close()); clientSocket.closeHandler(v -> socket.close()); Pump.pump(socket, clientSocket).start(); Pump.pump(clientSocket, socket).start();
NetClient client = process.vertx().createNetClient(); client.connect(23, "towel.blinkenlights.nl", ar -> { if (ar.succeeded()) { NetSocket socket = ar.result(); socket.close(); }); socket.handler(buff -> { process.write(buff.toString("UTF-8")); }).exceptionHandler(err -> { err.printStackTrace(); socket.close(); }); socket.closeHandler(v -> { process.end(); }); CommandRegistry.getShared(vertx).registerCommand(starwars); service.start(ar -> { if (!ar.succeeded()) { ar.cause().printStackTrace();
@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(); }
@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(); }
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(); int val = done.incrementAndGet(); if (val == num) { 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(); }); so2.closeHandler(v -> { paused.set(false); socketStream.resume(); client.connect(testAddress, ar3 -> { Buffer buffer = Buffer.buffer(); so3.handler(buffer::appendBuffer); so3.closeHandler(v3 -> { assertEquals("hello", buffer.toString("utf-8"));
@Test public void testReadStreamPauseResume() { String path = "/some/path"; this.server = vertx.createHttpServer(new HttpServerOptions().setAcceptBacklog(10).setPort(HttpTestBase.DEFAULT_HTTP_PORT)); ReadStream<HttpServerRequest> httpStream = server.requestStream(); AtomicBoolean paused = new AtomicBoolean(); }); server.listen(listenAR -> { assertTrue(listenAR.succeeded()); paused.set(true); httpStream.pause(); netClient = vertx.createNetClient(new NetClientOptions().setConnectTimeout(1000)); netClient.connect(HttpTestBase.DEFAULT_HTTP_PORT, "localhost", socketAR -> { assertTrue(socketAR.succeeded()); NetSocket socket = socketAR.result(); Buffer buffer = Buffer.buffer(); socket.handler(buffer::appendBuffer); socket.closeHandler(v -> { assertEquals(0, buffer.length()); paused.set(false); httpStream.resume(); client = vertx.createHttpClient(new HttpClientOptions()); client.request(HttpMethod.GET, HttpTestBase.DEFAULT_HTTP_PORT, "localhost", path, onSuccess(resp -> { assertEquals(200, resp.statusCode());
void testEcho(Consumer<NetSocket> writer, Consumer<Buffer> dataChecker, int length) { Handler<AsyncResult<NetSocket>> clientHandler = (asyncResult) -> { if (asyncResult.succeeded()) { NetSocket sock = asyncResult.result(); Buffer buff = Buffer.buffer(); sock.handler((buffer) -> { buff.appendBuffer(buffer); if (buff.length() == length) { dataChecker.accept(buff); testComplete(); } if (buff.length() > length) { fail("Too many bytes received"); } }); writer.accept(sock); } else { fail("failed to connect"); } }; startEchoServer(testAddress, s -> client.connect(testAddress, clientHandler)); await(); }
@Test // Let's manually handle the websocket handshake and write a frame to the client public void testHandleWSManually() throws Exception { String path = "/some/path"; String message = "here is some text data"; server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)).requestHandler(req -> { NetSocket sock = getUpgradedNetSocket(req, path); // Let's write a Text frame raw Buffer buff = Buffer.buffer(); buff.appendByte((byte)129); // Text frame buff.appendByte((byte)message.length()); buff.appendString(message); sock.write(buff); }); server.listen(ar -> { assertTrue(ar.succeeded()); client.websocketStream(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, path). handler(ws -> { ws.handler(buff -> { assertEquals(message, buff.toString("UTF-8")); testComplete(); }); }); }); await(); }
@Test public void testReportProtocolViolationOnServer() { server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)).websocketHandler(ws -> { AtomicReference<Throwable> failure = new AtomicReference<>(); ws.closeHandler(v -> { assertNotNull(failure.get()); testComplete(); }); ws.exceptionHandler(failure::set); }); server.listen(ar -> { assertTrue(ar.succeeded()); handshake(sock -> { // Let's write an invalid frame Buffer buff = Buffer.buffer(); buff.appendByte((byte)(0x8)).appendByte((byte)0); // Violates protocol with V13 (final control frame) sock.write(buff); }); }); await(); }
if (r.succeeded()) { NetClient client = vertx.createNetClient(); client.connect(8080, "localhost", onSuccess(conn -> { conn.write(rawReq); Buffer respBuff = Buffer.buffer(); conn.handler(respBuff::appendBuffer); conn.closeHandler(v -> { assertTrue(respBuff.toString().contains("501 Not Implemented")); client.close(); testComplete(); });
@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(); }