How to use

com.oracle.coherence.patterns.messaging.entryprocessors.AcknowledgeSubscriptionMessagesProcessor

constructor

  /**
   * {@inheritDoc}
   */
  @Override
  protected void acknowledgeDistributedEvents(List<Event>    events,
                        MessageTracker messageTracker)
  {
    // create the set of keys for messages to acknowledge
    ArrayList<MessageKey>       messageKeys = new ArrayList<MessageKey>(events.size());
    Iterator<MessageIdentifier> messageIds  = messageTracker.iterator();

    while (messageIds.hasNext())
    {
      MessageIdentifier messageId = messageIds.next();

      messageKeys.add(Message.getKey(subscriptionIdentifier.getDestinationIdentifier(), messageId));
    }

    // remove this subscriber from each of the messages in this batch
    // (to help clean up the messages when they are completely consumed)
    NamedCache messagesCache = CacheFactory.getCache(Message.CACHENAME);

    messagesCache.invokeAll(messageKeys, new AcknowledgeMessageProcessor(subscriptionIdentifier));

    // remove the range we've just distributed from the subscriber
    NamedCache subscriptions = CacheFactory.getCache(Subscription.CACHENAME);

    subscriptions.invoke(subscriptionIdentifier, new AcknowledgeSubscriptionMessagesProcessor(messageTracker));
  }
}

/**
 * {@inheritDoc}
 */
public void commit()
{
  ensureActive();
  if (!isAutoCommitting())
  {
    // ensure that we have a subscription from which we can retrieve
    // messages
    ensureSubscription();
    // determine the range of messages that are visible
    // (these are the ones we must acknowledge)
    MessageTracker messageTracker =
      (MessageTracker) CacheFactory.getCache(Subscription.CACHENAME).invoke(getSubscriptionIdentifier(),
                                         new ExtractorProcessor("getVisibleMessageTracker"));
    // send the AcknowledgeMessageProcessor to all of the visible
    // messages
    ArrayList<MessageKey> messageKeys = messageTracker.getMessageKeys(getDestinationIdentifier());
    CacheFactory.getCache(Message.CACHENAME).invokeAll(messageKeys,
                              new AcknowledgeMessageProcessor(getSubscriptionIdentifier()));
    // let the subscriber know that we've acknowledged all messages
    CacheFactory.getCache(Subscription.CACHENAME).invoke(getSubscriptionIdentifier(),
                               new AcknowledgeSubscriptionMessagesProcessor(messageTracker));
  }
}

/**
 * {@inheritDoc}
 */
public void commit()
{
  ensureActive();
  if (!isAutoCommitting())
  {
    // ensure that we have a subscription from which we can retrieve
    // messages
    ensureSubscription();
    // determine the range of messages that have been delivered
    // (these are the ones we must acknowledge)
    MessageTracker messageTracker =
      (MessageTracker) CacheFactory.getCache(Subscription.CACHENAME).invoke(getSubscriptionIdentifier(),
                                         new ExtractorProcessor("getDeliveredMessageTracker"));
    if (!messageTracker.isEmpty())
    {
      // Tell Message that is has been acked
      ArrayList<MessageKey> messageKeys = messageTracker.getMessageKeys(getDestinationIdentifier());
      CacheFactory.getCache(Message.CACHENAME).invokeAll(messageKeys,
                                new AcknowledgeMessageProcessor(getSubscriptionIdentifier()));
      // Tell subscription that msg has been acked.
      CacheFactory.getCache(Subscription.CACHENAME).invoke(getSubscriptionIdentifier(),
                                 new AcknowledgeSubscriptionMessagesProcessor(messageTracker));
    }
  }
}

new AcknowledgeSubscriptionMessagesProcessor(messageTracker));

new AcknowledgeSubscriptionMessagesProcessor(messageTracker));