javax.websocket.RemoteEndpoint Java Examples

@SuppressWarnings("ResultOfMethodCallIgnored")
@Before
public void setup() throws Exception{
    //setup mocks
    cle = new ClassLoaderEndpoint();
    session = mock(Session.class);
    RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.Async.class);
    doReturn(remoteEndpoint).when(session).getAsyncRemote();
    ((RemoteEndpoint.Async) doReturn(null).when(remoteEndpoint)).sendBinary(any(ByteBuffer.class));
    resourceRequest = mock(ResourceRequest.class);
    doReturn(UUID.randomUUID()).when(resourceRequest).getClassLoaderId();
    doReturn("resource1").when(resourceRequest).getResourceName();
    FressianWriter fressianWriter = mock(FressianWriter.class);
    doReturn(mock(Writer.class)).when(fressianWriter).writeObject(any(ResourceRequest.class));
    PowerMockito.whenNew(FressianWriter.class).withAnyArguments().thenReturn(fressianWriter);
}
 

protected final void processResult(Object result) {
    if (result == null) {
        return;
    }

    RemoteEndpoint.Basic remoteEndpoint = session.getBasicRemote();
    try {
        if (result instanceof String) {
            remoteEndpoint.sendText((String) result);
        } else if (result instanceof ByteBuffer) {
            remoteEndpoint.sendBinary((ByteBuffer) result);
        } else if (result instanceof byte[]) {
            remoteEndpoint.sendBinary(ByteBuffer.wrap((byte[]) result));
        } else {
            remoteEndpoint.sendObject(result);
        }
    } catch (IOException ioe) {
        throw new IllegalStateException(ioe);
    } catch (EncodeException ee) {
        throw new IllegalStateException(ee);
    }
}
 

protected final void processResult(Object result) {
    if (result == null) {
        return;
    }

    RemoteEndpoint.Basic remoteEndpoint = session.getBasicRemote();
    try {
        if (result instanceof String) {
            remoteEndpoint.sendText((String) result);
        } else if (result instanceof ByteBuffer) {
            remoteEndpoint.sendBinary((ByteBuffer) result);
        } else if (result instanceof byte[]) {
            remoteEndpoint.sendBinary(ByteBuffer.wrap((byte[]) result));
        } else {
            remoteEndpoint.sendObject(result);
        }
    } catch (IOException ioe) {
        throw new IllegalStateException(ioe);
    } catch (EncodeException ee) {
        throw new IllegalStateException(ee);
    }
}
 

@OnOpen
public void onOpen(Session session, @PathParam("uuid") String uuid) {
    UUID key = UUID.fromString(uuid);
    peers.put(key, session);
    JsonArrayBuilder builder = Json.createArrayBuilder();
    for (StatusMessage statusMessage : StatusMessage.values()) {
        JsonObjectBuilder object = Json.createObjectBuilder();
        builder.add(object.add(statusMessage.name(), statusMessage.getMessage()).build());
    }

    RemoteEndpoint.Async asyncRemote = session.getAsyncRemote();
    asyncRemote.sendText(builder.build().toString());
    // Send pending messages
    List<String> messages = messageBuffer.remove(key);
    if (messages != null) {
        messages.forEach(asyncRemote::sendText);
    }
}
 

protected final void processResult(Object result) {
    if (result == null) {
        return;
    }

    RemoteEndpoint.Basic remoteEndpoint = session.getBasicRemote();
    try {
        if (result instanceof String) {
            remoteEndpoint.sendText((String) result);
        } else if (result instanceof ByteBuffer) {
            remoteEndpoint.sendBinary((ByteBuffer) result);
        } else if (result instanceof byte[]) {
            remoteEndpoint.sendBinary(ByteBuffer.wrap((byte[]) result));
        } else {
            remoteEndpoint.sendObject(result);
        }
    } catch (IOException | EncodeException ioe) {
        throw new IllegalStateException(ioe);
    }
}
 

public static void executeRemoteCommand(Client client, String command) {
    LOGGER.info("Executing remote command ...");
    RemoteEndpoint.Basic remoteEndpoint = client.getRemoteEndpoint();
    String data = "{\"action\":\"read\",\"data\":\"" + command + "\\r\\n\"}";
    try {
        remoteEndpoint.sendBinary(ByteBuffer.wrap(data.getBytes()));
    } catch (IOException e) {
        e.printStackTrace();
    }
}
 

@Test
public void send() throws Exception {
  underTest.connect();
  RemoteEndpoint.Basic basicRemote = mock(RemoteEndpoint.Basic.class);
  doReturn(basicRemote).when(session).getBasicRemote();
  underTest.send(new Cancel());
  verify(basicRemote).sendBinary(ByteBuffer.wrap("{\"type\":\"CANCEL\"}".getBytes()));
}
 

@Test(expected = UncheckedIOException.class)
public void sendException() throws Exception {
  underTest.connect();
  RemoteEndpoint.Basic basicRemote = mock(RemoteEndpoint.Basic.class);
  doReturn(basicRemote).when(session).getBasicRemote();
  doThrow(IOException.class).when(basicRemote).sendBinary(any(ByteBuffer.class));
  underTest.send(new Cancel());
}
 

@Test
public void keepAlives() throws Exception {
  underTest.connect();
  RemoteEndpoint.Basic basicRemote = mock(RemoteEndpoint.Basic.class);
  doReturn(basicRemote).when(session).getBasicRemote();
  doReturn(true).when(session).isOpen();
  Awaitility.await().atMost(2, SECONDS).pollInterval(200, MILLISECONDS).until(() -> {
    try {
      verify(basicRemote).sendPong(any());
    } catch (Exception e) {
      fail();
    }
  });
}
 

public void subscribeBlocking(String topic, String filter, Consumer<String> onMessage)
        throws IOException, DeploymentException {

    ProgressUpdatesRequest progressUpdatesRequest = ProgressUpdatesRequest.subscribe(topic, filter);

    UpdatesMessageHandler updatesMessageHandler = new UpdatesMessageHandler(onMessage);

    WebSocketContainer container = ContainerProvider.getWebSocketContainer();
    String uri = "ws://localhost:8080/pnc-rest-new/" + NotificationsEndpoint.ENDPOINT_PATH;
    Session session = container.connectToServer(updatesMessageHandler, URI.create(uri));

    RemoteEndpoint.Basic asyncRemote = session.getBasicRemote();
    asyncRemote.sendText(toJson(progressUpdatesRequest));
}
 

@Override
public RemoteEndpoint.Basic getBasicRemote() {
    if (channel.eventLoop().inEventLoop()) {
        throw new IllegalStateException("Cannot use the basic remote from an IO thread");
    }
    return remote.getBasic();
}
 

public static void executeRemoteCommand(Client client, String command) {
  log.info("Executing remote command ...");
  RemoteEndpoint.Basic remoteEndpoint = client.getRemoteEndpoint();
  String data = "{\"action\":\"read\",\"data\":\"" + command + "\\r\\n\"}";
  try {
    remoteEndpoint.sendBinary(ByteBuffer.wrap(data.getBytes()));
  } catch (IOException e) {
    e.printStackTrace();
  }
}
 

public static void executeRemoteCommand(Client client, String command) {
  log.info("Executing remote command ...");
  RemoteEndpoint.Basic remoteEndpoint = client.getRemoteEndpoint();
  String data = "{\"action\":\"read\",\"data\":\"" + command + "\\r\\n\"}";
  try {
    remoteEndpoint.sendBinary(ByteBuffer.wrap(data.getBytes()));
  } catch (IOException e) {
    e.printStackTrace();
  }
}
 

public static String getIp(javax.websocket.Session session){
    RemoteEndpoint.Async async = session.getAsyncRemote();
    InetSocketAddress addr = (InetSocketAddress) getFieldInstance(async,
            "base#sos#socketWrapper#socket#sc#remoteAddress");
    if(addr == null){
        return "127.0.0.1";
    }
    return addr.getAddress().getHostAddress();
}
 

private EchoMessageHandlerBinary(RemoteEndpoint.Basic remoteEndpointBasic) {
    this.remoteEndpointBasic = remoteEndpointBasic;
}
 

@Override
public RemoteEndpoint.Async getAsyncRemote() {
    checkState();
    return remoteEndpointAsync;
}
 

@Override
public RemoteEndpoint.Basic getBasicRemote() {
    checkState();
    return remoteEndpointBasic;
}
 

@Override
public RemoteEndpoint.Async getAsyncRemote() {
    return delegate.getAsyncRemote();
}
 

@Override
public void onOpen(Session session, EndpointConfig endpointConfig) {
    RemoteEndpoint.Basic remoteEndpointBasic = session.getBasicRemote();
    session.addMessageHandler(new EchoMessageHandlerText(remoteEndpointBasic));
    session.addMessageHandler(new EchoMessageHandlerBinary(remoteEndpointBasic));
}
 

private EchoMessageHandlerText(RemoteEndpoint.Basic remoteEndpointBasic) {
    this.remoteEndpointBasic = remoteEndpointBasic;
}
 

public BinaryFrameOutputStream(RemoteEndpoint.Async remote) {
    this.buffer = ByteBuffer.allocate(DEFAULT_BUFFER_SIZE);
    this.remote = remote;
}
 

private EchoMessageHandlerBinary(RemoteEndpoint.Basic remoteEndpointBasic) {
    this.remoteEndpointBasic = remoteEndpointBasic;
}
 

@Override
public void onOpen(Session session, EndpointConfig endpointConfig) {
    RemoteEndpoint.Basic remoteEndpointBasic = session.getBasicRemote();
    session.addMessageHandler(new EchoMessageHandlerText(remoteEndpointBasic));
    session.addMessageHandler(new EchoMessageHandlerBinary(remoteEndpointBasic));
}
 

private EchoMessageHandlerText(RemoteEndpoint.Basic remoteEndpointBasic) {
    this.remoteEndpointBasic = remoteEndpointBasic;
}
 

@Override
public RemoteEndpoint.Async getAsyncRemote() {
	return asyncRemote;
}
 

@Override
public RemoteEndpoint.Basic getBasicRemote() {
	return basicRemote;
}
 

public RemoteEndpoint.Basic getRemoteEndpoint() {
    return endpoint.session.getBasicRemote();
}
 

public RemoteEndpoint.Basic getRemoteEndpoint() {
  return endpoint.session.getBasicRemote();
}
 

@Override
public RemoteEndpoint.Async getAsyncRemote() {
    return remote.getAsync();
}
 

private EchoMessageHandlerText(RemoteEndpoint.Basic remoteEndpointBasic) {
    this.remoteEndpointBasic = remoteEndpointBasic;
}