org.eclipse.jetty.websocket.api.RemoteEndpoint Java Examples

@Test
public void testSocket_write_string() throws IOException {
    final String queryString = ParseQS.encode(new HashMap<String, String>() {{
        put("transport", WebSocket.NAME);
    }});
    final UpgradeRequest upgradeRequest = Mockito.mock(UpgradeRequest.class);
    final RemoteEndpoint remoteEndpoint = Mockito.mock(RemoteEndpoint.class);
    final Session session = Mockito.mock(Session.class);
    final EngineIoServer server = Mockito.spy(new EngineIoServer());

    Mockito.doAnswer(invocationOnMock -> queryString).when(upgradeRequest).getQueryString();
    Mockito.doAnswer(invocationOnMock -> upgradeRequest).when(session).getUpgradeRequest();
    Mockito.doAnswer(invocationOnMock -> remoteEndpoint).when(session).getRemote();
    Mockito.doAnswer(invocationOnMock -> null).when(server).handleWebSocket(Mockito.any(EngineIoWebSocket.class));

    final JettyWebSocketHandler handler = new JettyWebSocketHandler(server);
    handler.onWebSocketConnect(session);

    final String message = "FooBar";
    handler.write(message);
    Mockito.verify(remoteEndpoint, Mockito.times(1))
            .sendString(Mockito.eq(message));
}
 

@Test
public void testSocket_write_binary() throws IOException {
    final String queryString = ParseQS.encode(new HashMap<String, String>() {{
        put("transport", WebSocket.NAME);
    }});
    final UpgradeRequest upgradeRequest = Mockito.mock(UpgradeRequest.class);
    final RemoteEndpoint remoteEndpoint = Mockito.mock(RemoteEndpoint.class);
    final Session session = Mockito.mock(Session.class);
    final EngineIoServer server = Mockito.spy(new EngineIoServer());

    Mockito.doAnswer(invocationOnMock -> queryString).when(upgradeRequest).getQueryString();
    Mockito.doAnswer(invocationOnMock -> upgradeRequest).when(session).getUpgradeRequest();
    Mockito.doAnswer(invocationOnMock -> remoteEndpoint).when(session).getRemote();
    Mockito.doAnswer(invocationOnMock -> null).when(server).handleWebSocket(Mockito.any(EngineIoWebSocket.class));

    final JettyWebSocketHandler handler = new JettyWebSocketHandler(server);
    handler.onWebSocketConnect(session);

    final byte[] message = new byte[16];
    (new Random()).nextBytes(message);
    handler.write(message);
    Mockito.verify(remoteEndpoint, Mockito.times(1))
            .sendBytes(Mockito.any(ByteBuffer.class));
}
 

@Override
public void send( final String message )
{
    final RemoteEndpoint endpoint = getRemote();
    if ( endpoint == null )
    {
        return;
    }

    try
    {
        endpoint.sendString( message );
    }
    catch ( final Exception e )
    {
        LOG.log( Level.SEVERE, "Failed to send web-socket message", e );
    }
}
 

@Override
public void send( final ByteSource bytes )
{
    final RemoteEndpoint endpoint = getRemote();
    if ( endpoint == null )
    {
        return;
    }

    try
    {
        final ByteBuffer buffer = ByteBuffer.wrap( bytes.read() );
        endpoint.sendBytes( buffer );
    }
    catch ( final Exception e )
    {
        LOG.log( Level.SEVERE, "Failed to send web-socket message", e );
    }
}
 

public boolean isConnected() {
    if (session == null || !session.isOpen()) {
        connected = false;
        return connected;
    }

    RemoteEndpoint remote = session.getRemote();

    ByteBuffer payload = ByteBuffer.allocate(4).putInt(ping++);
    try {
        remote.sendPing(payload);
    } catch (IOException e) {
        logger.error("Connection to {} lost {}", uri, e);
        connected = false;
    }

    return connected;
}
 

@Override
public void onWebSocketText(String message) {
  if (isNotConnected()) {
    return;
  }

  try {
    RemoteEndpoint remote = getRemote();
    remote.sendString(message, null);
    if (remote.getBatchMode() == BatchMode.ON) {
      remote.flush();
    }
  } catch (IOException x) {
    throw new RuntimeIOException(x);
  }
}
 

@Override
public void onWebSocketBinary(byte[] payload, int offset, int len) {
  if (isNotConnected()) {
    return;
  }

  try {
    RemoteEndpoint remote = getRemote();
    remote.sendBytes(BufferUtil.toBuffer(payload, offset, len), null);
    if (remote.getBatchMode() == BatchMode.ON) {
      remote.flush();
    }
  } catch (IOException x) {
    throw new RuntimeIOException(x);
  }
}
 

@Override
public void onWebSocketBinary(byte[] payload, int offset, int len) {
  if (isNotConnected()) {
    return;
  }

  try {
    RemoteEndpoint remote = getRemote();
    remote.sendBytes(BufferUtil.toBuffer(payload, offset, len), null);
    if (remote.getBatchMode() == BatchMode.ON) {
      remote.flush();
    }
  } catch (IOException x) {
    throw new RuntimeIOException(x);
  }
}
 

@OnWebSocketMessage
public void onMessage(String data) {
    try {
        Matcher matcher = BOARD_PATTERN.matcher(data);
        if (!matcher.matches()) {
            throw new IllegalArgumentException("Unexpected board format, should be: " + BOARD_FORMAT);
        }

        board.forString(matcher.group(1));
        print("Board: \n" + board);

        String answer = solver.get(board);
        print("Answer: " + answer);

        RemoteEndpoint remote = session.getRemote();
        if (remote == null) { // TODO to understand why this can happen?
            WebSocketRunner.this.tryToConnect();
            return;
        }
        remote.sendString(answer);
    } catch (Exception e) {
        print("Error processing data: " + data);
        print(e);
    }
    printBreak();
}
 

@Override
public void onWebSocketConnect(Session sess) {
  super.onWebSocketConnect(sess);
  try {
    Thread.sleep(1000);
  } catch (Exception e) {
  }
  final String textMessage = "PingPong";
  final ByteBuffer binaryMessage = ByteBuffer.wrap(
             textMessage.getBytes(StandardCharsets.UTF_8));

  try {
    RemoteEndpoint remote = getRemote();
    remote.sendPing(binaryMessage);
    if (remote.getBatchMode() == BatchMode.ON) {
      remote.flush();
    }
  } catch (IOException x) {
    throw new RuntimeIOException(x);
  }
}
 

private RemoteEndpoint getRemoteEndpoint() throws IOException {
	try {
		return getNativeSession().getRemote();
	}
	catch (WebSocketException ex) {
		throw new IOException("Unable to obtain RemoteEndpoint in session " + getId(), ex);
	}
}
 

public KafkaClient(String zooKeeper, String groupId, String topic, RemoteEndpoint remote) 
   {
       this.consumer = kafka.consumer.Consumer.createJavaConsumerConnector(
               createConsumerConfig(zooKeeper, groupId ));
       
       this.topic = topic;
       this.remote = remote;
}
 

private WebSocketHandler configuredHandler() {

		this.session = Mockito.mock( Session.class );
		this.remoteEndpoint = Mockito.mock( RemoteEndpoint.class );
		Mockito.when( this.session.getRemote()).thenReturn( this.remoteEndpoint );

		WebSocketHandler.addSession( this.session );
		WebSocketHandler handler = new WebSocketHandler();

		return handler;
	}
 

@Test
public void testProcess() throws Exception {

	HttpRoutingContext routingContext = new HttpRoutingContext();
	HttpDmClient httpDmClient = new HttpDmClient( routingContext );

	// Not connected => no processing
	Message message = Mockito.mock( Message.class );
	Session session = Mockito.mock( Session.class );
	Mockito.when( session.isOpen()).thenReturn( false );

	httpDmClient.process( session, message );
	Mockito.verifyZeroInteractions( message );
	Mockito.verify( session, Mockito.only()).isOpen();

	// Connected => processing...
	Mockito.reset( session );
	Future<Void> future = Mockito.mock( Future.class );
	RemoteEndpoint remote = Mockito.mock( RemoteEndpoint.class );
	Mockito.when( remote.sendBytesByFuture( Mockito.any( ByteBuffer.class ) )).thenReturn( future );

	Mockito.when( session.getRemote()).thenReturn( remote );
	Mockito.when( session.isOpen()).thenReturn( true );

	httpDmClient.process( session, message );

	Mockito.verifyZeroInteractions( message );
	Mockito.verify( session, Mockito.times( 1 )).isOpen();
	Mockito.verify( session, Mockito.times( 1 )).getRemote();
	Mockito.verifyNoMoreInteractions( session );
}
 

@Override
public void onWebSocketConnect(Session sess) {
  super.onWebSocketConnect(sess);

  try {
    RemoteEndpoint remote = getRemote();
    remote.sendString("echo", null);
    if (remote.getBatchMode() == BatchMode.ON) {
      remote.flush();
    }
  } catch (IOException x) {
    throw new RuntimeIOException(x);
  }
}
 

private void flushBufferedMessages(final RemoteEndpoint remote) throws IOException {
  LOG.debugLog("Flushing old buffered messages");
  for(String obj:messageBuffer) {
    LOG.debugLog("Sending old buffered message [From Backend <---]: " + obj);
    remote.sendString(obj);
  }
  messageBuffer.clear();
}
 

private PlayerSocket connectWebSocketClient(String authId) {
    when(authentication.authenticate(any(HttpServletRequest.class))).thenReturn(authId);

    PlayerSocket webSocket = createWebSocket();

    if (webSocket == null) return null;

    Session session = mock(Session.class);
    when(session.isOpen()).thenReturn(true);
    RemoteEndpoint remote = mock(RemoteEndpoint.class);
    when(session.getRemote()).thenReturn(remote);
    webSocket.onWebSocketConnect(session);
    return webSocket;
}
 

private RemoteEndpoint getRemote()
{
    try
    {
        return this.raw.getRemote();
    }
    catch ( final Exception e )
    {
        return null;
    }
}
 

private void sendMessage(String text) {
	if (BrowserVisualizationSocket.ENDPOINTS != null) {
		for (RemoteEndpoint rep : BrowserVisualizationSocket.ENDPOINTS) {
			try {
				rep.sendString(text);
			}
			catch(IOException e) { e.printStackTrace(); }
		}
	}
}
 

private RemoteEndpoint getRemoteEndpoint() throws IOException {
	try {
		return getNativeSession().getRemote();
	}
	catch (WebSocketException ex) {
		throw new IOException("Unable to obtain RemoteEndpoint in session " + getId(), ex);
	}
}
 

@Test
    public void shouldCollectErrors_whenSendDataToAllWebSocketClients() throws IOException {
        // given
        createServices(PlayerSocket.CLIENT_SEND_FIRST);

        createServerWebSocket("id1");
        createServerWebSocket("id2");
        createServerWebSocket("id3");

        PlayerSocket webSocket1 = connectWebSocketClient("id1");
        PlayerSocket webSocket2 = connectWebSocketClient("id2");
        PlayerSocket webSocket3 = connectWebSocketClient("id3");

        // when client answer
        answerClient(webSocket1);
        answerClient(webSocket2);
        answerClient(webSocket3);

        // simulate errors
        RemoteEndpoint remote1 = webSocket1.getSession().getRemote();
        doThrow(new IOException("Error1")).when(remote1).sendString(anyString());

        RemoteEndpoint remote2 = webSocket2.getSession().getRemote();
        doThrow(new IOException("Error2")).when(remote2).sendString(anyString());

        RemoteEndpoint remote3 = webSocket3.getSession().getRemote();
        doThrow(new IOException("Error3")).when(remote3).sendString(anyString());

        // when send state
//        try { // TODO мы не ловим больше ошибков а потому надо про другому проверить факт недосылки
            transport.sendStateToAll(new LinkedHashMap<String, Integer>() {{
                put("one", 1);
                put("two", 2);
                put("three", 3);
            }});

//            fail("Expected exception");
//        } catch (Exception e) {
//            // then
//            assertEquals("Error during send state to all players: [Error1, Error2, Error3]",
//                    e.getMessage());
//        }
    }
 

public RemoteEndpoint getRemote() {
    return this.session.getRemote();
}
 

public RemoteEndpoint getRemote() {
    return this.session.getRemote();
}
 

public RemoteEndpoint getRemote() {
    return this.session.getRemote();
}
 

public RemoteEndpoint getRemote() {
    return this.session.getRemote();
}
 

public RemoteEndpoint getRemote() {
    return this.session.getRemote();
}
 

public KafkaConsumer( RemoteEndpoint remote, KafkaStream a_stream, int a_threadNumber) 
{
    this.m_threadNumber = a_threadNumber;
    this.m_stream = a_stream;
    this.remote = remote;
}
 

@Override
public RemoteEndpoint getRemote() {
  return null;
}