public boolean endBatch() {
   synchronized (getLock()) {
     if (--_batch == 0 && _nonLazyMessages) {
       flush();
       return true;
     }
   }
   return false;
 }
 public void disconnect() {
   boolean connected = _bayeux.removeServerSession(this, false);
   if (connected) {
     ServerMessage.Mutable message = _bayeux.newMessage();
     message.setChannel(Channel.META_DISCONNECT);
     message.setSuccessful(true);
     deliver(this, message);
     flush();
   }
 }
  private void flushLazy(ServerMessage message) {
    synchronized (getLock()) {
      ServerChannel channel = _bayeux.getChannel(message.getChannel());
      long lazyTimeout = -1;
      if (channel != null) lazyTimeout = channel.getLazyTimeout();
      if (lazyTimeout <= 0) lazyTimeout = _maxLazy;

      if (lazyTimeout <= 0) flush();
      else _lazyTask.schedule(lazyTimeout);
    }
  }
  protected void doDeliver(ServerSession sender, ServerMessage.Mutable mutable) {
    if (sender == this && !isBroadcastToPublisher()) return;

    ServerMessage message = null;
    if (mutable.isMeta()) {
      if (extendSendMeta(mutable)) message = mutable;
    } else {
      message = extendSendMessage(mutable);
    }

    if (message == null) return;

    _bayeux.freeze((Mutable) message);

    if (!_listeners.isEmpty()) {
      for (ServerSessionListener listener : _listeners) {
        if (listener instanceof MessageListener) {
          if (!notifyOnMessage((MessageListener) listener, sender, message)) return;
        }
      }
    }

    boolean wakeup;
    synchronized (getLock()) {
      if (!_listeners.isEmpty()) {
        for (ServerSessionListener listener : _listeners) {
          if (listener instanceof MaxQueueListener) {
            final int maxQueueSize = _maxQueue;
            if (maxQueueSize > 0 && _queue.size() > maxQueueSize) {
              if (!notifyQueueMaxed((MaxQueueListener) listener, this, _queue, sender, message))
                return;
            }
          }
        }
      }
      addMessage(message);
      if (!_listeners.isEmpty()) {
        for (ServerSessionListener listener : _listeners) {
          if (listener instanceof QueueListener)
            notifyQueued((QueueListener) listener, sender, message);
        }
      }
      wakeup = _batch == 0;
    }

    if (wakeup) {
      if (message.isLazy()) flushLazy(message);
      else flush();
    }
  }
Example #5
0
  @Override
  public void handle(HttpServletRequest request, HttpServletResponse response)
      throws IOException, ServletException {
    // Is this a resumed connect?
    LongPollScheduler scheduler =
        (LongPollScheduler) request.getAttribute(LongPollScheduler.ATTRIBUTE);
    if (scheduler == null) {
      // No - process messages

      // Remember if we start a batch
      boolean batch = false;

      // Don't know the session until first message or handshake response.
      ServerSessionImpl session = null;
      boolean connect = false;

      try {
        ServerMessage.Mutable[] messages = parseMessages(request);
        if (messages == null) return;

        PrintWriter writer = null;
        for (ServerMessage.Mutable message : messages) {
          // Is this a connect?
          connect = Channel.META_CONNECT.equals(message.getChannel());

          // Get the session from the message
          String client_id = message.getClientId();
          if (session == null || client_id != null && !client_id.equals(session.getId())) {
            session = (ServerSessionImpl) getBayeux().getSession(client_id);
            if (_autoBatch && !batch && session != null && !connect && !message.isMeta()) {
              // start a batch to group all resulting messages into a single response.
              batch = true;
              session.startBatch();
            }
          } else if (!session.isHandshook()) {
            batch = false;
            session = null;
          }

          if (connect && session != null) {
            // cancel previous scheduler to cancel any prior waiting long poll
            // this should also dec the browser ID
            session.setScheduler(null);
          }

          boolean wasConnected = session != null && session.isConnected();

          // Forward handling of the message.
          // The actual reply is return from the call, but other messages may
          // also be queued on the session.
          ServerMessage.Mutable reply = bayeuxServerHandle(session, message);

          // Do we have a reply ?
          if (reply != null) {
            if (session == null) {
              // This must be a handshake, extract a session from the reply
              session = (ServerSessionImpl) getBayeux().getSession(reply.getClientId());

              // Get the user agent while we are at it, and add the browser ID cookie
              if (session != null) {
                String userAgent = request.getHeader("User-Agent");
                session.setUserAgent(userAgent);

                String browserId = findBrowserId(request);
                if (browserId == null) setBrowserId(request, response);
              }
            } else {
              // Special handling for connect
              if (connect) {
                try {
                  writer = sendQueue(request, response, session, writer);

                  // If the writer is non null, we have already started sending a response, so we
                  // should not suspend
                  if (writer == null && reply.isSuccessful() && session.isQueueEmpty()) {
                    // Detect if we have multiple sessions from the same browser
                    // Note that CORS requests do not send cookies, so we need to handle them
                    // specially
                    // CORS requests always have the Origin header

                    String browserId = findBrowserId(request);
                    boolean allowSuspendConnect;
                    if (browserId != null) allowSuspendConnect = incBrowserId(browserId);
                    else
                      allowSuspendConnect =
                          _allowMultiSessionsNoBrowser || request.getHeader("Origin") != null;

                    if (allowSuspendConnect) {
                      long timeout = session.calculateTimeout(getTimeout());

                      // Support old clients that do not send advice:{timeout:0} on the first
                      // connect
                      if (timeout > 0 && wasConnected && session.isConnected()) {
                        // Suspend and wait for messages
                        Continuation continuation = ContinuationSupport.getContinuation(request);
                        continuation.setTimeout(timeout);
                        continuation.suspend(response);
                        scheduler = new LongPollScheduler(session, continuation, reply, browserId);
                        session.setScheduler(scheduler);
                        request.setAttribute(LongPollScheduler.ATTRIBUTE, scheduler);
                        reply = null;
                        metaConnectSuspended(request, session, timeout);
                      } else {
                        decBrowserId(browserId);
                      }
                    } else {
                      // There are multiple sessions from the same browser
                      Map<String, Object> advice = reply.getAdvice(true);

                      if (browserId != null) advice.put("multiple-clients", true);

                      if (_multiSessionInterval > 0) {
                        advice.put(Message.RECONNECT_FIELD, Message.RECONNECT_RETRY_VALUE);
                        advice.put(Message.INTERVAL_FIELD, _multiSessionInterval);
                      } else {
                        advice.put(Message.RECONNECT_FIELD, Message.RECONNECT_NONE_VALUE);
                        reply.setSuccessful(false);
                      }
                      session.reAdvise();
                    }
                  }
                } finally {
                  if (reply != null && session.isConnected())
                    session.startIntervalTimeout(getInterval());
                }
              } else {
                if (!isMetaConnectDeliveryOnly() && !session.isMetaConnectDeliveryOnly()) {
                  writer = sendQueue(request, response, session, writer);
                }
              }
            }

            // If the reply has not been otherwise handled, send it
            if (reply != null) {
              if (connect && session != null && !session.isConnected())
                reply.getAdvice(true).put(Message.RECONNECT_FIELD, Message.RECONNECT_NONE_VALUE);

              reply = getBayeux().extendReply(session, session, reply);

              if (reply != null) {
                getBayeux().freeze(reply);
                writer = send(request, response, writer, reply);
              }
            }
          }

          // Disassociate the reply
          message.setAssociated(null);
        }
        if (writer != null) complete(writer);
      } catch (ParseException x) {
        handleJSONParseException(request, response, x.getMessage(), x.getCause());
      } finally {
        // If we started a batch, end it now
        if (batch) {
          boolean ended = session.endBatch();

          // Flush session if not done by the batch, since some browser order <script> requests
          if (!ended && isAlwaysFlushingAfterHandle()) session.flush();
        } else if (session != null && !connect && isAlwaysFlushingAfterHandle()) {
          session.flush();
        }
      }
    } else {
      // Get the resumed session
      ServerSessionImpl session = scheduler.getSession();
      metaConnectResumed(request, session);

      PrintWriter writer;
      try {
        // Send the message queue
        writer = sendQueue(request, response, session, null);
      } finally {
        // We need to start the interval timeout before the connect reply
        // otherwise we open up a race condition where the client receives
        // the connect reply and sends a new connect request before we start
        // the interval timeout, which will be wrong.
        // We need to put this into a finally block in case sending the queue
        // throws an exception (for example because the client is gone), so that
        // we start the interval timeout that is important to sweep the session
        if (session.isConnected()) session.startIntervalTimeout(getInterval());
      }

      // Send the connect reply
      ServerMessage.Mutable reply = scheduler.getReply();

      if (!session.isConnected())
        reply.getAdvice(true).put(Message.RECONNECT_FIELD, Message.RECONNECT_NONE_VALUE);

      reply = getBayeux().extendReply(session, session, reply);

      if (reply != null) {
        getBayeux().freeze(reply);
        writer = send(request, response, writer, reply);
      }

      complete(writer);
    }
  }