RE: [wsbpel] Reg. Issue#3 Proposal

["Satish Thatte" <satisht@microsoft.com>]

Muruga,

The snapshot is in fact the completed state of the scope, as it existed when the scope completed successfully.  As you point out, this takes care of both the situation when the successful scope was executed once and the looping situation where the scope was executed multiple times.

Since your understanding reflects the intent of the new language, I am left wondering where the difficulty is.  Perhaps you are just pointing out that the language is misleading in some way?

Satish 

_____________________________________________
From: Muruga Chinnananchi [mailto:muruga@collaxa.com] 
Sent: Thursday, January 29, 2004 11:38 AM
To: Muruga Chinnananchi; wsbpel@lists.oasis-open.org
Subject: RE: [wsbpel] Reg. Issue#3 Proposal

I would like to repharase the question:

I thought issue #3 has been resolved in latest spec draft(23rd Nov'03) and proposal for this issue doesn't use scope snapshot. But this one sentence is confusing to me in the latest spec section 13.3.2: 
"For the variables in the local scope, the compensation handler starts with the scope snapshot"

Here is my understanding:
Compensation handler for a scope can see only its snapshot as well as the current state (live state) of the enclosing scope. I would like to give an example.

<process p> process p has variable v0
 <scope s1> scope s1 has local variable v1
  <scope s2> scope s2 has local variable v2
  
*copy of variable v1 is v1' (copied variable uses single quote to indicate that it is a copy)*

Lets say s1 is in 'completed' state, and its parent (process p) asking it to compensate, so s1 uses a copied variable v1' during its compensation and invokes its enclosed (nested) scope s2 compensation handler. Now s2 uses a copied variable v2' and sees its parent scope's variable v1' as well as the process variable v0.

I don't understand why a scope need to live in the snapshot world. why can't we use the current completed state of the scope  when it compensates.

I understand that when a scope is involved in a while loop, it needs to do snapshot because there are multiple 'completed' for states for the same scope.
<while>
   <scope s1> has variable v1
</while>
Lets say the scope s1 gets executed 3 times, here we need to preserve the state for each iteration. so when we do compensation it will use the corresponding iteration state.

Please advice me.

thanks,
-muruga

-----Original Message-----
From: Muruga Chinnananchi [mailto:muruga@collaxa.com]
Sent: Wednesday, January 28, 2004 11:47 AM
To: wsbpel@lists.oasis-open.org
Subject: [wsbpel] Reg. Issue#3 Proposal


Hi all,

I have one question regarding Issue #3 which has been resolved. The Proposal
text says the following:
(http://www.oasis-open.org/committees/download.php/5197/wsbpel_issues_list.h
tml#Issue3):

"The behavior of a compensation handler can be thought of as an optional
continuation of the behavior of the associated scope and as such its usage
of variables is similar to the usage that occurred in the body of the scope
itself, including update actions. This includes variables in both the local
scope and all enclosing scopes. Note that the compensation handler may
itself have been called from an enclosing compensation handler. It will then
share the continuation of the state of the enclosing scope that its caller
is using. In the attached picture showing three nested scopes S1, S2 and S3,
and their compensation handlers C1, C2, C3, and failure handlers F1 and F2,
we may have an error handling call stack F1->C2->C3. In that case C3 will
share the state of S2 as it is being seen and used by C2."


But When I looked the latest spec dated 23 Nov 2003, I noticed that this
proposal has been updated in the spec. But the text differs little bit from
the original proposal. I highlighted the addition under the <NEW> tag.

"The behavior of a compensation handler can be thought of as an optional
continuation of the behavior of the associated scope and as such its usage
of variables is similar to the usage that occurred in the body of the scope
itself, including update actions.   This includes variables in both the
local scope and all enclosing scopes. <NEW>For the variables in the local
scope, the compensation handler starts with the scope snapshot.</NEW> Note
that the compensation handler may itself have been called from an enclosing
compensation handler.  It will then share the continuation of the state of
the enclosing scope that its caller is using.  In the picture below showing
three nested scopes S1, S2 and S3, and their compensation handlers C1, C2,
C3, and failure handlers F1 and  F2, we may have an error handling call
stack F1->C2->C3.  In that case C3 will share the state of S2 as it is being
seen and used by C2, and the current state of the uncompleted scope S1."

Can I assume that when compensation handler runs for a Scope, it can only
see the snapshot of the scope? I think this snapshot is missing in the
original proposal.



To unsubscribe from this mailing list (and be removed from the roster of the OASIS TC), go to http://www.oasis-open.org/apps/org/workgroup/wsbpel/members/leave_workgroup.php.

 << File: ATT6413299.txt >>