Simon Moser

Analyzing Compatibility of BPEL Processes

The Business Process Execution Language for Web Services provides a powerful technology to aggregate encapsulated functionalities and define high-value Web services - backed by various development and runtime environments of major software companies. Nevertheless, modeling and composing BPEL processes is still a complicated, time and money consuming, and errorprone activity. Formal methods like Petri nets enable the effective analysis of one single BPEL process as well as the comparison of multiple given BPEL models, and the generation of a BPEL model out of another. The current paper presents an prototypically implemented analysis framework that integrates those methods into IBM’s business integration tools. The value of such a framework is illustrated by analyzing behavioral compatibility between BPEL processes, one of the most crucial properties in real-world B2B scenarios.

Advanced Verification of Distributed WS-BPEL Business Processes Incorporating CSSA-based Data Flow Analysis

The Business Process Execution Language for Web Services WS-BPEL provides an technology to aggregate encapsulated functionalities for defining high-value Web services. For a distributed application in a B2B interaction, the partners simply need to expose their provided functionality as BPEL processes and compose them. Verifying such distributed web service based systems has been a huge topic in the research community lately - cf. [4] for a good overview. However, in most of the work on analyzing properties of interacting Web Services, especially when backed by stateful implementations like WS-BPEL, the data flow present in the implementation is widely neglected, and the analysis focusses on control flow only. This might lead to false-positive analysis results when searching for design weaknesses and errors, e. g. analyzing the controllability [14] of a given BPEL process. In this paper, we present a method to extract dataflow information by constructing a CSSA representation and detecting data dependencies that effect communication behavior. Those discovered dependencies are used to construct a more precise formal model of the given BPEL process and hence to improve the quality of analysis results.

Extending the compatibility notion for abstract WS-BPEL processes

WS-BPEL defines a standard for executable processes. Executable processes are business processes which can be automated through an IT infrastructure. The WS-BPEL specification also introduces the concept of abstract processes: In contrast to their executable siblings, abstract processes are not executable and can have parts where business logic is disguised. Nevertheless, the WS-BPEL specification introduces a notion of compatibility between such an under-specified abstract process and a fully specified executable one. Basically, this compatibility notion defines a set of syntactical rules that can be augmented or restricted by profiles. So far, there exist two of such profiles: the Abstract Process Profile for Observable Behavior and the Abstract Process Profile for Templates. None of these profiles defines a concept of behavioral equivalence. Therefore, both profiles are too strict with respect to the rules they impose when deciding whether an executable process is compatible to an abstract one. In this paper, we propose a novel profile that extends the existing Abstract Process Profile for Observable Behavior by defining a behavioral relationship. We also show that our novel profile allows for more flexibility when deciding whether an executable and an abstract process are compatible.

Automatic Workflow Graph Refactoring and Completion

Workflow graphs are used to model the control flow of business processes in various languages, e.g., BPMN, EPCs and UML activity diagrams. We present techniques for automatic workflow graph refactoring and completion. These techniques enable various use cases in modeling and runtime optimization. For example they allow us to complete a partial workflow graph, they provide local termination detection for workflow graphs with multiple ends, and they allow us to execute models containing OR-joins faster. Some of our techniques are based on workflow graph parsing and the Refined Process Structure Tree [10].

Advanced verification of distributed WS-BPEL business processes incorporating CSSA-based data flow analysis

The Business Process Execution Language for Web Services WS-BPEL provides an technology to aggregate encapsulated functionalities for defining high-value Web services. For a distributed application in a B2B interaction, the partners simply need to expose their provided functionality as BPEL processes and compose them. Verifying such distributed web service based systems has been a huge topic in the research community lately - cf. [4] for a good overview. However, in most of the work on analyzing properties of interacting Web Services, especially when backed by stateful implementations like WS-BPEL, the data flow present in the implementation is widely neglected, and the analysis focusses on control flow only. This might lead to false-positive analysis results when searching for design weaknesses and errors, e. g. analyzing the controllability [14] of a given BPEL process. In this paper, we present a method to extract dataflow information by constructing a CSSA representation and detecting data dependencies that effect communication behavior. Those discovered dependencies are used to construct a more precise formal model of the given BPEL process and hence to improve the quality of analysis results.

Diagnosing SCA components using WOMBAT

The Service Component Architecture (SCA) is a new technology aiming to simplify application development in a service-oriented architecture. Developing a SCA application basically consists of two major parts: The implementation or discovery of individual components, and the assembly of sets of components. Since each assembly itself might act as a component within a larger application, SCA obviously enables the construction of complex distributed systems that are hardly analyzable. Hence crucial questions like compatibility, consistency or soundness of components need to be answered early during the development process. This paper presents Wombat – an analysis tool that is integrated into IBM’s development environment to perform on demand verification tasks. Wombat benefits from established formal methods for distributed systems. It tailors those methods to relevant use case and puts them into a context that directly supports the development of SCA applications.

A hybrid approach for generating compatible WS-BPEL partner processes

The Business Process Execution Language for Web Services provides an technology to aggregate encapsulated functionalities for defining high-value Web services. For a distributed application in a B2B interaction, the partners simply need to expose their behavior as BPEL processes and compose them. Still, modeling and composing BPEL processes can be complex and error-prone. With formal methods like Petri nets, it is possible to analyze crucial properties (e.g. compatibility) effectively. In this paper, we present a method that automatically generates compatible partner BPEL processes for a given BPEL processes. Our hybrid approach makes use of formal methods, but also incorporates the structure of the original BPEL process model, such that the generated partner process is easier to understand and manage.

A Restructuring Method for WS-BPEL Business Processes Based on Extended Workflow Graphs

Much research effort has been spent on the provision of analysis methods for business processes specified by means of Web Services Business Process Execution Language (WS-BPEL). Nevertheless, most approaches neglect conditional control flow, though running the risk of erroneous analysis results. In this paper, we present a restructuring approach for WS-BPEL processes, which helps to partly remedy conditional control flow. We therefore use a combination of workflow graphs and Concurrent Static Single Assignment Form. Based on the hybrid format, we are able to identify loops with static quasi-constant loop condition and transform them in such a way, that conditional control flow is replaced by unconditional control flow. Augmenting an existing analysis with the proposed restructuring then enables more precise results, as is shown for a compatibility analysis of WS-BPEL business processes.

Process restructuring in the presence of message-dependent variables

When services interact, issues can be caused by service implementations being stateful because a stateful implementation requires a certain message exchange protocol to be followed. At present, a model of such a message exchange protocol is seldom complete and precise, mainly because the available analysis techniques for its derivation suffer from drawbacks: most prominently the neglect of data. Process restructuring allows for the increase of precision of such a data-unaware analysis by resolving conditional into unconditional control flow in service implementations and hence eliminating the need to consider data. But the restructuring approach so far has been restricted to cases where conditions of data-based choices have been defined over quasi-constant variables only. In this paper we introduce a restructuring technique that also allows us to resolve data-based choices with conditions over variables whose value is determined by the contents of incoming messages.

Compiling More Precise Petri Net Models for an Improved Verification of Service Implementations

Verification of distributed business processes typically relies on Petri-net-based process models, which allow for a natural modeling and analysis of aspects like parallelism and message exchange. Unfortunately, such a process model is seldom complete and precise today, mainly because the available techniques for its derivation neglect process data in favor of a feasible verification. In this paper, we present an approach for deriving more precise process models in terms of a transforming process-to-Petri-net compiler, which takes as input a business process and generates as output a Petri net model for the process which can subsequently be used for verification. However, in contrast to a conventional compiler, its objective is not to result in efficient runtime code but rather to produce a most-precise though still effectively verifiable Petri-net-based process model.