i0019 - a proposal

[Doug Davis <dug@us.ibm.com>]

For issue 19 we're really dealing with
the communication of the state of the sequence between the RMD and the
RMS.  I think there are two situation we need to think about:
1 - a sequence w/o gaps
2 - a sequence with gaps

#1 is easy, when the RMS receives an
Ack for the full range of messages that it has sent then it knows that
the sequence is complete and it can send a Terminate knowing no new messages
will be accepted by the RMD.  In the absence of an ACK the RMS can
always ask for one using an AckRequested thereby determine the RMD's state.

#2 seems to be the problem child.  Lost
(or delayed) Acks and Messages can play havoc with the RMS's perception
of what the final state of the sequence is.  For example, it may believe
that message #3 (out of 6) was lost and doesn't care any more (for some
reason), so it sends a TerminateSequence.  However, if message #3
is just slow, and arrives at the RMD after the sending of the Terminate
but before it arrives then the RMD's sequence state will differ from the
RMS's.  Sending a final Ack back to the RMS might not be sufficient
since that might be lost as well. 

So, I'd like to propose the following:

Add a "Final" marker to the
SequenceAck header (per Dan's suggestions).  The inclusion of this
element in the Ack is the RMD's way of telling the RMS that no new messages
will be accepted into this sequence.  This is true regardless of there
being gaps in it or not.
Define a new operation: "Close".
 The RMS can send a "Close" to the RMD indicating that it
would like to shutdown the sequence and request that no new messages be
accepted.  Notice that this is similar to a TerminateSequence in that
they both shutdown the sequence but unlike a TerminateSeq, the "Close"
will not do any resource reclamation - it just halts the delivery/processing
of any new messages.

So, going back to situation #2, the
RMS wants to close down the sequence despite there being gaps. It will
send a "Close" to the RMD, which in turn responds with "Closed"
plus an Ack.  Note that the Ack will include the "Final"
marker.  If this message (or the Close) is lost the RMS is free to
send it over and over until it gets an Ack+Final since processing multiple
ones has no negative impact.  Upon receipt of the Ack+Final the RMS
can then safely send a TerminateSequence without fear of any new messages
arriving and changing its perception of the gaps in the sequence.

Note that sending a "Close"
for a sequence that doesn't have gaps doesn't cause any harm either - its
an optional message that _can_ flow right before a TerminateSequence.
Thoughts?  If people like this
I'll write up a more formal proposal (spec changes).

thanks
-Doug