private void messageFailure(ServerMessage message, Throwable cause) { ServerMessage.Mutable failed = newMessage(); failed.setId(message.getId()); failed.setSuccessful(false); failed.setChannel(message.getChannel()); if (message.containsKey(Message.SUBSCRIPTION_FIELD)) { failed.put(Message.SUBSCRIPTION_FIELD, message.get(Message.SUBSCRIPTION_FIELD)); } Map<String, Object> failure = new HashMap<>(); failed.put("failure", failure); failure.put("message", message); failure.put("exception", cause); receive(failed, Promise.noop()); }
protected void publish(ServerSessionImpl session, ServerChannelImpl channel, ServerMessage.Mutable message, boolean receiving, Promise<Boolean> promise) { if (_logger.isDebugEnabled()) { _logger.debug("< {} {}", message, session); } if (channel.isBroadcast()) { // Do not leak the clientId to other subscribers // as we are now "sending" this message. message.setClientId(null); // Reset the messageId to avoid clashes with message-based transports such // as websocket whose clients may rely on the messageId to match request/responses. message.setId(null); } notifyListeners(session, channel, message, Promise.from(proceed -> { if (proceed) { publish2(session, channel, message, receiving, promise); } else { ServerMessageImpl reply = (ServerMessageImpl)message.getAssociated(); if (reply != null && !reply.isHandled()) { error(reply, "404::message_deleted"); } promise.succeed(false); } }, promise::fail)); }
private boolean deliver(Object data, boolean successful) { boolean completed = complete.compareAndSet(false, true); if (completed) { ServerMessage.Mutable message = bayeux.newMessage(); message.setId(messageId); message.setSuccessful(successful); message.setChannel(channel); message.setData(data); session.deliver(sender, message, Promise.noop()); } return completed; } }
@Override public void handshake(Map<String, Object> template, ClientSession.MessageListener callback) { if (_session != null) { throw new IllegalStateException(); } ServerSessionImpl session = new ServerSessionImpl(_bayeux, this, _idHint); ServerMessage.Mutable hsMessage = newMessage(); if (template != null) { hsMessage.putAll(template); } String messageId = newMessageId(); hsMessage.setId(messageId); hsMessage.setChannel(Channel.META_HANDSHAKE); registerCallback(messageId, callback); doSend(session, hsMessage, Promise.from(hsReply -> { if (hsReply != null && hsReply.isSuccessful()) { _session = session; ServerMessage.Mutable cnMessage = newMessage(); cnMessage.setId(newMessageId()); cnMessage.setChannel(Channel.META_CONNECT); cnMessage.getAdvice(true).put(Message.INTERVAL_FIELD, -1L); cnMessage.setClientId(session.getId()); doSend(session, cnMessage, Promise.from(cnReply -> { // Nothing more to do. }, failure -> messageFailure(cnMessage, failure))); } }, failure -> messageFailure(hsMessage, failure))); }
private void doSend(ServerSessionImpl session, ServerMessage.Mutable message, Promise<ServerMessage.Mutable> promise) { String messageId = message.getId(); message.setClientId(session.getId()); extendOutgoing(message, Promise.from(result -> { // Extensions may have changed the messageId. message.setId(messageId); if (result) { _bayeux.handle(session, message, Promise.from(r -> _bayeux.extendReply(session, _session, r, Promise.from(reply -> { if (reply != null) { receive(reply, Promise.from(y -> promise.succeed(reply), promise::fail)); } else { promise.succeed(null); } }, promise::fail)), promise::fail)); } else { ServerMessage.Mutable reply = _bayeux.createReply(message); _bayeux.error(reply, "404::message_deleted"); receive(reply, Promise.from(y -> promise.succeed(reply), promise::fail)); } }, promise::fail)); }
@Override public void disconnect(ClientSession.MessageListener callback) { if (_session != null) { ServerMessage.Mutable message = newMessage(); String messageId = newMessageId(); message.setId(messageId); message.setChannel(Channel.META_DISCONNECT); message.setClientId(_session.getId()); registerCallback(messageId, callback); send(message); while (isBatching()) { endBatch(); } } }