io.vertx.core.http.WebSocketBase Java Examples

private void messageHandler(WebSocketBase socket, WebSocketMessage message) {
    if (message.getType() == WebSocketMessage.Type.TEXT) {
        String payload = message.getPayloadAsText();
        socket.writeTextMessage(payload);
    } else {
        Buffer buffer = bufferConverter.toBuffer(message.getPayload());

        if (message.getType() == WebSocketMessage.Type.PING) {
            socket.writePing(buffer);
        } else if (message.getType() == WebSocketMessage.Type.PONG) {
            socket.writePong(buffer);
        } else {
            socket.writeBinaryMessage(buffer);
        }
    }
}
 

@Test
public void websocketServiceRemoveSubscriptionOnConnectionClose(final TestContext context) {
  final Async async = context.async();

  vertx
      .eventBus()
      .consumer(SubscriptionManager.EVENTBUS_REMOVE_SUBSCRIPTIONS_ADDRESS)
      .handler(
          m -> {
            context.assertNotNull(m.body());
            async.complete();
          })
      .completionHandler(v -> httpClient.websocket("/", WebSocketBase::close));

  async.awaitSuccess(VERTX_AWAIT_TIMEOUT_MILLIS);
}
 

@Test
public void testHookSocketClosed() throws Exception {

  sockJSHandler.bridge(allAccessOptions, be -> {
    if (be.type() == BridgeEventType.SOCKET_CLOSED) {
      assertNotNull(be.socket());
      assertNull(be.getRawMessage());
      be.complete(true);
      testComplete();
    } else {
      be.complete(true);
    }
  });
  client.webSocket(websocketURI, onSuccess(WebSocketBase::close));
  await();
}
 

@Override
public Flux<WebSocketMessage> receive() {
    return Flux.create(sink -> {
            logger.debug("{}Connecting to a web socket read stream", getLogPrefix());
            WebSocketBase socket = getDelegate();
            socket.pause()
                .textMessageHandler(payload -> {
                    logger.debug("{}Received text '{}' from a web socket read stream", getLogPrefix(), payload);
                    sink.next(textMessage(payload));
                })
                .binaryMessageHandler(payload -> {
                    logger.debug("{}Received binary '{}' from a web socket read stream", getLogPrefix(), payload);
                    sink.next(binaryMessage(payload));
                })
                .pongHandler(payload -> {
                    logger.debug("{}Received pong '{}' from a web socket read stream", getLogPrefix(), payload);
                    sink.next(pongMessage(payload));
                })
                .exceptionHandler(throwable -> {
                    logger.debug("{}Received exception '{}' from a web socket read stream", getLogPrefix(), throwable);
                    sink.error(throwable);
                })
                .endHandler(e -> {
                    logger.debug("{}Web socket read stream ended", getLogPrefix());
                    sink.complete();
                });
            sink.onRequest(i -> {
                logger.debug("{}Fetching '{}' entries from a web socket read stream", getLogPrefix(), i);
                socket.fetch(i);
            });
        }
    );
}
 

@Override
public Mono<Void> send(Publisher<WebSocketMessage> messages) {
    return Mono.create(sink -> {
        logger.debug("{}Subscribing to messages publisher", getLogPrefix());
        Subscriber<WebSocketMessage> subscriber =
            new WriteStreamSubscriber.Builder<WebSocketBase, WebSocketMessage>()
                .writeStream(getDelegate())
                .nextHandler(this::messageHandler)
                .endHook(sink)
                .build();
        messages.subscribe(subscriber);
    });
}
 

@Test
public void testCloseEvent(TestContext context) throws Exception {
  Async async = context.async();
  vertx.eventBus().consumer(BridgeEventType.SOCKET_CLOSED.toString(), ebMsg -> {
    context.assertEquals(BridgeEventType.SOCKET_CLOSED.toString(), ebMsg.body());
    async.complete();
  });
  client().websocket("/eventbus/default/websocket", WebSocketBase::close);
}
 

@Test
public void testWebSocketFailure() throws Exception {
  String expected = TestUtils.randomAlphaString(64);
  socketHandler = () -> socket -> {
    socket.endHandler(v -> {
      socket.write(Buffer.buffer(expected), onFailure(err -> {
        testComplete();
      }));
    });
  };
  startServers();
  client.webSocket("/test/400/8ne8e94a/websocket", onSuccess(WebSocketBase::close));
  await();
}
 

@Test
public void testRawFailure() throws Exception {
  String expected = TestUtils.randomAlphaString(64);
  socketHandler = () -> socket -> {
    socket.endHandler(v -> {
      socket.write(Buffer.buffer(expected), onFailure(err -> {
        testComplete();
      }));
    });
  };
  startServers();
  client.webSocket("/test/websocket", onSuccess(WebSocketBase::close));
  await();
}
 

@Override
public WebSocketBase textMessageHandler(@Nullable Handler<String> handler) {
  delegate.textMessageHandler(handler);
  return this;
}
 

public MQTTWebSocketWrapper(WebSocketBase netSocket) {
    super(netSocket);
}
 

public WebSocketWrapper(WebSocketBase netSocket) {
    super(netSocket, netSocket);
}
 

public EventBusWebsocketBridge(WebSocketBase webSocket, EventBus eventBus, String eventBusAddress) {
    this.eventBus = eventBus;
    this.webSocket = webSocket;
    this.eventBusAddress = eventBusAddress;
    this.bridgeUUID = UUID.randomUUID().toString();
}
 

@Override
public WebSocketBase pongHandler(@Nullable Handler<Buffer> handler) {
  delegate.pongHandler(handler);
  return this;
}
 

@Override
public WebSocketBase binaryMessageHandler(@Nullable Handler<Buffer> handler) {
  delegate.binaryMessageHandler(handler);
  return this;
}
 

@Override
public WebSocketBase writePong(Buffer data, Handler<AsyncResult<Void>> handler) {
  delegate.writePong(data, handler);
  return this;
}
 

@Override
public WebSocketBase writePing(Buffer data, Handler<AsyncResult<Void>> handler) {
  delegate.writePing(data, handler);
  return this;
}
 

public VertxWebSocketSession(WebSocketBase delegate, HandshakeInfo handshakeInfo, BufferConverter bufferConverter) {
    super(delegate, ObjectUtils.getIdentityHexString(delegate), handshakeInfo,
        bufferConverter.getDataBufferFactory());
    this.bufferConverter = bufferConverter;
}