Analyzing interacting WS-BPEL processes using flexible model generation

https://doi.org/10.1016/j.datak.2007.06.006Get rights and content

Abstract

We address the problem of analyzing the interaction between WS-BPEL processes. We present a technology chain that starts out with a WS-BPEL process and translates it into a Petri net model. On the model we decide controllability of the process (the existence of a partner process, such that both can interact properly) and compute its operating guideline (a characterization of all properly interacting partner processes). To manage processes of realistic size, we present a concept of a flexible model generation which allows the generation of compact Petri net models. A case study demonstrates the value of this technology chain.

Introduction

The Web Services Business Process Execution Language (WS-BPEL) [1] is a language for describing the behavior of business processes based on web services. A WS-BPEL process or process for short can be seen as a workflow enhanced by an interface description specifying the interactional behavior of this process with other processes, its partners. The interaction between processes may be nontrivial. Thus, it is a challenging task to decide whether all processes interact properly; that is, the interaction is free of deadlocks and there are no messages being sent that cannot be received any more. There are two main reasons for improper interaction: (1) A process may have an erroneous design. For instance, the process may contain an internal choice relevant for the expected behavior of a partner, but the partner is not informed which decision is actually made. (2) The interactional behaviors of two processes exclude each other. For example, the processes run into a situation where one process waits for a message of the other one and vice versa. Therefore, tool support is needed to assist process designers during the modeling.

In [2], we presented a technology chain that starts out with a BPEL4WS [3] process,1 translates it into a Petri net model, and finally analyzes this model. We introduced two tools: BPEL2oWFN and Fiona. BPEL2oWFN translates a process into an open workflow net (oWFN), a special class of Petri nets modeling the interactional behavior of its corresponding BPEL process. Fiona then analyzes whether this oWFN is controllable. An oWFN is controllable [4], [5] if there exists a partner such that both can interact properly. Fiona can also calculate the operating guideline of a given oWFN. The operating guideline characterizes all properly interacting partners in a compact way [6]. In addition, BPEL2oWFN also supports the translation into Petri nets modeling the internal behavior only. These nets can be analyzed by common model checkers.

In this paper, we improve the proposed technology chain presented in Fig. 1. Firstly, BPEL2oWFN is no longer restricted to processes specified in BPEL4WS. It now also translates processes compliant to the current WS-BPEL specification. To the best of our knowledge, this is the only formal semantics for WS-BPEL 2.0. Compared to the BPEL4WS specification, WS-BPEL 2.0 contains many new activities and other constructs, and clarifies the semantics of several complex scenarios such as compensation. Secondly, we further improved the translation to generate compact Petri net models. We introduce our concept of a flexible model generation that was only sketched in [2]. The idea is to have, for each WS-BPEL construct, several patterns that are applicable in different contexts. Using static analysis on the WS-BPEL code, information is derived to select the most abstract pattern applicable in a given context. With the help of data abstraction, the complexity of WS-BPEL processes of realistic size is reduced in such a way that they can be efficiently analyzed.

It is worthwhile to mention that the concepts of this paper are not restricted to analyze WS-BPEL processes only. The concept of flexible model generation as implemented in BPEL2oWFN can be applied to any other process description language and likewise to any other target formalism. Our presented model, open workflow nets, is a general formalism that can be used to model various kinds of interacting processes. Since the algorithms of Fiona are based on oWFNs we are not restricted to a specific process description language like WS-BPEL.

The paper is organized as follows. In Section 2, we introduce the general concepts of WS-BPEL and our model, open workflow nets. We also explain controllability of oWFNs and the operating guideline of an oWFN. A WS-BPEL example process, an online shop, is presented in Section 3. Our main contribution is presented in Section 4, where we explain the concepts of our advanced translation and especially flexible model generation. It is exemplified by translating the online shop into an oWFN. The resulting oWFN is then analyzed in Section 5. We present a slightly modified version of that process in Section 6 and analyze it, too. In Section 7, we describe related work. Finally, we conclude with some directions for future research.

Section snippets

WS-BPEL

The Web Services Business Process Execution Language (WS-BPEL) [1] is a language for describing the behavior of business processes based on web services. For the specification of a business process, WS-BPEL provides activities and distinguishes between basic and structured activities. A basic activity can communicate with the partners by messages (invoke,2 receive, reply), manipulate or check data (assign, validate), wait for some time (wait) or

Example process: online shop

In this section, we present an online shop as our example process. It is a nontrivial extension of the process presented in [2]. The online shop’s WS-BPEL process consists of 25 activities, a fault handler, an event handler, and a compensation handler. The shop is depicted in Fig. 5 in a common graphical notation.

When the online shop receives the login information from a customer, its business strategy distinguishes between premium and standard customers (upper if statement). The premium

Open workflow net semantics for WS-BPEL

We aim at formally analyzing WS-BPEL processes. To achieve this aim, we translate a WS-BPEL process into an oWFN. The translation is guided by the syntax of WS-BPEL. In WS-BPEL, a process is built by plugging instances of WS-BPEL constructs together. Accordingly, we translate each construct of the language separately into an oWFN. Such a net forms a pattern of the respective WS-BPEL construct. Each pattern has an interface for joining it with other patterns as it is done with WS-BPEL

The tool Fiona

Fiona6 is a tool to automatically analyze the interactional behavior of a given oWFN N. The input format of Fiona is the oWFN output format of BPEL2oWFN. Hence, we can easily analyze WS-BPEL processes. Fiona provides two techniques: it checks for the controllability of N or it calculates the operating guideline of N.

The algorithm to construct the OG as described in Section 2.4 performs three steps: first, a full automaton F is

The online shop revised

Let us take a look at the online shop presented in Section 3 once again. The shop now slightly modifies its business strategy: every premium customer may choose a gift after login. The modified online shop is depicted in Fig. 10a.

The changes only affect the left branch of the first if-statement. The shop sends a login confirmation (confirm) first and then expects the customer to choose a gift. The rest of the process is as in Fig. 5.

The analysis with Fiona reflects that this simple change has a

Related work

Several groups have proposed formal semantics for BPEL4WS 1.1. Among them, there are semantics based on finite state machines [20], [21], the process algebra Lotos [22], abstract state machines [23], [24], and Petri nets [25], [12]. However, to the best of our knowledge, the Petri net semantics proposed in this paper is the only formal semantics for WS-BPEL 2.0.

The groups of van der Aalst and ter Hofstede also follow a Petri net-based approach [25]. Their semantics, however, is restricted to

Conclusion and further work

We presented a framework to formally analyze the interactional behavior of WS-BPEL processes. Both the translation from WS-BPEL into compact Petri net models as well as the further analysis of controllability and the computation of the operating guideline are implemented which allows for a fully-automatic analysis. The results show that we can detect nontrivial model flaws of interacting WS-BPEL processes that would have been hard or impossible to find manually.

In BPEL2oWFN, we have implemented

Niels Lohmann studied Computer Science at Humboldt-Universität zu Berlin, Germany. He received his master’s degree in September, 2005. Since then, he is working as a research assistant at Humboldt-Universität zu Berlin and is preparing his doctoral degree. His research interests include process modeling, process analysis, formal methods, in particular Petri nets, and model checking.

References (28)

  • A. Alves, A. Arkin, S. Askary, C. Barreto, B. Bloch, F. Curbera, M. Ford, Y. Goland, A. Guízar, N. Kartha, C.K. Liu, R....
  • N. Lohmann et al.

    Analyzing interacting BPEL processes

  • T. Andrews, F. Curbera, H. Dholakia, Y. Goland, J. Klein, F. Leymann, K. Liu, D. Roller, D. Smith, S. Thatte, I....
  • K. Schmidt

    Controllability of open workflow nets

  • D. Weinberg, Reduction Rules for Interaction Graphs, Techn. Report 198, Humboldt-Universität zu Berlin, February...
  • P. Massuthe et al.

    Operating guidelines—an automata-theoretic foundation for the service-oriented architecture

  • P. Massuthe et al.

    An operating guideline approach to the SOA

    Annals of Mathematics, Computing and Teleinformatics

    (2005)
  • W.M.P. v. d. Aalst

    The application of Petri nets to workflow management

    Journal of Circuits, Systems and Computers

    (1998)
  • P. Ramadge et al.

    Supervisory control of a class of discrete event processes

    SIAM Journal of Control and Optimization

    (1987)
  • E. Badouel et al.

    Theory of regions

  • N. Lohmann, P. Massuthe, K. Wolf, Operating guidelines for finite-state services, Techn. Report 210,...
  • C. Stahl, A Petri Net Semantics for BPEL, Techn. Report 188, Humboldt-Universität zu Berlin, July...
  • N. Lohmann, A feature-complete Petri Net Semantics for WS-BPEL 2.0, in: K. van Hee, W. Reisig, K. Wolf (Eds.),...
  • S. Hinz et al.

    Transforming BPEL to Petri nets

  • Cited by (98)

    • Ensuring the canonicity of process models

      2017, Data and Knowledge Engineering
      Citation Excerpt :

      Most prominent is the soundness property [12] and its derivatives for Petri nets [15,17,16,18]. These analyses for Petri nets can be used for other languages by transformation from BPMN [30], BPEL [31], UML Activity Diagrams [32], EPCs [33,34], and YAWL [35]. Comparable formalisms such as behavioural profiles [8] or meta graphs [19] are utilized as well.

    • Patterns for emerging application integration scenarios: A survey

      2017, Information Systems
      Citation Excerpt :

      For SOA web service conversation policies [19] and interaction patterns [37] solutions were provided. Formalizations have been proposed in [34] for the SOA domain with focus on the controllability of a process. The proposed solutions for SOA might be transfered to integration processes as starting point for more general conversation patterns.

    • Deciding conformance for bounded responsiveness

      2017, Science of Computer Programming
      Citation Excerpt :

      Accordance for deadlock freedom is strictly weaker than conformance for responsiveness, because responsiveness implies deadlock freedom. Based on the accordance relation, Lohmann et al. [25] introduce a single service that encodes a set of services, which motivates the notion of a maximal b-partner. With Theorem 41, we showed how the notion of a maximal b-partner can be used to decide b-conformance.

    • Petri net model checking with LoLA 2

      2018, Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)
    • A formal framework for specifying and verifying microservices based process flows

      2018, Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)
    View all citing articles on Scopus

    Niels Lohmann studied Computer Science at Humboldt-Universität zu Berlin, Germany. He received his master’s degree in September, 2005. Since then, he is working as a research assistant at Humboldt-Universität zu Berlin and is preparing his doctoral degree. His research interests include process modeling, process analysis, formal methods, in particular Petri nets, and model checking.

    Peter Massuthe studied Computer Science at Humboldt-Universität zu Berlin, Germany. He received his master’s degree in March, 2004. Since then, he is working as a research assistant at Humboldt-Universität zu Berlin and is preparing his doctoral degree. His research interests include temporal logics, Petri nets, model checking, and formal methods for services.

    Christian Stahl studied computer science at Humboldt-Universität zu Berlin, Germany. He received his master’s degree in 2004. Since then, he is working as a research assistant in the group of Wolfgang Reisig in Berlin and since 2006 also in the group of Kees van Hee and Wil van der Aalst in Eindhoven. His research interests include process modeling, process analysis, formal methods, in particular Petri nets, and model checking.

    Daniela Weinberg studied Computer Science at Humboldt-Universität zu Berlin, Germany. She has received her master’s degree in October, 2004. She now works as a research assistant at Humboldt-Universität zu Berlin and is preparing her doctoral degree. Her research interests are centered around Petri nets, model checking, temporal logics, and formal methods for services.

    Partially funded by the BMBF project “Tools4BPEL”.

    View full text