@Override public void onFailure(Throwable throwable) { client.close(1001, "That's all!"); } });
@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 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 run(ServerConfiguration serverConfiguration, Environment environment) throws Exception { WebSocketEnvironment webSocketEnvironment = new WebSocketEnvironment(environment, serverConfiguration.getWebSocketConfiguration()); HelloResource helloResource = new HelloResource(serverConfiguration.getHelloResponse()); HelloAccountBasicAuthenticator helloBasicAuthenticator = new HelloAccountBasicAuthenticator(); environment.jersey().register(helloResource); environment.jersey().register(new AuthDynamicFeature(new BasicCredentialAuthFilter.Builder<HelloAccount>() .setAuthenticator(helloBasicAuthenticator) .setPrincipal(HelloAccount.class) .buildAuthFilter())); environment.jersey().register(new AuthValueFactoryProvider.Binder()); webSocketEnvironment.jersey().register(helloResource); webSocketEnvironment.setAuthenticator(new HelloAccountWebSocketAuthenticator(helloBasicAuthenticator)); WebSocketResourceProviderFactory servlet = new WebSocketResourceProviderFactory(webSocketEnvironment); ServletRegistration.Dynamic websocket = environment.servlets().addServlet("WebSocket", servlet); websocket.addMapping("/websocket/*"); websocket.setAsyncSupported(true); servlet.start(); }
WebSocketEnvironment webSocketEnvironment = new WebSocketEnvironment(environment, config.getWebSocketConfiguration(), 90000); webSocketEnvironment.setAuthenticator(new WebSocketAccountAuthenticator(deviceAuthenticator)); webSocketEnvironment.setConnectListener(new AuthenticatedConnectListener(pushSender, receiptSender, messagesManager, pubSubManager, apnFallbackManager)); webSocketEnvironment.jersey().register(new KeepAliveController(pubSubManager)); webSocketEnvironment.jersey().register(messageController); webSocketEnvironment.jersey().register(profileController); WebSocketEnvironment provisioningEnvironment = new WebSocketEnvironment(environment, webSocketEnvironment.getRequestLog(), 60000); provisioningEnvironment.setConnectListener(new ProvisioningConnectListener(pubSubManager)); provisioningEnvironment.jersey().register(new KeepAliveController(pubSubManager)); WebSocketResourceProviderFactory webSocketServlet = new WebSocketResourceProviderFactory(webSocketEnvironment ); WebSocketResourceProviderFactory provisioningServlet = new WebSocketResourceProviderFactory(provisioningEnvironment); provisioning.setAsyncSupported(true); webSocketServlet.start(); provisioningServlet.start();
@Override public void onWebSocketBinary(byte[] payload, int offset, int length) { try { WebSocketMessage webSocketMessage = messageFactory.parseMessage(payload, offset, length); switch (webSocketMessage.getType()) { case REQUEST_MESSAGE: handleRequest(webSocketMessage.getRequestMessage()); break; case RESPONSE_MESSAGE: handleResponse(webSocketMessage.getResponseMessage()); break; default: close(session, 1018, "Badly formatted"); break; } } catch (InvalidMessageException e) { logger.debug("Parsing", e); close(session, 1018, "Badly formatted"); } }
@Override public Object createWebSocket(ServletUpgradeRequest request, ServletUpgradeResponse response) { try { Optional<WebSocketAuthenticator> authenticator = Optional.ofNullable(environment.getAuthenticator()); Object authenticated = null; if (authenticator.isPresent()) { AuthenticationResult authenticationResult = authenticator.get().authenticate(request); if (!authenticationResult.getUser().isPresent() && authenticationResult.isRequired()) { response.sendForbidden("Unauthorized"); return null; } else { authenticated = authenticationResult.getUser().orElse(null); } } return new WebSocketResourceProvider(this.environment.getJerseyServletContainer(), this.environment.getRequestLog(), authenticated, this.environment.getMessageFactory(), Optional.ofNullable(this.environment.getConnectListener()), this.environment.getIdleTimeoutMillis()); } catch (AuthenticationException | IOException e) { logger.warn("Authentication failure", e); return null; } }
private void handleRequest(WebSocketRequestMessage requestMessage) { try { HttpServletRequest servletRequest = createRequest(requestMessage, context); HttpServletResponse servletResponse = createResponse(requestMessage); servlet.service(servletRequest, servletResponse); servletResponse.flushBuffer(); requestLog.log(new LoggableRequest(servletRequest), new LoggableResponse(servletResponse)); } catch (IOException | ServletException e) { logger.warn("Servlet Error: " + requestMessage.getVerb() + " " + requestMessage.getPath() + "\n" + requestMessage.getBody(), e); sendErrorResponse(requestMessage, Response.status(500).build()); } }
@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(); }
@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(); }
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; }
@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 void start() throws ServletException { this.environment.getJerseyServletContainer().init(new WServletConfig()); }
@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 onWebSocketError(Throwable cause) { logger.debug("onWebSocketError", cause); close(session, 1011, "Server error"); }
ListenableFuture<WebSocketResponseMessage> response = client.sendRequest("PUT", "/api/v1/message", Collections.singletonList(header), body);
@Override public void onDispatchUnsubscribed(String channel) { this.client.close(1001, "Closed"); } }
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 onSuccess(WebSocketResponseMessage webSocketResponseMessage) { client.close(1001, "All you get."); }
@Override public void onDispatchUnsubscribed(String channel) { client.close(1000, "OK"); }