Next: , Previous: Top, Up: Top



1 Overview

1.1 Introduction

BPEL2oWFN is a compiler translating a business processes expressed in BPEL (Business Process Execution Language for Web Services) [ACD^+03] into an oWFN (open Workflow Net) [MRS05]. This oWFN can be used to:

BPEL2oWFN uses static analysis to make the generated oWFN as compact as possible to analyze a chosen property. This is called flexible model generation (see Future Work).

BPEL2oWFN is the successor from BPEL2PN [SHS05], a Java-based compiler generating low-level Petri nets. BPEL2oWFN can be understood as a re-implementation for extensibility and performance issues. Its functionality is a superset of the functionality of BPEL2PN. 1

BPEL2oWFN was written by Niels Lohmann, Christian Gierds and Dennis Reinert. It is part of the Tools4BPEL project funded by the German Bundesministerium für Bildung und Forschung. See http://www.informatik.hu-berlin.de/top/tools4bpel for details.

1.2 Translation Process

The translation process of the BPEL business process is performed in six steps which we describe briefly in this section:

  1. Lexical and syntactical analysis. BPEL2oWFN parses the input process according to the specification of BPEL4WS version 1.1 [ACD^+03]. All information about the process is collected in a symbol table for further use.
  2. Semantic analysis. The input file is checked against the constraints of the specification, e.g. that each defined link has to be used as source and target exactly once. BPEL processes violating these constraints are rejected.
  3. AST generation. For further analysis steps the exact syntax (indentation etc.) is not used any more. The input process is represented as an AST (abstract syntax tree). While generating the AST, the implicit transformation rules of BPEL (e.g. the presence of an otherwise-branch with an empty activity) are applied.
  4. Net generation. The nodes of the AST are used to create the Petri net using the pattern database by applying `unparse'-rules (rules associating each node with a pattern).
  5. Net optimization (optional). To reduce the generated net several structural reduction rules can be applied, e.g. to merge sequences.
  6. Net output. The generated Petri net can be exported in several file formats.

1.3 Concepts of BPEL2oWFN

In this section we describe the main concepts of BPEL2oWFN used to realize the translation. Reading this section is not necessary for using BPEL2oWFN, yet knowing the underlying algorithms and data structures not only helps to locate bugs, but also helps you to customize BPEL2oWFN or request a feature.

1.3.1 Abstract Syntax Tree

The AST (abstract syntax tree) is an abstraction of the syntax tree generated while parsing the BPEL process: any unnecessary information (e.g. indention, brackets or other “syntax-supporting” elements) is omitted. It is the central data structure of BPEL2oWFN. The nodes of the AST are annotated with pointers to symbol table entries during the analysis steps. These annotations are used to select the most compact Petri net pattern from the pattern database to check a given property.

1.3.2 Pattern Repository

The idea of flexible model generation is to find the most compact model to check a given property. The patterns of the Petri net semantics of [Sta05] are designed to fit in any given context. However when the context is known some behavior modeled in the patterns (i.e. some of the nodes) can be safely removed without changing its semantics. BPEL2oWFN is designed to hold several sets of Petri net patterns each suitable in certain contexts. These patterns are collected in a pattern repository.

1.3.3 Petri Net Class

BPEL2oWFN provides many algorithms and data structures to build, represent, modify and simplify Petri nets and open workflow nets, resp. They are the interface between the pattern database and the file output for the model checking tool. The functions are collected in an extensible class allowing to add more output file formats, structural simplification rules (optimized to preserve certain properties such as deadlock freedom or liveness) or abstractions (e.g. abstraction from variables, abstraction from external behavior).

1.3.4 Control Flow Graph

Beside the dynamic analysis of the generated Petri net model with Fiona or classical model checking tools, BPEL2oWFN prototypically implements a control flow graph (CFG) (c.f. [Hei03]). This CFG can be used to check most of the constraints of the specification statically, i.e. without actually deploying and running the BPEL process. For example, the CFG can be used to check if each variable is initialized by an incoming message or an <assign> activity.


Footnotes

[1] In fact, BPEL2oWFN can simulate the behavior of BPEL2PN with a command-line parameter (see Invoking BPEL2oWFN).