Compensate Demo

Sample Practice Document for Training Evaluation http://soatraining.hpage.
com
With every training session, the presentation used and a practice

document that contains step-
step-by step instructions for developing
the sample is provided.
This document is a demo of those practice documents. This

particular one is when we discuss and develop
develop a compensation
handler in a BPEL process. It also brings out how to use throw
and catch activity.
activity.
Every document starts with an ‘Aim’ and then goes on to develop

a project around that. It ends after showing the project in action.
Aim
To demonstrate use of compensation handler and compensate activity
Use case
We shall pass two integers num1 and num2. The result would tell values of num1 +
num2, num1 – num2 and num1/num2.
Initially the variables for the results – additionResult, subtractionResult and

divisionResult are all set to -1.
The first operation is addition, followed by subtraction and division. If during division,
we find that result is Infinity (which would happen when num2 is zero), we want to undo
the assignment of valid values to additionResult and subtractionResult (‘undo’ in the
context of this example means setting these back to -1)
You can save the following embedded zip file onto your computer. It contains the code
for this project
C:\
CompensateDemo.zip
Sample Practice Document for Training Evaluation http://soatraining.hpage.com
Start by creating a new project

Modify the input schema to accept two integers
Add a scope named Operations.

Within that, add three scopes named addition, subtraction and division
Create three variables – additionResult (integer), subtractionResult (integer) and

divisionResult (float)
Steps to create additionResult are shown
Follow similar steps for subtractionResult and divisionResult

Add a assign activity before the Operations scope and set each of the three variables to -1
BPEL looks like this as of now

In each scope add an assign activity.
In Addition, name the assign activity as add. Create a copy operation and add the two
inputs and assign that value to addResult
bpws:getVariableData('inputVariable','payload','/client:CompensateDemoP
rocessRequest/client:num1') +
rocessRequest/client:num2')
Similarly do for subtraction and division.
rocessRequest/client:num1') -
rocessRequest/client:num1') div
The BPEL now looks like this

Now our business requirement is, if the second number is zero, then divisionResult would
be Infinity or –Infinity. We want to test for this condition in the division scope. If it is
found true, we shall throw an exception. That exception shall be caught by Operations
scope and it will ‘undo’ the values in additionResult and subtractionResult, and set them
to -1.
To undo these values, we have two options – either we can write expressions in the catch
handler itself to reset each of these variables, or we can associate ‘undo steps’ or
compensation steps with every scope itself, and then just invoke these undo steps from
the fault handler. This is the concept of compensation handler. The value it brings to
table is this – instead of making the fault handler ‘know’ about every scope and how to
undo it, we localize that information with that scope. That way, we get neat code, and
abstraction.
The first step towards this is therefore, to add compensation handlers to each of the
scopes – addition, subtraction and division. While we do add a compensation handler to
division scope, we know it will never be executed as the division scope is never going to
complete successfully. We shall verify this through the results. Compensation handlers
become active only when the scope they are attached with completes successfully.
Add an assign activity in the compensation handler. Name it reset.
Add a copy operation in that that sets additionResult to -1

Similarly add a reset assign activity to subtraction scope
Now, we need to check for Infinity in Division Scope.

For that, add a switch in the division scope. .
Delete the otherwise branch
In case branch, add an expression, as shown

bpws:getVariableData('divisionResult') = 'Infinity' or
bpws:getVariableData('divisionResult') = '-Infinity'
In the case branch, add a throw activity.

Name the throw activity as Throw_Err and give some value to the namespace and local
part text boxes.
We also added the compensation handler to the division scope. The division scope looks
like this now
Add a catchAll branch to Operations scope. In that catchAll, drag a compensate activity
and name it Compensate_all
After the Operations scope, add a assign activity and name it Prepare_Result
Add the following copy operation to it
concat('Addition result = ',bpws:getVariableData('additionResult'),',

Subtraction result = ',bpws:getVariableData('subtractionResult'),',
Division result = ',bpws:getVariableData('divisionResult'))
The complete BPEL looks like this: (you may enlarge to 150 – 200% to see clearly)
Deploy and test

Give non zero input
Got expected output
Give input such that second value is 0.

What we have achieved is

1. By using compensate activity without specifying any scope, BPEL PM produced
the default behavior -compensation handlers of all completed scopes – addition
and subtraction, were invoked. This can be verified from the values of
additionResult and subtractionResult which were reset to -1
2. Compensation handler for division scope is not called as this scope did not
complete. It is evident from the value of divisionResult, which is still Infinity,
and not -1

Compensate Demo

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Compensate Demo

Transféré par

Droits d'auteur :

Formats disponibles

Sample Practice Document for Training Evaluation http://soatraining.hpage.

With every training session, the presentation used and a practice

This document is a demo of those practice documents. This

Every document starts with an ‘Aim’ and then goes on to develop

Initially the variables for the results – additionResult, subtractionResult and

Start by creating a new project

Modify the input schema to accept two integers

Add a scope named Operations.

Create three variables – additionResult (integer), subtractionResult (integer) and

Follow similar steps for subtractionResult and divisionResult

BPEL looks like this as of now

In each scope add an assign activity.

Similarly do for subtraction and division.

The BPEL now looks like this

Add an assign activity in the compensation handler. Name it reset.

Add a copy operation in that that sets additionResult to -1

Similarly add a reset assign activity to subtraction scope

Now, we need to check for Infinity in Division Scope.

Delete the otherwise branch

In case branch, add an expression, as shown

In the case branch, add a throw activity.

Add the following copy operation to it

concat('Addition result = ',bpws:getVariableData('additionResult'),',

Deploy and test

Got expected output

Give input such that second value is 0.

What we have achieved is

Vous aimerez peut-être aussi