@Override public void onSuccess(WebSocketResponseMessage webSocketResponseMessage) { client.close(1001, "All you get."); }
@Override public void onDispatchSubscribed(String channel) { try { ProvisioningAddress address = new ProvisioningAddress(channel); this.client.sendRequest("PUT", "/v1/address", null, Optional.of(ProvisioningUuid.newBuilder() .setUuid(address.getAddress()) .build() .toByteArray())); } catch (InvalidWebsocketAddressException e) { logger.warn("Badly formatted address", e); this.client.close(1001, "Server Error"); } }
@Override public void onDispatchMessage(String channel, byte[] message) { try { PubSubMessage outgoingMessage = PubSubMessage.parseFrom(message); if (outgoingMessage.getType() == PubSubMessage.Type.DELIVER) { Optional<byte[]> body = Optional.of(outgoingMessage.getContent().toByteArray()); ListenableFuture<WebSocketResponseMessage> response = client.sendRequest("PUT", "/v1/message", null, body); Futures.addCallback(response, new FutureCallback<WebSocketResponseMessage>() { @Override public void onSuccess(WebSocketResponseMessage webSocketResponseMessage) { client.close(1001, "All you get."); } @Override public void onFailure(Throwable throwable) { client.close(1001, "That's all!"); } }); } } catch (InvalidProtocolBufferException e) { logger.warn("Protobuf Error: ", e); } }
@Override public void onDispatchMessage(String channel, byte[] message) { try { PubSubMessage pubSubMessage = PubSubMessage.parseFrom(message); switch (pubSubMessage.getType().getNumber()) { case PubSubMessage.Type.QUERY_DB_VALUE: processStoredMessages(); break; case PubSubMessage.Type.DELIVER_VALUE: sendMessage(Envelope.parseFrom(pubSubMessage.getContent()), Optional.empty(), false); break; case PubSubMessage.Type.CONNECTED_VALUE: if (pubSubMessage.hasContent() && !new String(pubSubMessage.getContent().toByteArray()).equals(connectionId)) { client.hardDisconnectQuietly(); } break; default: logger.warn("Unknown pubsub message: " + pubSubMessage.getType().getNumber()); } } catch (InvalidProtocolBufferException e) { logger.warn("Protobuf parse error", e); } }
@Override public void onWebSocketConnect(Session session) { this.session = session; this.remoteEndpoint = session.getRemote(); this.context = new WebSocketSessionContext(new WebSocketClient(session, remoteEndpoint, messageFactory, requestMap)); this.context.setAuthenticated(authenticated); this.session.setIdleTimeout(idleTimeoutMillis); if (connectListener.isPresent()) { connectListener.get().onWebSocketConnect(this.context); } }
public ListenableFuture<WebSocketResponseMessage> sendRequest(String verb, String path, List<String> headers, Optional<byte[]> body) { final long requestId = generateRequestId(); final SettableFuture<WebSocketResponseMessage> future = SettableFuture.create(); pendingRequestMapper.put(requestId, future); WebSocketMessage requestMessage = messageFactory.createRequest(Optional.of(requestId), verb, path, headers, body); try { remoteEndpoint.sendBytes(ByteBuffer.wrap(requestMessage.toByteArray()), new WriteCallback() { @Override public void writeFailed(Throwable x) { logger.debug("Write failed", x); pendingRequestMapper.remove(requestId); future.setException(x); } @Override public void writeSuccess() {} }); } catch (WebSocketException e) { logger.debug("Write", e); pendingRequestMapper.remove(requestId); future.setException(e); } return future; }
ListenableFuture<WebSocketResponseMessage> response = client.sendRequest("PUT", "/api/v1/message", Collections.singletonList(header), body);
private void processStoredMessages() { OutgoingMessageEntityList messages = messagesManager.getMessagesForDevice(account.getNumber(), device.getId()); Iterator<OutgoingMessageEntity> iterator = messages.getMessages().iterator(); while (iterator.hasNext()) { OutgoingMessageEntity message = iterator.next(); Envelope.Builder builder = Envelope.newBuilder() .setType(Envelope.Type.valueOf(message.getType())) .setTimestamp(message.getTimestamp()) .setServerTimestamp(message.getServerTimestamp()); if (!Util.isEmpty(message.getSource())) { builder.setSource(message.getSource()) .setSourceDevice(message.getSourceDevice()); } if (message.getMessage() != null) { builder.setLegacyMessage(ByteString.copyFrom(message.getMessage())); } if (message.getContent() != null) { builder.setContent(ByteString.copyFrom(message.getContent())); } if (message.getRelay() != null && !message.getRelay().isEmpty()) { builder.setRelay(message.getRelay()); } sendMessage(builder.build(), Optional.of(new StoredMessageInfo(message.getId(), message.isCached())), !iterator.hasNext() && messages.hasMore()); } if (!messages.hasMore()) { client.sendRequest("PUT", "/api/v1/queue/empty", null, Optional.empty()); } }
@Override public void onFailure(Throwable throwable) { client.close(1001, "That's all!"); } });
@GET @Path("/prompt") public Response askMe(@Auth HelloAccount account, @WebSocketSession WebSocketSessionContext context) { ListenableFuture<WebSocketResponseMessage> response = context.getClient().sendRequest("GET", "/hello", new LinkedList<>(), Optional.empty()); Futures.addCallback(response, new FutureCallback<WebSocketResponseMessage>() { @Override public void onSuccess(WebSocketResponseMessage result) { logger.warn("Got response: " + new String(result.getBody().orElse(null))); } @Override public void onFailure(Throwable t) { logger.warn("Request error", t); } }); return Response.ok().build(); }
@Override public void onDispatchUnsubscribed(String channel) { this.client.close(1001, "Closed"); } }
@Override public void onDispatchUnsubscribed(String channel) { client.close(1000, "OK"); }
@Timed @GET public Response getKeepAlive(@Auth Account account, @WebSocketSession WebSocketSessionContext context) { if (account != null) { WebsocketAddress address = new WebsocketAddress(account.getNumber(), account.getAuthenticatedDevice().get().getId()); if (!pubSubManager.hasLocalSubscription(address)) { logger.warn("***** No local subscription found for: " + address); context.getClient().close(1000, "OK"); } } return Response.ok().build(); }