@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 -> {
private Handler<NetSocket> getServerHandler() { return socket -> { RecordParser parser = RecordParser.newFixed(4); Handler<Buffer> handler = new Handler<Buffer>() { int size = -1; public void handle(Buffer buff) { if (size == -1) { size = buff.getInt(0); parser.fixedSizeMode(size); } else { ClusteredMessage received = new ClusteredMessage(); received.readFromWire(buff, codecManager); if (metrics != null) { metrics.messageRead(received.address(), buff.length()); } parser.fixedSizeMode(4); size = -1; if (received.codec() == CodecManager.PING_MESSAGE_CODEC) { // Just send back pong directly on connection socket.write(PONG); } else { deliverMessageLocally(received); } } } }; parser.setOutput(handler); socket.handler(parser); }; }
void startEchoServer(SocketAddress address, Handler<AsyncResult<NetServer>> listenHandler) { Handler<NetSocket> serverHandler = socket -> socket.handler(socket::write); server.connectHandler(serverHandler).listen(address, listenHandler); }
@Test public void testConnectionCloseHttp_1_1_NoClose() throws Exception { testConnectionClose(HttpClientRequest::end, socket -> { AtomicBoolean firstRequest = new AtomicBoolean(true); socket.handler(RecordParser.newDelimited("\r\n\r\n", buffer -> { if (firstRequest.getAndSet(false)) { socket.write("HTTP/1.1 200 OK\r\n" + "Content-Type: text/plain\r\n" + "Content-Length: 4\r\n" + "\r\n" + "xxx\n"); } else { socket.write("HTTP/1.1 200 OK\r\n" + "Content-Type: text/plain\r\n" + "Content-Length: 1\r\n" + "Connection: close\r\n" + "\r\n" + "\r\n"); } })); }); }
@Test public void testConnectionCloseHttp_1_1_Close() throws Exception { testConnectionClose(HttpClientRequest::end, socket -> { AtomicBoolean firstRequest = new AtomicBoolean(true); socket.handler(RecordParser.newDelimited("\r\n\r\n", buffer -> { if (firstRequest.getAndSet(false)) { socket.write("HTTP/1.1 200 OK\r\n" + "Content-Type: text/plain\r\n" + "Content-Length: 3\r\n" + "\r\n" + "xxx"); } else { socket.write("HTTP/1.1 200 OK\r\n" + "Content-Type: text/plain\r\n" + "Content-Length: 0\r\n" + "Connection: close\r\n" + "\r\n"); socket.close(); } })); }); }
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 public void testConnectionCloseHttp_1_0_NoClose() throws Exception { testConnectionClose(req -> { req.putHeader("Connection", "close"); req.end(); }, socket -> { AtomicBoolean firstRequest = new AtomicBoolean(true); socket.handler(RecordParser.newDelimited("\r\n\r\n", buffer -> { if (firstRequest.getAndSet(false)) { socket.write("HTTP/1.0 200 OK\n" + "Content-Type: text/plain\n" + "Content-Length: 4\n" + "Connection: keep-alive\n" + "\n" + "xxx\n"); } else { socket.write("HTTP/1.0 200 OK\n" + "Content-Type: text/plain\n" + "Content-Length: 1\n" + "\n" + "\n"); } })); }); }
@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 // 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 testSendFileDirectory() throws Exception { File fDir = testFolder.newFolder(); server.connectHandler(socket -> { socket.handler(buff -> { fail("Should not receive any data"); }); }).listen(testAddress, ar -> { assertTrue(ar.succeeded()); client.connect(testAddress, result -> { assertTrue(result.succeeded()); NetSocket socket = result.result(); try { socket.sendFile(fDir.getAbsolutePath().toString()); // should throw exception and never hit the assert fail("Should throw exception"); } catch (IllegalArgumentException e) { testComplete(); } }); }); await(); }
@Test public void testListenSocketAddress() { NetClient netClient = vertx.createNetClient(); server = vertx.createHttpServer().requestHandler(req -> req.response().end()); SocketAddress sockAddress = SocketAddress.inetSocketAddress(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST); server.listen(sockAddress, onSuccess(server -> { netClient.connect(sockAddress, onSuccess(sock -> { sock.handler(buf -> { assertTrue("Response is not an http 200", buf.toString("UTF-8").startsWith("HTTP/1.1 200 OK")); testComplete(); }); sock.write("GET / HTTP/1.1\r\n\r\n"); })); })); try { await(); } finally { netClient.close(); } }
@Test public void testConnectionCloseHttp_1_0_Close() throws Exception { testConnectionClose(req -> { req.putHeader("Connection", "close"); req.end(); }, socket -> { AtomicBoolean firstRequest = new AtomicBoolean(true); socket.handler(RecordParser.newDelimited("\r\n\r\n", buffer -> { if (firstRequest.getAndSet(false)) { socket.write("HTTP/1.0 200 OK\n" + "Content-Type: text/plain\n" + "Content-Length: 4\n" + "Connection: keep-alive\n" + "\n" + "xxx\n"); } else { socket.write("HTTP/1.0 200 OK\n" + "Content-Type: text/plain\n" + "Content-Length: 1\n" + "\n" + "\n"); socket.close(); } })); }); }
@Test public void sendFileServerToClient() 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(buf -> { sock.sendFile(file.getAbsolutePath()); }); }); server.listen(testAddress, ar -> { assertTrue(ar.succeeded()); client.connect(testAddress, ar2 -> { assertTrue(ar2.succeeded()); NetSocket sock = ar2.result(); sock.handler(buff -> { received.appendBuffer(buff); if (received.length() == expected.length()) { assertEquals(expected, received); testComplete(); } }); sock.write("foo"); }); }); await(); }
@Test public void testListenDomainSocketAddress() throws Exception { Vertx vx = Vertx.vertx(new VertxOptions().setPreferNativeTransport(true)); Assume.assumeTrue("Native transport must be enabled", vx.isNativeTransportEnabled()); NetClient netClient = vx.createNetClient(); HttpServer httpserver = vx.createHttpServer().requestHandler(req -> req.response().end()); File sockFile = TestUtils.tmpFile(".sock"); SocketAddress sockAddress = SocketAddress.domainSocketAddress(sockFile.getAbsolutePath()); httpserver.listen(sockAddress, onSuccess(server -> { netClient.connect(sockAddress, onSuccess(sock -> { sock.handler(buf -> { assertTrue("Response is not an http 200", buf.toString("UTF-8").startsWith("HTTP/1.1 200 OK")); testComplete(); }); sock.write("GET / HTTP/1.1\r\n\r\n"); })); })); try { await(); } finally { vx.close(); } }
private void testNet(String hostname) throws Exception { NetClient client = vertx.createNetClient(); NetServer server = vertx.createNetServer().connectHandler(so -> { so.handler(buff -> { so.write(buff); so.close(); }); }); try { CountDownLatch listenLatch = new CountDownLatch(1); server.listen(1234, hostname, onSuccess(s -> { listenLatch.countDown(); })); awaitLatch(listenLatch); client.connect(1234, hostname, onSuccess(so -> { Buffer buffer = Buffer.buffer(); so.handler(buffer::appendBuffer); so.closeHandler(v -> { assertEquals(Buffer.buffer("foo"), buffer); testComplete(); }); so.write(Buffer.buffer("foo")); })); await(); } finally { client.close(); server.close(); } }
@Test public void testServerDrainHandler() { drainingServer(s -> { client.connect(testAddress, onSuccess(sock -> { sock.pause(); setHandlers(sock); sock.handler(buf -> {}); })); }); 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; }
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(); }
NetServer server = vertx.createNetServer().connectHandler(so -> { StringBuilder request = new StringBuilder(); so.handler(buff -> { request.append(buff); if (request.toString().endsWith("\r\n\r\n")) {
private void testAccessNetSocketPendingResponseData(boolean pause) { server.requestHandler(req -> { NetSocket so = req.netSocket(); so.write("hello"); }); server.listen(onSuccess(s -> { HttpClientRequest req = client.request(HttpMethod.CONNECT, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { NetSocket so = resp.netSocket(); assertNotNull(so); so.handler(buff -> { // With HTTP/1.1 the buffer is received immediately but delivered asynchronously assertEquals("hello", buff.toString()); testComplete(); }); if (pause) { so.pause(); vertx.setTimer(100, id -> { so.resume(); }); } })); req.sendHead(); })); await(); }