@Override public void start() throws Exception { HttpClient client = vertx.createHttpClient(); client.websocket(8080, "localhost", "/some-uri", websocket -> { websocket.handler(data -> { System.out.println("Received data " + data.toString("ISO-8859-1")); client.close(); }); websocket.writeBinaryMessage(Buffer.buffer("Hello world")); }); } }
@Test public void testWriteFromConnectHandlerFromAnotherThread() { Buffer expected = Buffer.buffer("AAA"); server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)); server.websocketHandler(ws -> { Thread t = new Thread() { @Override public void run() { ws.writeFrame(WebSocketFrame.binaryFrame(expected, true)); } }; t.start(); while (t.getState() != Thread.State.BLOCKED) { Thread.yield(); } }); server.listen(onSuccess(server -> { client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", ws -> { ws.handler(buff -> { assertEquals(buff, expected); testComplete(); }); }); })); await(); }
@Test public void httpClientWebsocketConnectionFailureHandlerShouldBeCalled() throws Exception { int port = 7867; HttpClient client = vertx.createHttpClient(); client.websocket(port, "localhost", "", websocket -> { websocket.handler(data -> { fail("connection should not succeed"); }); }, throwable -> testComplete()); await(); }
private void testRaceConditionWithWebsocketClient(Context context) { server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)); // Handcrafted websocket handshake for sending a frame immediatly after the handshake server.requestHandler(req -> { NetSocket so = handshake(req); if (so != null) { so.write(Buffer.buffer(new byte[]{ (byte) 0x82, 0x05, 0x68, 0x65, 0x6c, 0x6c, 0x6f, })); } }); server.listen(ar -> { assertTrue(ar.succeeded()); context.runOnContext(v -> { client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", ws -> { ws.handler(buf -> { assertEquals("hello", buf.toString()); testComplete(); }); }); }); }); await(); }
private void testWriteMessage(int size, WebsocketVersion version) { String path = "/some/path"; byte[] expected = TestUtils.randomByteArray(size); server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)).websocketHandler(ws -> { ws.writeBinaryMessage(Buffer.buffer(expected)); ws.close(); }); server.listen(ar -> { assertTrue(ar.succeeded()); client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, path, null, version, ws -> { Buffer actual = Buffer.buffer(); ws.handler(actual::appendBuffer); ws.closeHandler(v -> { assertArrayEquals(expected, actual.getBytes(0, actual.length())); testComplete(); }); }); }); await(); }
handler(ws -> { Buffer buff = Buffer.buffer(); ws.handler(b -> { buff.appendBuffer(b); });
@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 testRaceConditionWithWebsocketClientWorker2() throws Exception { int size = getOptions().getWorkerPoolSize() - 4; List<Context> workers = createWorkers(size + 1); server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)); server.websocketHandler(ws -> { ws.write(Buffer.buffer("hello")); }); server.listen(ar -> { assertTrue(ar.succeeded()); workers.get(0).runOnContext(v -> { ReadStream<WebSocket> webSocketStream = client.websocketStream(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/"); webSocketStream.handler(ws -> { ws.handler(buf -> { assertEquals("hello", buf.toString()); testComplete(); }); }); }); }); await(); }
private void testWriteFromConnectHandler(WebsocketVersion version) throws Exception { String path = "/some/path"; Buffer buff = Buffer.buffer("AAA"); server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)).websocketHandler(ws -> { assertEquals(path, ws.path()); ws.writeFrame(WebSocketFrame.binaryFrame(buff, true)); }); server.listen(ar -> { assertTrue(ar.succeeded()); client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, path, null, version, ws -> { Buffer received = Buffer.buffer(); ws.handler(data -> { received.appendBuffer(data); if (received.length() == buff.length()) { assertEquals(buff, received); ws.close(); testComplete(); } }); }); }); await(); }
stream.resume(); client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/some/path", ws -> { ws.handler(buffer -> { assertEquals("whatever", buffer.toString("UTF-8")); ws.closeHandler(v2 -> {
@Test public void testClearClientHandlersOnEnd() { String path = "/some/path"; server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)).websocketHandler(WebSocketBase::close); server.listen(ar -> { assertTrue(ar.succeeded()); client.websocketStream(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, path, null). handler(ws -> { ws.endHandler(v -> { try { ws.endHandler(null); ws.exceptionHandler(null); ws.handler(null); } catch (Exception e) { fail("Was expecting to set to null the handlers when the socket is closed"); return; } testComplete(); }); }); }); await(); }
@Test public void testServerWebSocket() { server = vertx.createHttpServer(); server.websocketHandler(ws -> { FakeHttpServerMetrics metrics = FakeMetricsBase.getMetrics(server); WebSocketMetric metric = metrics.getMetric(ws); assertNotNull(metric); assertNotNull(metric.soMetric); ws.handler(ws::write); ws.closeHandler(closed -> { assertNull(metrics.getMetric(ws)); testComplete(); }); }); server.listen(HttpTestBase.DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, ar -> { assertTrue(ar.succeeded()); client = vertx.createHttpClient(); client.websocket(HttpTestBase.DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", ws -> { ws.write(Buffer.buffer("wibble")); ws.handler(buff -> ws.close()); }); }); await(); }
@Test public void testWebSocket() { server = vertx.createHttpServer(); server.websocketHandler(ws -> { ws.write(Buffer.buffer("wibble")); ws.handler(buff -> ws.close()); }); server.listen(HttpTestBase.DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, ar -> { assertTrue(ar.succeeded()); client = vertx.createHttpClient(); client.websocket(HttpTestBase.DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", ws -> { FakeHttpClientMetrics metrics = FakeMetricsBase.getMetrics(client); WebSocketMetric metric = metrics.getMetric(ws); assertNotNull(metric); assertNotNull(metric.soMetric); ws.closeHandler(closed -> { assertNull(metrics.getMetric(ws)); testComplete(); }); ws.handler(ws::write); }); }); await(); }
@Test public void testServerWebSocketUpgrade() { server = vertx.createHttpServer(); server.requestHandler(req -> { FakeHttpServerMetrics metrics = FakeMetricsBase.getMetrics(server); assertNotNull(metrics.getMetric(req)); ServerWebSocket ws = req.upgrade(); assertNull(metrics.getMetric(req)); WebSocketMetric metric = metrics.getMetric(ws); assertNotNull(metric); assertNotNull(metric.soMetric); ws.handler(buffer -> ws.write(buffer)); ws.closeHandler(closed -> { WebSocketMetric a = metrics.getMetric(ws); assertNull(a); testComplete(); }); }); server.listen(HttpTestBase.DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, ar -> { assertTrue(ar.succeeded()); client = vertx.createHttpClient(); client.websocket(HttpTestBase.DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", ws -> { ws.write(Buffer.buffer("wibble")); ws.handler(buff -> { ws.close(); }); }); }); await(); }
ws.handler(data -> { received.appendBuffer(data); if (received.length() == bsize * sends) {
client.websocket(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, path, ws -> { final Buffer received = Buffer.buffer(); ws.handler(data -> { received.appendBuffer(data); if (received.length() == buff.length()) {
private void testValidSubProtocol(WebsocketVersion version) throws Exception { String path = "/some/path"; String clientSubProtocols = "clientproto,commonproto"; String serverSubProtocols = "serverproto,commonproto"; Buffer buff = Buffer.buffer("AAA"); server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT).setWebsocketSubProtocols(serverSubProtocols)).websocketHandler(ws -> { assertEquals(path, ws.path()); assertNull(ws.subProtocol()); ws.accept(); assertEquals("commonproto", ws.subProtocol()); ws.writeFrame(WebSocketFrame.binaryFrame(buff, true)); }); server.listen(ar -> { assertTrue(ar.succeeded()); client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, path, null, version, clientSubProtocols, ws -> { assertEquals("commonproto", ws.subProtocol()); final Buffer received = Buffer.buffer(); ws.handler(data -> { received.appendBuffer(data); if (received.length() == buff.length()) { assertEquals(buff, received); ws.close(); testComplete(); } }); }); }); await(); }
client.websocket(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, path, ws -> { final Buffer received = Buffer.buffer(); ws.handler(data -> { received.appendBuffer(data); if (received.length() == buff.length()) {
@Test public void testClientWebsocketWithHttp2Client() throws Exception { client.close(); client = vertx.createHttpClient(new HttpClientOptions().setHttp2ClearTextUpgrade(false).setProtocolVersion(HttpVersion.HTTP_2)); server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)); server.requestHandler(req -> { req.response().setChunked(true).write("connect"); }); server.websocketHandler(ws -> { ws.writeFinalTextFrame("ok"); }); server.listen(onSuccess(server -> { client.getNow(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", resp -> { client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", ws -> { ws.handler(buff -> { assertEquals("ok", buff.toString()); testComplete(); }); }); }); })); await(); }
ws.handler(data -> { received.appendBuffer(data); if (received.length() == buff.length()) {