@OnOpen public void onOpen(Session session, @PathParam("uuid") String uuid) { UUID key = UUID.fromString(uuid); peers.put(key, session); JsonArrayBuilder builder = Json.createArrayBuilder(); for (StatusEventType statusEventType : StatusEventType.values()) { JsonObjectBuilder object = Json.createObjectBuilder(); builder.add(object.add(statusEventType.name(), statusEventType.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); } }
synchronized LSPProcess createProcess(String wsKey, String lang, RemoteEndpoint.Basic remoteEndpoint, String ownerSessionId) throws LSPException { String procKey = processKey(wsKey, lang); String rpcType = langContexts.get(lang).getRpcType(); String wsKeyElem[] = wsKey.split(WS_KEY_DELIMITER,3); disconnect(lang, ownerSessionId); LSPProcess lspProcess = new LSPProcess(wsKeyElem, lang, langContexts.get(lang).getProcessBuilder(wsKeyElem), remoteEndpoint, ownerSessionId); switch(rpcType) { case ENV_IPC_SOCKET: socketEnv(lspProcess, LangServerCtx.LangPrefix(lang)); break; case ENV_IPC_PIPES: pipeEnv(lspProcess, LangServerCtx.LangPrefix(lang)); break; case ENV_IPC_CLIENT: clientSocketEnv(lspProcess, LangServerCtx.LangPrefix(lang)); break; default: streamEnv(lspProcess); } lspProcesses.put(procKey, lspProcess); return lspProcess; }
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); } }
public void updateAllMap(int nc, boolean send, RemoteEndpoint.Basic... remotes) { for (int x = 0; x < data.length; x++) { for (int y = 0; y < data[0].length; y++) { if (nc != -1) { data[x][y] = nc; } if (send) { String msg = "update:" + x + ":" + y + ":" + data[x][y]; for (RemoteEndpoint.Basic remote : remotes) { try { remote.sendText(msg); } catch (IOException ex) { } } } } } }
@Before public void setupTest() throws Exception { this.origRegistry = MonitorWebsocket.getRegistry(); this.origSendTimeout = MonitorWebsocket.getSendTimeout(); this.origScheduler = MonitorWebsocket.getScheduler(); this.mockRegistry = Mockito.mock(MonitorWebsocketRegistry.class); this.mockScheduler = Mockito.mock(Scheduler.class); this.mockSession = Mockito.mock(Session.class); this.mockReason = Mockito.mock(CloseReason.class); this.mockAsyncRemote = Mockito.mock(RemoteEndpoint.Async.class); this.mockBasic = Mockito.mock(RemoteEndpoint.Basic.class); this.mockSendProcess = Mockito.mock(StepListSchedulerProcess.class); this.mockLogger = Mockito.mock(Logger.class); Mockito.when(this.mockSession.getId()).thenReturn("x-sess-id-x"); Mockito.when(this.mockSession.getAsyncRemote()).thenReturn(this.mockAsyncRemote); Mockito.when(this.mockSession.getBasicRemote()).thenReturn(this.mockBasic); }
/** * Test of sendMessageToClient method, of class CallServiceManager. */ @Test public void testSendMessageToClient() { System.out.println("sendMessageToClient"); Session client = mock(Session.class); MessageToClient mtc = mock(MessageToClient.class); RemoteEndpoint.Async async = mock(RemoteEndpoint.Async.class); when(client.getAsyncRemote()).thenReturn(async); when(messageToClientService.createMessageToClient(any(MessageFromClient.class), any(Session.class))).thenReturn(mtc).thenReturn(null); boolean result = instance.sendMessageToClient(new MessageFromClient(), client); assertThat(result).isTrue(); result = instance.sendMessageToClient(new MessageFromClient(), client); assertThat(result).isFalse(); ArgumentCaptor<MessageToClient> captureMsg = ArgumentCaptor.forClass(MessageToClient.class); verify(async).sendObject(captureMsg.capture()); assertThat(captureMsg.getValue()).isEqualTo(mtc); }
/** * Test of sendSubscriptionEvent method, of class TopicManager. */ @Test public void testSendSubscriptionEvent() { System.out.println("sendSubscriptionEvent"); Collection<Session> sessions = new ArrayList<>(); Session session = mock(Session.class); RemoteEndpoint.Async async = mock(RemoteEndpoint.Async.class); sessions.add(session); when(session.isOpen()).thenReturn(Boolean.FALSE).thenReturn(Boolean.TRUE); when(session.getAsyncRemote()).thenReturn(async); doReturn(Collections.EMPTY_LIST).doReturn(sessions).when(instance).getSessionsForTopic(TOPIC1); instance.sendSubscriptionEvent(TOPIC1, 1); instance.sendSubscriptionEvent(TOPIC1, 2); instance.sendSubscriptionEvent(TOPIC1, 3); ArgumentCaptor<MessageToClient> captureMsg = ArgumentCaptor.forClass(MessageToClient.class); verify(async).sendObject(captureMsg.capture()); MessageToClient msg = captureMsg.getValue(); assertThat(msg.getType()).isEqualTo(MessageType.MESSAGE); assertThat(msg.getId()).isEqualTo(TOPIC1); assertThat(msg.getResponse()).isEqualTo(3); }
/** * Test of checkAndSendMtcToSession method, of class. * * @throws javax.websocket.SessionException * @throws org.ocelotds.security.NotRecipientException */ @Test public void checkAndSendMtcToSessionTest() throws SessionException, NotRecipientException { System.out.println("checkAndSendMtcToSession"); Session session = mock(Session.class); RemoteEndpoint.Async async = mock(RemoteEndpoint.Async.class); when(session.isOpen()).thenReturn(true); when(session.getId()).thenReturn("ID1"); when(session.getAsyncRemote()).thenReturn(async); JsTopicMessageController jtmcmsgControl = mock(JsTopicMessageController.class); MessageToClient mtc = mock(MessageToClient.class); when(session.isOpen()).thenReturn(Boolean.TRUE); when(userContextFactory.getUserContext(eq("ID1"))).thenReturn(mock(UserContext.class)); doNothing().doThrow(NotRecipientException.class).when(instance).checkMessageTopic(any(UserContext.class), anyString(), eq(PAYLOAD), eq(jtmcmsgControl)); int result = instance.checkAndSendMtcToSession(session, jtmcmsgControl, mtc, PAYLOAD); assertThat(result).isEqualTo(1); result = instance.checkAndSendMtcToSession(session, jtmcmsgControl, mtc, PAYLOAD); assertThat(result).isEqualTo(0); }
@SuppressWarnings("unchecked") public void handle(final ByteBuffer buf, final Session session) throws IOException { WebSocketContext context = new WebSocketContext(this, session, config); final int id = buf.getInt(); currentContext.set(context); handle(buf.slice(), context).then(new Action<ByteBuffer>() { public void call(ByteBuffer value) throws Throwable { try { ByteBuffer buffer = ByteBuffer.allocate(4 + value.remaining()); buffer.putInt(id); buffer.put(value); buffer.flip(); final RemoteEndpoint.Async remote = session.getAsyncRemote(); remote.sendBinary(buffer); } finally { ByteBufferStream.free(value); } } }).whenComplete(new Runnable() { public void run() { currentContext.remove(); ByteBufferStream.free(buf); } }); }
@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); }
@Override public void onOpen(Session session, EndpointConfig arg1) { final RemoteEndpoint.Basic remote = session.getBasicRemote(); session.addMessageHandler(new MessageHandler.Whole<String>() { public void onMessage(String text) { try { remote.sendText(text.toUpperCase()); } catch (IOException ioe) { ioe.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(); }
public void join(User player2) { if (player2 == null) { return; } if (playing && checkOpen(player2)) { try { spectators.add(player2); player2.addMessageHandler(handler.new SpectatorHandler(player2)); RemoteEndpoint.Basic remote = player2.getBasicRemote(); remote.sendText("start:spectator"); updateAllMap(-1, true, player2.getBasicRemote()); remote.sendText("status:white:" + (turnToBlack ? "Waiting..." : "Holding...")); remote.sendText("status:black:" + (turnToBlack ? "Holding..." : "Waiting...")); remote.sendText("join:white:" + (player1IsWhite ? player1.getName() : this.player2.getName())); remote.sendText("join:black:" + (!player1IsWhite ? player1.getName() : this.player2.getName())); broadcast("join:spectator:" + player2.getName()); } catch (IOException ex) { spectators.remove(player2); } return; } this.player2 = player2; broadcast("join:" + (player1IsWhite ? "black" : "white") + ":" + player2.getName()); sendToPlayer2("join:" + (player1IsWhite ? "white" : "black") + ":" + player1.getName()); if (canStart()) { start(false); } player2.addMessageHandler(this.handler.new Player2Handler()); }
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(); } }
@Override public void onOpen(Session arg0, javax.websocket.EndpointConfig arg1) { // TODO Auto-generated method stub RemoteEndpoint.Basic remoteEndpointBasic = arg0.getBasicRemote(); arg0.addMessageHandler(new EchoMessageHandler(remoteEndpointBasic)); System.out.println("MyEndpoint OpOpen"); }
private void processSend() { List<String> activeTokenKeys = NetSystem.getInstance().getActiveTokenKeys(); Token token = null; String key = null; for (int i = 0; i < activeTokenKeys.size(); ++i) { key = activeTokenKeys.get(i); token = NetSystem.getInstance().getTokenByConnection(key); if (token == null || !token.isUsing()) { continue; } // token.formatSendPacket(mPacketFormat); int length = token.getNetStream().OutStreamLength(); if (token.getCanSend() && token.getNetStream().asyncPipeInIdle() && length > 0) { RemoteEndpoint re = (RemoteEndpoint)token.getConnection().getReal(); ByteBuffer bb = ByteBuffer.wrap(token.getNetStream().asyncPipeOut(), 0, length); ((RemoteEndpoint.Async)re).sendBinary(bb, getAsyncSendHandler(token).setLength(length)); token.setCanSend(false); } } }
/** * Test of removeSessionToTopics method, of class TopicManager. * * @throws java.lang.IllegalAccessException */ @Test public void testRemoveSessionToTopic() throws IllegalAccessException { System.out.println("removeSessionToTopic"); Session session = mock(Session.class); when(session.isOpen()).thenReturn(true); int result = instance.registerTopicSession(TOPIC1, session); assertThat(result).isEqualTo(1); assertThat(instance.getNumberSubscribers(TOPIC1)).isEqualTo(1); result = instance.registerTopicSession(TOPIC2, session); assertThat(result).isEqualTo(1); assertThat(instance.getNumberSubscribers(TOPIC2)).isEqualTo(1); Session session1 = mock(Session.class); when(session1.isOpen()).thenReturn(true); result = instance.registerTopicSession(TOPIC2, session1); assertThat(result).isEqualTo(2); assertThat(instance.getNumberSubscribers(TOPIC2)).isEqualTo(2); result = instance.registerTopicSession(SUBTOPIC2, session1); assertThat(result).isEqualTo(1); assertThat(instance.getNumberSubscribers(SUBTOPIC2)).isEqualTo(1); RemoteEndpoint.Async async = mock(RemoteEndpoint.Async.class); when(session1.getAsyncRemote()).thenReturn(async); instance.removeSessionToTopics(session); instance.removeSessionToTopics(null); assertThat(instance.getNumberSubscribers(TOPIC1)).isEqualTo(0); assertThat(instance.getNumberSubscribers(TOPIC2)).isEqualTo(1); ArgumentCaptor<MessageToClient> captureMsg = ArgumentCaptor.forClass(MessageToClient.class); verify(async).sendObject(captureMsg.capture()); MessageToClient msg = captureMsg.getValue(); assertThat(msg.getType()).isEqualTo(MessageType.MESSAGE); assertThat(msg.getId()).isEqualTo(Constants.Topic.SUBSCRIBERS + Constants.Topic.COLON + TOPIC2); assertThat(msg.getResponse()).isEqualTo(1); }
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(); } }
private void lockAndRun(InternalMessage message, Member destination, int retry) { try { RemoteEndpoint.Basic basic = destination.getSession().getBasicRemote(); synchronized (destination) { basic.sendObject(message.transformToExternalMessage()); } } catch (Exception e) { if (retry >= 0) { log.warn("Retrying... " + message.transformToExternalMessage()); send(message, --retry); } log.error("Unable to send message: " + message.transformToExternalMessage() + " error during sending!"); throw new RuntimeException("Unable to send message: " + message.transformToExternalMessage(), e); } }
protected Session mockSession(String id, ArgumentMatcher<Message> match) { Session s = mock(Session.class); when(s.getId()).thenReturn(id); when(s.isOpen()).thenReturn(true); Async mockAsync = mockAsync(match); RemoteEndpoint.Basic mockBasic = mockBasic(match); when(s.getAsyncRemote()).thenReturn(mockAsync); when(s.getBasicRemote()).thenReturn(mockBasic); return s; }
protected RemoteEndpoint.Basic mockBasic(ArgumentMatcher<Message> match) { try { RemoteEndpoint.Basic basic = mock(RemoteEndpoint.Basic.class); doNothing().when(basic).sendObject(Mockito.argThat(match)); return basic; } catch (Exception e) { throw new RuntimeException(e); } }
public TestClientActor(String name, Server server) { this.server = server; this.name = name; Session session = mock(Session.class); this.client = new MockedClient(server, session); when(session.getId()).thenReturn(name); when(session.isOpen()).thenReturn(true); RemoteEndpoint.Async async = mockAsync(session); RemoteEndpoint.Basic basic = mockBasic(); when(session.getAsyncRemote()).thenReturn(async); when(session.getBasicRemote()).thenReturn(basic); this.session = session; }
private RemoteEndpoint.Basic mockBasic() { try { RemoteEndpoint.Basic basic = mock(RemoteEndpoint.Basic.class); doNothing().when(basic).sendObject(Mockito.argThat(client)); return basic; } catch (Exception e) { throw new RuntimeException("", e); } }
private void broadcastEvent(ActivitiActivityEvent e) { ProcessEventDTO dto = ProcessEventDTO.builder().activityId(e.getActivityId()) .activityName(e.getActivityId()) .activityType(e.getType().toString()) .processId(e.getProcessInstanceId()) .build(); log.info("Activiti event received: " + e.getType()); RemoteEndpoint.Basic remoteEndpoint = session.getBasicRemote(); try { remoteEndpoint.sendText(om.writeValueAsString(dto)); } catch (IOException ex) { throw new RuntimeException(ex); } }
@Before public void setUp() { session = mock(Session.class); basicRemote = mock(RemoteEndpoint.Basic.class); when(session.getBasicRemote()).thenReturn(basicRemote); response = new WebSocketResponse(session); }
OutputStreamHandler(RemoteEndpoint.Basic remoteEndpointBasic, InputStream out) { this.remote = remoteEndpointBasic; this.out = out; }
@Override public RemoteEndpoint.Async getAsyncRemote() { checkState(); return remoteEndpointAsync; }
@Override public RemoteEndpoint.Basic getBasicRemote() { checkState(); return 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; }
private EchoMessageHandlerBinary(RemoteEndpoint.Basic remoteEndpointBasic) { this.remoteEndpointBasic = remoteEndpointBasic; }