@Override public boolean sendMeta(ServerSession session, ServerMessage.Mutable message) { if (!Channel.META_CONNECT.equals(message.getChannel()) && activity == Activity.CLIENT_SERVER) { if (logger.isDebugEnabled()) { logger.debug("Marking active session {}, sending meta message {}", session, message); } markActive(); } return true; }
@Override public boolean sendMeta(ServerSession to, Mutable message) { String channel = message.getChannel(); Map<String, Object> ext = message.getExt(true); if (channel.equals(Channel.META_HANDSHAKE)) { if (_session.isAllowMessageDeliveryDuringHandshake()) { long batch = closeBatch(message); Map<String, Object> ack = new HashMap<>(3); ack.put("enabled", true); ack.put("batch", batch); ext.put("ack", ack); if (_logger.isDebugEnabled()) { _logger.debug("Sending batch {} for {}", batch, _session); } } else { ext.put("ack", Boolean.TRUE); } } else if (channel.equals(Channel.META_CONNECT)) { long batch = closeBatch(message); ext.put("ack", batch); if (_logger.isDebugEnabled()) { _logger.debug("Sending batch {} for {}", batch, _session); } } return true; }
protected void unknownSession(Mutable reply) { error(reply, "402::Unknown client"); if (Channel.META_HANDSHAKE.equals(reply.getChannel()) || Channel.META_CONNECT.equals(reply.getChannel())) { Map<String, Object> advice = reply.getAdvice(true); advice.put(Message.RECONNECT_FIELD, Message.RECONNECT_HANDSHAKE_VALUE); advice.put(Message.INTERVAL_FIELD, 0L); } }
for (ServerMessage.Mutable message : messages) { connect = Channel.META_CONNECT.equals(message.getChannel());
if (Channel.META_HANDSHAKE.equals(reply.getChannel())) { if (allowMessageDeliveryDuringHandshake(session) && !messages.isEmpty()) { reply.put("x-messages", messages.size());
(!session.getId().equals(message.getClientId()) && !Channel.META_HANDSHAKE.equals(message.getChannel()))) { unknownSession(reply); promise.succeed(reply); } else { String channelName = message.getChannel(); session.cancelExpiration(Channel.META_CONNECT.equals(channelName));
RemoteCall.Caller caller = new CallerImpl(bayeuxServer, localSession, from, message.getId(), message.getChannel()); args[0] = caller; args[1] = message.getData();
protected void processMessages(Context context, ServerMessage.Mutable[] messages, Promise<Void> promise) { if (messages.length == 0) { promise.fail(new IOException("protocol violation")); } else { Collection<ServerSessionImpl> sessions = findCurrentSessions(context.request); ServerMessage.Mutable message = messages[0]; ServerSessionImpl session = findSession(sessions, message); if (_logger.isDebugEnabled()) { _logger.debug("Processing {} messages for session {}", messages.length, session); } boolean batch = session != null && !Channel.META_CONNECT.equals(message.getChannel()); if (batch) { session.startBatch(); } context.messages = messages; context.session = session; AsyncFoldLeft.run(messages, null, (result, item, loop) -> processMessage(context, (ServerMessageImpl)item, Promise.from(loop::proceed, loop::fail)), Promise.from(y -> { flush(context, promise); if (batch) { session.endBatch(); } }, promise::fail)); } }
protected ServerSessionImpl findSession(Collection<ServerSessionImpl> sessions, ServerMessage.Mutable message) { if (Channel.META_HANDSHAKE.equals(message.getChannel())) { ServerSessionImpl session = getBayeux().newServerSession(); session.setAllowMessageDeliveryDuringHandshake(isAllowMessageDeliveryDuringHandshake()); return session; } // Is there an existing, trusted, session ? String clientId = message.getClientId(); if (sessions != null) { if (clientId != null) { for (ServerSessionImpl session : sessions) { if (session.getId().equals(clientId)) { return session; } } } } if (_trustClientSession) { return (ServerSessionImpl)getBayeux().getSession(clientId); } return null; }
@Override public void deQueue(ServerSession session, Queue<ServerMessage> queue, List<Mutable> replies) { Mutable reply = null; for (Mutable r : replies) { String channel = r.getChannel(); if (Channel.META_HANDSHAKE.equals(channel) || Channel.META_CONNECT.equals(channel)) { reply = r; break; } } if (reply != null) { long batch = _batches.remove(reply.getId()); synchronized (_session.getLock()) { if (_logger.isDebugEnabled()) { _logger.debug("Dequeuing {}/{} messages until batch {} for {} on {}", queue.size(), _queue.size(), batch, reply, _session); } queue.clear(); _queue.exportMessagesToBatch(queue, batch); } } }
@Override public boolean rcvMeta(ServerSession remote, Mutable message) { if (Channel.META_HANDSHAKE.equals(message.getChannel())) { Map<String, Object> rcvExt = message.getExt(); boolean clientRequestedAcks = rcvExt != null && rcvExt.get("ack") == Boolean.TRUE; if (clientRequestedAcks && remote != null) { if (_logger.isDebugEnabled()) { _logger.debug("Enabled message acknowledgement for session {}", remote); } AcknowledgedMessagesSessionExtension extension = new AcknowledgedMessagesSessionExtension(remote); // Make sure that adding the extension and importing the queue is atomic. ServerSessionImpl session = (ServerSessionImpl)remote; synchronized (session.getLock()) { session.addExtension(extension); extension.importMessages(session); } } } return true; } }
@Override public boolean rcvMeta(ServerSession session, ServerMessage.Mutable message) { if (Channel.META_CONNECT.equals(message.getChannel())) { if (isInactive()) { if (logger.isDebugEnabled()) { logger.debug("Inactive session {}, disconnecting", session); } disconnect(session); } } else { if (logger.isDebugEnabled()) { logger.debug("Marking active session {}, received meta message {}", session, message); } markActive(); } return true; }
private boolean writeHandshakeReply(ServletOutputStream output) throws IOException { List<ServerMessage.Mutable> replies = context.replies; if (replies.size() > 0) { ServerMessage.Mutable reply = replies.get(0); if (Channel.META_HANDSHAKE.equals(reply.getChannel())) { if (allowMessageDeliveryDuringHandshake(context.session) && !messages.isEmpty()) { reply.put("x-messages", messages.size()); } getBayeux().freeze(reply); output.write(toJSONBytes(reply, "UTF-8")); needsComma = true; ++replyIndex; } } return output.isReady(); }
protected ServerMessage.Mutable createReply(ServerMessage.Mutable message) { ServerMessageImpl reply = (ServerMessageImpl)newMessage(); message.setAssociated(reply); reply.setAssociated(message); reply.setServerTransport(message.getServerTransport()); reply.setBayeuxContext(message.getBayeuxContext()); reply.setChannel(message.getChannel()); String id = message.getId(); if (id != null) { reply.setId(id); } return reply; }
@Override public boolean rcvMeta(ServerSession session, Mutable message) { if (Channel.META_CONNECT.equals(message.getChannel())) { Map<String, Object> ext = message.getExt(false); if (ext != null) { Number batchValue = (Number)ext.get("ack"); if (batchValue != null) { processBatch(batchValue.longValue()); updateAdvice(message); } } } return true; }
@Override public boolean rcvMeta(ServerSession session, ServerMessage.Mutable message) { if (Channel.META_HANDSHAKE.equals(message.getChannel())) { session.addExtension(newSessionExtension(session, message)); } return true; }
protected String validateMessage(Mutable message) { String channel = message.getChannel(); if (!validate(channel)) { return "405::invalid_channel"; } String id = message.getId(); if (id != null && !validate(id)) { return "405::invalid_id"; } return null; }