コード例 #1
0
  /** {@inheritDoc} */
  @Override
  public boolean sendMessageToSubscriber(ProtocolMessage protocolMessage, AndesContent content)
      throws AndesException {

    boolean sendSuccess;

    DeliverableAndesMetadata messageMetadata = protocolMessage.getMessage();

    if (messageMetadata.isRetain()) {
      recordRetainedMessage(messageMetadata.getMessageID());
    }

    // Should get the message from the list
    ByteBuffer message = MQTTUtils.getContentFromMetaInformation(content);
    // Will publish the message to the respective queue
    if (null != mqqtServerChannel) {
      try {

        // TODO:review - instead of getSubscribedDestination() used message destination
        mqqtServerChannel.distributeMessageToSubscriber(
            wildcardDestination,
            message,
            messageMetadata.getMessageID(),
            messageMetadata.getQosLevel(),
            messageMetadata.isPersistent(),
            getMqttSubscriptionID(),
            getSubscriberQOS(),
            messageMetadata);

        // We will indicate the ack to the kernel at this stage
        // For MQTT QOS 0 we do not get ack from subscriber, hence will be implicitly creating an
        // ack
        if (QOSLevel.AT_MOST_ONCE.getValue() == getSubscriberQOS()
            || QOSLevel.AT_MOST_ONCE.getValue() == messageMetadata.getQosLevel()) {
          mqqtServerChannel.implicitAck(messageMetadata.getMessageID(), getChannelID());
        }
        sendSuccess = true;
      } catch (MQTTException e) {
        final String error =
            "Error occurred while delivering message to the subscriber for message :"
                + messageMetadata.getMessageID();
        log.error(error, e);
        throw new AndesException(error, e);
      }
    } else {
      sendSuccess = false;
    }

    return sendSuccess;
  }
コード例 #2
0
  /** {@inheritDoc} */
  @Override
  public int deliverMessageToSubscriptions(MessageDeliveryInfo messageDeliveryInfo)
      throws AndesException {

    Set<DeliverableAndesMetadata> messages = messageDeliveryInfo.getReadButUndeliveredMessages();
    int sentMessageCount = 0;
    Iterator<DeliverableAndesMetadata> iterator = messages.iterator();
    List<DeliverableAndesMetadata> droppedTopicMessagesList = new ArrayList<>();

    /**
     * get all relevant type of subscriptions. This call does NOT return hierarchical subscriptions
     * for the destination. There are duplicated messages for each different subscribed destination.
     * For durable topic subscriptions this should return queue subscription bound to unique queue
     * based on subscription id
     */
    Collection<LocalSubscription> subscriptions =
        subscriptionEngine.getActiveLocalSubscribers(
            messageDeliveryInfo.getDestination(),
            messageDeliveryInfo.getProtocolType(),
            messageDeliveryInfo.getDestinationType());

    while (iterator.hasNext()) {

      try {
        DeliverableAndesMetadata message = iterator.next();

        // All subscription filtering logic for topics goes here
        List<LocalSubscription> subscriptionsToDeliver = new ArrayList<>();

        for (LocalSubscription subscription : subscriptions) {

          /*
           * If this is a topic message, remove all durable topic subscriptions here
           * because durable topic subscriptions will get messages via queue path.
           * Also need to consider the arrival time of the message. Only topic
           * subscribers which appeared before publishing this message should receive it
           */
          if (subscription.isDurable()
              || (subscription.getSubscribeTime() > message.getArrivalTime())) {
            continue;
          }

          // Avoid sending if the selector of subscriber does not match
          if (!subscription.isMessageAcceptedBySelector(message)) {
            continue;
          }

          subscriptionsToDeliver.add(subscription);
        }

        if (subscriptionsToDeliver.size() == 0) {
          iterator.remove(); // remove buffer
          droppedTopicMessagesList.add(message);

          continue; // skip this iteration if no subscriptions for the message
        }

        /**
         * For normal non-durable topic we pre evaluate room for all subscribers and if all subs has
         * room to accept messages we send them. This means we operate to the speed of slowest
         * subscriber (to prevent OOM). If it is too slow to make others fast, make that topic
         * subscriber a durable topic subscriber.
         */
        boolean allTopicSubscriptionsHasRoom = true;
        for (LocalSubscription subscription : subscriptionsToDeliver) {
          if (!subscription.hasRoomToAcceptMessages()) {
            allTopicSubscriptionsHasRoom = false;
            break;
          }
        }
        if (allTopicSubscriptionsHasRoom) {

          message.markAsScheduledToDeliver(subscriptionsToDeliver);

          // schedule message to all subscribers
          for (LocalSubscription localSubscription : subscriptionsToDeliver) {
            MessageFlusher.getInstance().deliverMessageAsynchronously(localSubscription, message);
          }
          iterator.remove();
          if (log.isDebugEnabled()) {
            log.debug(
                "Removing Scheduled to send message from buffer. MsgId= " + message.getMessageID());
          }
          sentMessageCount++;
        } else {
          if (log.isDebugEnabled()) {
            log.debug(
                "Some subscriptions for destination "
                    + messageDeliveryInfo.getDestination()
                    + " have max unacked messages "
                    + message.getDestination());
          }
          // if we continue message order will break
          break;
        }

      } catch (NoSuchElementException ex) {
        // This exception can occur because the iterator of ConcurrentSkipListSet loads the
        // at-the-time snapshot.
        // Some records could be deleted by the time the iterator reaches them.
        // However, this can only happen at the tail of the collection, not in middle, and it would
        // cause the loop
        // to blindly check for a batch of deleted records.
        // Given this situation, this loop should break so the sendFlusher can re-trigger it.
        // for tracing purposes can use this : log.warn("NoSuchElementException thrown",ex);
        log.warn("NoSuchElementException thrown. ", ex);
        break;
      }
    }

    /**
     * Here we do not need to have orphaned slot scenario (return slot). If there are no subscribers
     * slot will be consumed and metadata will be removed. We duplicate topic messages per node
     */

    /**
     * delete topic messages that were dropped due to no subscriptions for the message and due to
     * has no room to enqueue the message. Delete call is blocking and then slot message count is
     * dropped in order
     */
    MessagingEngine.getInstance().deleteMessages(droppedTopicMessagesList);

    return sentMessageCount;
  }