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()); }
private void handleMetaConnect(ServerSessionImpl session, Mutable message, Promise<Boolean> promise) { ServerMessage.Mutable reply = message.getAssociated(); if (session.connected()) { reply.setSuccessful(true); Map<String, Object> adviceIn = message.getAdvice(); if (adviceIn != null) { Number timeout = (Number)adviceIn.get("timeout"); session.updateTransientTimeout(timeout == null ? -1L : timeout.longValue()); Number interval = (Number)adviceIn.get("interval"); session.updateTransientInterval(interval == null ? -1L : interval.longValue()); // Force the server to send the advice, as the client may // have forgotten it (for example because of a reload) session.reAdvise(); } else { session.updateTransientTimeout(-1); session.updateTransientInterval(-1); } Map<String, Object> adviceOut = session.takeAdvice(message.getServerTransport()); if (adviceOut != null) { reply.put(Message.ADVICE_FIELD, adviceOut); } promise.succeed(true); } else { unknownSession(reply); promise.succeed(false); } }
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; } }
} else { advice.put(Message.RECONNECT_FIELD, Message.RECONNECT_NONE_VALUE); reply.setSuccessful(false);
} else { advice.put(Message.RECONNECT_FIELD, Message.RECONNECT_NONE_VALUE); reply.setSuccessful(false);
} else { if (channel.unsubscribe(session, message)) { reply.setSuccessful(true); loop.proceed(true); } else {
private void handleMetaSubscribe2(ServerSessionImpl session, Mutable message, ServerChannelImpl channel, Promise<Boolean> promise) { ServerMessage.Mutable reply = message.getAssociated(); isSubscribeAuthorized(channel, session, message, Promise.from(subscribeResult -> { if (subscribeResult instanceof Authorizer.Result.Denied) { String denyReason = ((Authorizer.Result.Denied)subscribeResult).getReason(); error(reply, "403:" + denyReason + ":subscribe_denied"); promise.succeed(false); } else { if (channel.subscribe(session, message)) { reply.setSuccessful(true); promise.succeed(true); } else { error(reply, "403::subscribe_failed"); promise.succeed(false); } } }, promise::fail)); }
private void handleMetaHandshake2(ServerSessionImpl session, Mutable message, Promise<Boolean> promise) { ServerMessage.Mutable reply = message.getAssociated(); if (session.handshake(message)) { addServerSession(session, message); reply.setSuccessful(true); reply.setClientId(session.getId()); reply.put(Message.VERSION_FIELD, "1.0"); reply.put(Message.MIN_VERSION_FIELD, "1.0"); reply.put(Message.SUPPORTED_CONNECTION_TYPES_FIELD, getAllowedTransports()); Map<String, Object> adviceOut = session.takeAdvice(message.getServerTransport()); reply.put(Message.ADVICE_FIELD, adviceOut); promise.succeed(true); } else { error(reply, "403::handshake_failed"); promise.succeed(false); } }
@Override public void disconnect() { boolean connected = _bayeux.removeServerSession(this, false); if (connected) { ServerMessage.Mutable message = _bayeux.newMessage(); message.setSuccessful(true); message.setChannel(Channel.META_DISCONNECT); deliver(this, message, new Promise<Boolean>() { @Override public void succeed(Boolean result) { flush(); } }); } }
private void handle3(ServerSessionImpl session, ServerMessage.Mutable message, ServerChannelImpl channel, Promise<ServerMessage.Mutable> promise) { ServerMessage.Mutable reply = message.getAssociated(); if (channel.isMeta()) { publish(session, channel, message, true, Promise.from(published -> promise.succeed(reply), promise::fail)); } else { isPublishAuthorized(channel, session, message, Promise.from(result -> { if (result instanceof Authorizer.Result.Denied) { String denyReason = ((Authorizer.Result.Denied)result).getReason(); error(reply, "403:" + denyReason + ":publish denied"); promise.succeed(reply); } else { reply.setSuccessful(true); publish(session, channel, message, true, Promise.from(published -> promise.succeed(reply), promise::fail)); } }, promise::fail)); } }
protected void error(ServerMessage.Mutable reply, String error) { if (reply != null) { reply.put(Message.ERROR_FIELD, error); reply.setSuccessful(false); } }
private void handleMetaDisconnect(ServerSessionImpl session, Mutable message, Promise<Boolean> promise) { ServerMessage.Mutable reply = message.getAssociated(); reply.setSuccessful(true); removeServerSession(session, false); // Wake up the possibly pending /meta/connect session.flush(); promise.succeed(true); }