private SocketMessages testWriteTextMessages(List<String> messagesToSend, WebsocketVersion version) { String path = "/some/path"; server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)).websocketHandler(ws -> { for (String messageToSend : messagesToSend) { ws.writeTextMessage(messageToSend); } ws.close(); }); List<String> receivedMessages = new ArrayList<>(); List<Throwable> receivedExceptions = new ArrayList<>(); server.listen(ar -> { assertTrue(ar.succeeded()); client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, path, null, version, ws -> { ws.textMessageHandler(receivedMessages::add); ws.exceptionHandler(receivedExceptions::add); ws.closeHandler(v -> testComplete()); }); }); await(); return new SocketMessages(receivedMessages, receivedExceptions); }
@Test public void testReportProtocolViolationOnClient() { server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)).requestHandler(req -> { NetSocket sock = getUpgradedNetSocket(req, "/some/path"); // 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); }); server.listen(ar -> { assertTrue(ar.succeeded()); client.websocketStream(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/some/path", null, WebsocketVersion.V13). handler(ws -> { AtomicReference<Throwable> failure = new AtomicReference<>(); ws.closeHandler(v -> { assertNotNull(failure.get()); testComplete(); }); ws.exceptionHandler(failure::set); }); }); await(); }
@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(); }
/** * This does not set up a handler on the websocket */ private WebSocket setupRawWebsocketClient(String serverPath) throws InterruptedException { String requestURI = serverPath + "/websocket"; AtomicReference<WebSocket> openedWebSocketReference = new AtomicReference<>(); CountDownLatch openSocketCountDown = new CountDownLatch(1); client.websocket(requestURI, ws -> { openedWebSocketReference.set(ws); openSocketCountDown.countDown(); ws.endHandler(v -> testComplete()); ws.exceptionHandler(this::fail); }); openSocketCountDown.await(5, TimeUnit.SECONDS); return openedWebSocketReference.get(); }
.addAll(authHeaders), ws -> { ws.exceptionHandler(e -> { LOGGER.error("watch config read fail", e); stopHeartBeatThread();
public static void open(IpPort ipPort, String url, Handler<Void> onOpen, Handler<Void> onClose, Handler<Buffer> onMessage, Handler<Throwable> onException, Handler<Throwable> onConnectFailed) { HttpClientWithContext vertxHttpClient = WebsocketClientPool.INSTANCE.getClient(); vertxHttpClient.runOnContext(client -> { client.websocket(ipPort.getPort(), ipPort.getHostOrIp(), url, RestUtils.getDefaultHeaders().addAll(RestUtils.getSignAuthHeaders( RestUtils.createSignRequest(HttpMethod.GET.name(), ipPort, new RequestParam(), url, new HashMap<>()))), ws -> { onOpen.handle(null); ws.exceptionHandler(v -> { onException.handle(v); try { ws.close(); } catch (Exception err) { LOGGER.error("ws close error.", err); } }); ws.closeHandler(v -> { onClose.handle(v); }); ws.handler(onMessage); }, onConnectFailed); }); } }
vertxWebSocket.exceptionHandler(error -> { if (error instanceof ConnectException) { logger.error("Unable to connect to " + host + " port " + port, error);
/** * This sets up a handler on the websocket */ private WebSocket setupSockJsClient(String serverPath, List<Buffer> receivedMessagesCollector) throws InterruptedException { String requestURI = serverPath + "/000/000/websocket"; AtomicReference<WebSocket> openedWebSocketReference = new AtomicReference<>(); CountDownLatch openSocketCountDown = new CountDownLatch(1); client.websocket(requestURI, ws -> { openedWebSocketReference.set(ws); ws.handler(replyBuffer -> { log.debug("Client received " + replyBuffer); String textReply = replyBuffer.toString(); if ("o".equals(textReply)) { openSocketCountDown.countDown(); } else { receivedMessagesCollector.add(replyBuffer); } }); ws.endHandler(v -> testComplete()); ws.exceptionHandler(this::fail); }); openSocketCountDown.await(5, TimeUnit.SECONDS); return openedWebSocketReference.get(); }
public io.vertx.rxjava.core.http.WebSocket exceptionHandler(Handler<Throwable> handler) { delegate.exceptionHandler(handler); return this; }
public io.vertx.rxjava.core.http.WebSocket exceptionHandler(Handler<Throwable> handler) { delegate.exceptionHandler(handler); return this; }
@Test public void testReportProtocolViolationOnClient() { server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)).requestHandler(req -> { NetSocket sock = getUpgradedNetSocket(req, "/some/path"); // 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); }); server.listen(ar -> { assertTrue(ar.succeeded()); client.websocketStream(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/some/path", null, WebsocketVersion.V13). handler(ws -> { AtomicReference<Throwable> failure = new AtomicReference<>(); ws.closeHandler(v -> { assertNotNull(failure.get()); testComplete(); }); ws.exceptionHandler(failure::set); }); }); await(); }
private SocketMessages testWriteTextMessages(List<String> messagesToSend, WebsocketVersion version) { String path = "/some/path"; server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)).websocketHandler(ws -> { for (String messageToSend : messagesToSend) { ws.writeTextMessage(messageToSend); } ws.close(); }); List<String> receivedMessages = new ArrayList<>(); List<Throwable> receivedExceptions = new ArrayList<>(); server.listen(ar -> { assertTrue(ar.succeeded()); client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, path, null, version, ws -> { ws.textMessageHandler(receivedMessages::add); ws.exceptionHandler(receivedExceptions::add); ws.closeHandler(v -> testComplete()); }); }); await(); return new SocketMessages(receivedMessages, receivedExceptions); }
@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(); }
/** * This does not set up a handler on the websocket */ private WebSocket setupRawWebsocketClient(String serverPath) throws InterruptedException { String requestURI = serverPath + "/websocket"; AtomicReference<WebSocket> openedWebSocketReference = new AtomicReference<>(); CountDownLatch openSocketCountDown = new CountDownLatch(1); client.websocket(requestURI, ws -> { openedWebSocketReference.set(ws); openSocketCountDown.countDown(); ws.endHandler(v -> testComplete()); ws.exceptionHandler(this::fail); }); openSocketCountDown.await(5, TimeUnit.SECONDS); return openedWebSocketReference.get(); }
vertxWebSocket.exceptionHandler(error -> { if (error instanceof ConnectException) { logger.error("Unable to connect to " + host + " port " + port, error);
public static void open(IpPort ipPort, String url, Handler<Void> onOpen, Handler<Void> onClose, Handler<Buffer> onMessage, Handler<Throwable> onException, Handler<Throwable> onConnectFailed) { HttpClientWithContext vertxHttpClient = WebsocketClientPool.INSTANCE.getClient(); vertxHttpClient.runOnContext(client -> { client.websocket(ipPort.getPort(), ipPort.getHostOrIp(), url, RestUtils.getDefaultHeaders().addAll(RestUtils .getSignAuthHeaders(RestUtils.createSignRequest(null, ipPort, new RequestParam(), url, new HashMap<>()))), ws -> { onOpen.handle(null); ws.exceptionHandler(v -> { onException.handle(v); try { ws.close(); } catch (Exception err) { LOGGER.error("ws close error.", err); } }); ws.closeHandler(v -> { onClose.handle(v); }); ws.handler(onMessage); }, onConnectFailed); }); } }
/** * This sets up a handler on the websocket */ private WebSocket setupSockJsClient(String serverPath, List<Buffer> receivedMessagesCollector) throws InterruptedException { String requestURI = serverPath + "/000/000/websocket"; AtomicReference<WebSocket> openedWebSocketReference = new AtomicReference<>(); CountDownLatch openSocketCountDown = new CountDownLatch(1); client.websocket(requestURI, ws -> { openedWebSocketReference.set(ws); ws.handler(replyBuffer -> { log.debug("Client received " + replyBuffer); String textReply = replyBuffer.toString(); if ("o".equals(textReply)) { openSocketCountDown.countDown(); } else { receivedMessagesCollector.add(replyBuffer); } }); ws.endHandler(v -> testComplete()); ws.exceptionHandler(this::fail); }); openSocketCountDown.await(5, TimeUnit.SECONDS); return openedWebSocketReference.get(); }
onOpen.handle(null); ws.exceptionHandler(v -> { onException.handle(v); try {
@Override public void handle(WebSocket webSocket) { connecting = false; connected = true; logger.info("Bridge Client - connected to server [" + remoteBridgeHost + ":" + remoteBridgePort + "]"); webSocket.write(Buffer.buffer( tenant + "\n" )); webSocket.write(Buffer.buffer( "START SESSION" + "\n" )); webSocket.pause(); final EventBusWebsocketBridge ebnb = new EventBusWebsocketBridge(webSocket, vertx.eventBus(), address); webSocket.closeHandler(aVoid -> { logger.error("Bridge Client - closed connection from server [" + remoteBridgeHost + ":" + remoteBridgePort + "]" + webSocket.textHandlerID()); ebnb.stop(); connected = false; }); webSocket.exceptionHandler(throwable -> { logger.error("Bridge Client - Exception: " + throwable.getMessage(), throwable); ebnb.stop(); connected = false; }); ebnb.setTenant(tenant); ebnb.start(); logger.info("Bridge Client - bridgeUUID: "+ ebnb.getBridgeUUID()); webSocket.resume(); }
@SuppressWarnings("squid:HiddenFieldCheck") private void connectSocket(final String url) { client.websocketAbs(url, null, null, null, socket -> { this.socket = socket; socketOpen = true; catnip.eventBus().publish(Raw.CONNECTED, shardInfo()); socket.frameHandler(this::handleSocketFrame) .closeHandler(this::handleSocketClose) .exceptionHandler(t -> catnip.logAdapter().error("Shard {}/{}: Exception in Websocket", id, limit, t)); }, failure -> { socket = null; socketOpen = false; catnip.logAdapter().error("Shard {}/{}: Couldn't connect socket:", id, limit, failure); catnip.eventBus().publish(Raw.CLOSED, shardInfo()); stateReply(ShardConnectState.FAILED); }); }