How to modularize a large BPEL process definition?

[kodeninja <ko...@gmail.com>]

Howdy,

I have a pretty large BPEL file (> 12000 LoC) that's become quite unwieldy
now. Opening it up in the NetBeans/Eclipse BPEL editor itself is a pain and
maintaining it is really difficult. What are the best practices to
modularize a large BPEL file?

Part of the reason it's so large is because I have a retry logic implemented
on all the "invoke"s that happen within the BPEL. This code is pretty much
the same for all the invoke calls and has led to a lot of duplication. Is
there a way I can, say, create a reusable function which can be used in the
invoke calls rather pasting the same retry logic again and again? Or maybe a
way to break down the main BPEL into smaller BPEL processes that can be
invoked from the main BPEL?

Basically, I'm looking for ways to manage this complex BPEL process. Any
suggestions/comments?

Thanks,
-Kodeninja
-- 
View this message in context: http://www.nabble.com/How-to-modularize-a-large-BPEL-process-definition--tp24954577p24954577.html
Sent from the Apache Ode User mailing list archive at Nabble.com.

Re: How to modularize a large BPEL process definition?

[Rafal Rusin <ra...@gmail.com>]

Recently, I thought about implementing BPEL-SPE in ODE.
Here are my thoughts:
- BPEL-SPE is not so cool solution, because it's based on
receive/reply activities for communication. In my opinion it would be
better to pass variables between parent and sub process scopes.
- It's quite hard to implement support for multiple processes
references from a single instance because of mixing up bpel-obj
identifiers from multiple CBP files in the instance's state. So for
now I think the best solution is to add subprocesses statement to BPEL
Process and a possibility to include external file with other sub
processes definition (this won't be a bpel file, but subbpel or
something similar). That way we'll have recompilation of sub processes
in each process that includes it. This is bad, but for now a feasible
solution.

Do you agree with this approach?

2009/8/17 Tammo van Lessen <tv...@gmail.com>:
> Hi,
>
> kodeninja wrote:
>> Also, when you say breaking a BPEL process into sub-processes, does
>> it mean just creating multiple BPEL files, each containing a specific
>> portion of the original BPEL, and invoking them via "invoke"?
>
> Exactly. You may run into problems when autonomy of subprocesses is an
> issue, e.g. what happens to a sub-process when the parent process has
> been terminated due to some reason?
> This has been addressed in BPEL-SPE [1], a joint white paper by IBM and
> SAP but has, however, not been implemented in ODE, so you'd have to
> stick to "normal" invocations currently. This is just to make you aware
> of such issues.
>
> best,
>  Tammo
>
> [1]http://www.ibm.com/developerworks/library/specification/ws-bpelsubproc/
>
> --
> Tammo van Lessen - http://www.taval.de
>


Regards,
-- 
Rafał Rusin
http://www.touk.pl
http://top.touk.pl
http://www.mimuw.edu.pl/~rrusin

Re: How to modularize a large BPEL process definition?

[Tammo van Lessen <tv...@gmail.com>]

Hi,

kodeninja wrote:
> Also, when you say breaking a BPEL process into sub-processes, does 
> it mean just creating multiple BPEL files, each containing a specific
> portion of the original BPEL, and invoking them via "invoke"?

Exactly. You may run into problems when autonomy of subprocesses is an
issue, e.g. what happens to a sub-process when the parent process has
been terminated due to some reason?
This has been addressed in BPEL-SPE [1], a joint white paper by IBM and
SAP but has, however, not been implemented in ODE, so you'd have to
stick to "normal" invocations currently. This is just to make you aware
of such issues.

best,
  Tammo

[1]http://www.ibm.com/developerworks/library/specification/ws-bpelsubproc/

-- 
Tammo van Lessen - http://www.taval.de

Re: How to modularize a large BPEL process definition?

[kodeninja <ko...@gmail.com>]

Alex, could you provide some examples of using something like Velocity or
FreeMarker in a BPEL process definition? Also, when you say breaking a BPEL
process into sub-processes, does it mean just creating multiple BPEL files,
each containing a specific portion of the original BPEL, and invoking them
via "invoke"? Or is there some other way to create a sub-process?

-Kodeninja
-- 
View this message in context: http://www.nabble.com/How-to-modularize-a-large-BPEL-process-definition--tp24954577p25004599.html
Sent from the Apache Ode User mailing list archive at Nabble.com.

Re: How to modularize a large BPEL process definition?

[Alex Boisvert <bo...@intalio.com>]

The natural (but somewhat painful) way would be to create sub-processes for
each of these parts and invoke them from the main process.   If there's a
strong pattern between all of them, you could use templating techniques
(e.g. Velocity) to keep your BPELs DRY (don't repeat yourself) and avoid
discrepancies.

alex

On Thu, Aug 13, 2009 at 3:51 PM, kodeninja <ko...@gmail.com> wrote:

>
> Howdy,
>
> I have a pretty large BPEL file (> 12000 LoC) that's become quite unwieldy
> now. Opening it up in the NetBeans/Eclipse BPEL editor itself is a pain and
> maintaining it is really difficult. What are the best practices to
> modularize a large BPEL file?
>
> Part of the reason it's so large is because I have a retry logic
> implemented
> on all the "invoke"s that happen within the BPEL. This code is pretty much
> the same for all the invoke calls and has led to a lot of duplication. Is
> there a way I can, say, create a reusable function which can be used in the
> invoke calls rather pasting the same retry logic again and again? Or maybe
> a
> way to break down the main BPEL into smaller BPEL processes that can be
> invoked from the main BPEL?
>
> Basically, I'm looking for ways to manage this complex BPEL process. Any
> suggestions/comments?
>
> Thanks,
> -Kodeninja
> --
> View this message in context:
> http://www.nabble.com/How-to-modularize-a-large-BPEL-process-definition--tp24954577p24954577.html
> Sent from the Apache Ode User mailing list archive at Nabble.com.
>
>