server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)).websocketHandler(ws -> { boolean[] closed = new boolean[1]; ws.handler(msg -> { ws.closeHandler(v -> { closed[0] = true; vertx.setTimer(500, id -> { while (!ws.writeQueueFull()) { ws.write(TestUtils.randomBuffer(1000)); ws.close(); }); });
@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(); }
@Test public void testServerWebsocketPongExceeds125Bytes() { testServerWebsocketPingPongCheck(255, ws -> { try { ws.writePong(Buffer.buffer(randomAlphaString(126))); } catch(Throwable expected) { assertEquals("Pong cannot exceed maxWebSocketFrameSize or 125 bytes", expected.getMessage()); ws.close(); testComplete(); } }); }
@Test public void testServerWebsocketPingExceeds125Bytes() { testServerWebsocketPingPongCheck(255, ws -> { try { ws.writePing(Buffer.buffer(randomAlphaString(126))); } catch(Throwable expected) { assertEquals("Ping cannot exceed maxWebSocketFrameSize or 125 bytes", expected.getMessage()); ws.close(); testComplete(); } }); }
vertxServerWebSocket.headers().size() == 0 ? MultiMap.empty() : new MultiMapWrapper( vertxServerWebSocket.headers()); final WebSocket webSocket = webSocketBuilder().setUri(vertxServerWebSocket.uri()) .setRemoteAddress(vertxServerWebSocket.remoteAddress().toString()) .setWebSocketSender(new WebSocketSender() { @Override vertxServerWebSocket.closeHandler(event -> webSocket.onClose()); vertxServerWebSocket.frameHandler(event -> { vertxServerWebSocket.exceptionHandler(event -> { if (event instanceof Exception) { webSocket.onError((Exception) event);
@Override public void start() throws Exception { httpServer = vertx.createHttpServer(); httpServer .websocketHandler(websocketHandler -> { if (!websocketHandler.path().equals("/vertx/hot")) { websocketHandler.reject(); return; } MessageConsumer<JsonObject> consumer = vertx.eventBus().consumer(TOPIC); consumer.handler(m -> websocketHandler.writeFinalTextFrame(m.body().toString())); websocketHandler.closeHandler((v) -> consumer.unregister()); } ) .listen(notificationPort); logger.info("notification websocket started on: http://localhost:{}", notificationPort); }
private HttpServer setupStatusService() { return vertx.createHttpServer().websocketHandler(websock -> { websock.writeFinalTextFrame(new JsonObject().put("message", getStatusServiceWelcomeMessage()).encode()); AtomicReference<String> uploadId = new AtomicReference<>(""); // sets up an event bus consumer to listen for import progress. MessageConsumer<JsonObject> consumer = vertx.eventBus().consumer(IMPORT_PROGRESS, data -> { try { if (uploadId.get().equals(data.body().getString(UPLOAD_ID))) { websock.writeFinalTextFrame(data.body().encode()); } } catch (Throwable e) { websock.close(); } }); // we only support one message from the client - to set the upload ID to listen to. websock.handler(handler -> uploadId.set(handler.toJsonObject().getString(UPLOAD_ID))); // when the websocket is closed we should stop listening for status messages. websock.closeHandler(closed -> consumer.unregister()); // when the websocket excepts we should also stop listening for status messages. websock.exceptionHandler(sock -> consumer.unregister()); }); }
assertEquals(uri, ws.uri()); assertEquals(path, ws.path()); assertEquals(query, ws.query()); assertEquals("upgrade", ws.headers().get("Connection")); AtomicInteger count = new AtomicInteger(); ws.frameHandler(frame -> { if (frame.isClose()) { testComplete(); assertFalse(frame.isFinal()); ws.writeFrame(frame); if (count.incrementAndGet() == frames) { count.set(0);
if (!socket.path().equals(options.getWebsocketPath())) { LOGGER.error("Receiving a web socket connection on an invalid path (" + socket.path() + "), the path is " + "configured to " + options.getWebsocketPath() + ". Rejecting connection"); socket.reject(); return; socket.exceptionHandler((exception) -> { LOGGER.error("The STOMP server caught a WebSocket error - closing connection", exception); connection.close(); }); socket.endHandler(v -> connection.close()); parser .errorHandler((exception) -> { socket.handler(parser); };
netServer.websocketHandler(sock -> { final EventBusWebsocketBridge ebnb = new EventBusWebsocketBridge(sock, vertx.eventBus(), address); sock.closeHandler(aVoid -> { logger.info("Bridge Server - closed connection from client ip: " + sock.remoteAddress()); ebnb.stop(); }); sock.exceptionHandler(throwable -> { logger.error("Bridge Server - Exception: " + throwable.getMessage(), throwable); ebnb.stop(); }); logger.info("Bridge Server - new connection from client ip: " + sock.remoteAddress()); sock.handler(parser::handle);
public void start() { netSocket.handler(this); netSocket.exceptionHandler(event -> { String clientInfo = getClientInfo(); logger.info(clientInfo + ", web-socket closed ... " + netSocket.binaryHandlerID() + " error: " + event.getMessage()); handleWillMessage(); shutdown(); }); netSocket.closeHandler(aVoid -> { String clientInfo = getClientInfo(); logger.info(clientInfo + ", web-socket closed ... "+ netSocket.binaryHandlerID() +" "+ netSocket.textHandlerID()); shutdown(); }); }
/** * Handles a web socket connection. * * @param socket the opening socket. */ @Override public void handle(final ServerWebSocket socket) { LOGGER.info("New web socket connection {}, {}", socket, socket.uri()); if (! configuration.accept(socket.uri())) { LOGGER.warn("Web Socket connection denied on {} by {}", socket.uri(), configuration.name()); return; } final Socket sock = new Socket(socket); accessor.getDispatcher().addSocket(socket.path(), sock); socket.closeHandler(event -> { LOGGER.info("Web Socket closed {}, {}", socket, socket.uri()); accessor.getDispatcher().removeSocket(socket.path(), sock); }); socket.handler(event -> accessor.getDispatcher().received(socket.path(), event.getBytes(), sock)); } }
@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(); }
@Test public void testCloseStatusCodeFromServer() throws InterruptedException { CountDownLatch latch = new CountDownLatch(2); client = vertx.createHttpClient(); server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)) .websocketHandler(socket -> { socket.closeHandler(a -> { latch.countDown(); }); vertx.setTimer(1000, (ar) -> socket.close()); }) .listen(ar -> { client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", ws -> { ws.frameHandler(frame -> { assertEquals(1000, frame.binaryData().getByteBuf().getShort(0)); assertEquals(1000, frame.closeStatusCode()); assertNull(frame.closeReason()); latch.countDown(); }); }); }); awaitLatch(latch); }
if (log.isTraceEnabled()) log.trace("WS, handler"); SockJSSession session = new SockJSSession(vertx, sessions, request, options.getHeartbeatInterval(), sockHandler); session.setInfo(ws.localAddress(), ws.remoteAddress(), ws.uri(), ws.headers()); session.register(new WebSocketListener(ws, session));
private void testReject(WebsocketVersion version, Integer rejectionStatus, int expectedRejectionStatus) throws Exception { String path = "/some/path"; server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)).websocketHandler(ws -> { assertEquals(path, ws.path()); if (rejectionStatus != null) { ws.reject(rejectionStatus); } else { ws.reject(); } }); server.listen(ar -> { assertTrue(ar.succeeded()); client.websocketStream(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, path, null, version). exceptionHandler(t -> { assertTrue(t instanceof WebsocketRejectedException); assertEquals(expectedRejectionStatus, ((WebsocketRejectedException)t).getStatus()); testComplete(); }). handler(ws -> fail("Should not be called")); }); await(); }
@Test public void testInvalidUnmaskedFrameRequest(){ client = vertx.createHttpClient(new HttpClientOptions().setSendUnmaskedFrames(true)); server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)); server.requestHandler(req -> { req.response().setChunked(true).write("connect"); }); server.websocketHandler(ws -> { ws.exceptionHandler(exception -> { testComplete(); }); ws.handler(result -> { fail("Cannot decode unmasked message because I require masked frame as configured"); }); }); server.listen(onSuccess(server -> { client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", ws -> { ws.writeFinalTextFrame("first unmasked frame"); }); })); 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(); }