[Jboss-dev-forums] [Design of Messaging on JBoss (Messaging/JBoss)] - Re: Acknowledgment handling in the core

[<ovi...@jb...>]

The problem described by Tim is indirectly related to the way a Router handles acknowlegments. Actually, there are two distinct problems that need to be solved

1. A channel cannot distinguish between messages that have been delivered and NACKed and messages that haven't been delivered at all.  We need this distinction to implement channel browsers.

2. Because a Router is currently a Receiver, its handle() method can only return a binary result (ACK/NACK) which is certainly not sufficient to express combinations of ACKs/NACKs from multiple receivers, in the case of a  PointToMultipointRouter, for example.


Tim proposed to solve issue 1 by having three acknowledgment types . This would require changes throughout the core. I also think three acknowledgment types are not necessary, since NACK-DeliveryNotAttempted is a state that shouldn't propagate back on the receiver chain. We don't need to be able to browse all channels along a delivery path, we only need to be able to browse the last one, that actually keeps the message in question.


Here is another proposal that addresses 1. and 2. and it only requires localized changes. We still only have two types of acknowledgments: ACKs (true) and NACKs (false).

As originally designed, a Router is a synchronous component. It returns a NACK to the component that initiated delivery, if the delivery is not successful, but it does not hold messages and it does not attempt redelivery. In this respect, is not a Channel. To address 1. and 2. its interface should changes as follows


  | public interface Router extends Distributor
  | {
  |     public Serializable getRouterID();
  | 
  |     public Serializable[] handle(Routable);
  |     public Serializable[] handle(Routable, Serializable[]);
  | 
  |     public boolean isPassByReference();
  | }
  | 

A Router is not a Receiver anymore, since the Receiver interface is not semantically rich enough.

The handle() method behaves as follows: the sender attempts delivery using handle(Routable) or handle(Routable, null). The Router synchronously delivers the Routable to the receivers it chooses (all receivers for a PointToMultipointRouter or only one receiver for a PointToPointRouter) and returns the array containing ReceiverIDs of receivers that NACKed. This way, the sender can store the NACKs and attempt redelivery later using handle(Routable, Serializable[]).

If the Router has no receivers, handle() only returns a single element array containing the Router's ID. This way, the sender knows the message was not delivered in the first place (this is the equivalent to Tim's NACK-DeliveryNotAttempted). The pipe that calls into the Router stores the message and it's also able to distinguish between NACKed messages and non-delivered messages.

Browsing the queue would mean quering the AcknowledgmentStore for all messages that have been NACKed by the Router and not by individual Receivers. 

View the original post : http://www.jboss.org/index.html?module=bb&op=viewtopic&p=3878107#3878107

Reply to the post : http://www.jboss.org/index.html?module=bb&op=posting&mode=reply&p=3878107