W3C home > Mailing lists > Public > xml-dist-app@w3.org > May 2001

RE: An analysis of mustUnderstand and related issues

From: Kasi, Jay <jay.kasi@commerceone.com>
Date: Thu, 24 May 2001 22:45:55 -0700
Message-ID: <63751F9A4BBBD411A6E000508BA5831F02449210@c1plenaexm03.commerceone.com>
To: "'Noah_Mendelsohn@lotus.com'" <Noah_Mendelsohn@lotus.com>, xml-dist-app@w3.org

Some comments on Noahs and Henriks comments: 

Henrik said ---> 

>>> As the processing model doesn't allow for partial success,
>>> applications may always have to perform some form for
>>> compensation if the processing suddenly goes wrong in the
>>> middle.

Noah responded ----> 

>Whoa... that seems really complicated, and as noted above
>I don't see where the spec requires this. Nothing in
>SOAP says anything regarding atomicity.  Indeed, we
>seem to have been quite clear in other discussions
>that anything resembling transactions is separate
>from core SOAP.

I agree with Noah. 

How far do we want to go in the direction of atomicity? Especially
distributed atomicity? (even if we were willing to change SOAP in this

Distributed atomicity: 

This is next to impossible to achieve. Async Response error messages that 
exactly backtrack can get lost without guaranteed delivery or get
stuck and require manual intervention. If you closely examine guaranteed 
delivery (every flavor that I know of) there are corner cases where messages

are not guaranteed to reach the destination and the error is not guaranteed
make it back to the sender. Also many of them require retries from the send
and therefore messages are duplicated and processed twice. There are even
where the outcome of the message (processed or not processed) is "unknown"
the sender. Also synchoronous messages typically do not support guaranteed 
delivery of any kind and clearly distributed atomocity does not apply to
I am sure Henrik is not proposing this?  

Single node atomocity: 

Clearly some of the actors like a cache manager have nothing to do with
and clearly are not really covered by atomicity aspects. Insisting all
at a node share the same logging mechanism and transaction manager (unless
you want 
to get into the never never land of two phase commits) is a dracoonean
Even in the case of two phase commits, there is heuristic completion. Also
phase commits really dictates the kind of server technology and the way apps
written and therefore are darcoonean constraints. I suspect Henrik is not
this either? 

Implications of retries: 

One thing that occurs to me is what is the implications to SOAP
mustunderstand when 
messages are transparently retried, say,  due to a protocol on top (assuming
delivery or any kind of retries - even at the transport level for certain
kinds of async transports - is out of scope for SOAP itself). 

This is not a question about atomicity but duplication. For example what if
a billing 
record is emitted twice by executing a mustunderstand? Is there any concept
idempotency? Clearly SOAP does not address such broader issues I dont think?

atomocity, guaranteed delivery, duplication and idempotency are very complex
Do we want to go there with SOAP or leave it to a higher level?    
Received on Friday, 25 May 2001 01:46:23 UTC

This archive was generated by hypermail 2.3.1 : Tuesday, 6 January 2015 22:01:13 UTC