Daniele Strollo

JSCL: a middleware for service coordination

This paper describes the design and the prototype implementation of a middleware, called Java Signal Core Layer (jscl), for coordinating distributed services. jscl supports the coordination of distributed services by exploiting an event notification paradigm. The design and the implementation of jscl has been inspired and driven by its formal specification given as a process calculus, the Signal Calculus (sc). At the experimental level JSCL has been exploited to implement Long Running Transactions (LRTs).

From theory to practice in transactional composition of web services

We address the problem of composing Web Services in long-running transactional business processes, where compensations must be dealt with appropriately. The framework presented in this paper is a Java API called Java Transactional Web Services (jtws), which provides suitable primitives for wrapping and invoking Web Services as activities in long-running transactions. jtws adheres to a process calculi formalisation of long-running transactions, called saga, which fixes unambiguously the implemented compensation policy. In particular, the primitives provided by jtws are in one-to-one correspondence with the primitives of sagas,and they are abstract enough to hide the complex details of their realization, thus favouring usability. Moreover, jtws orchestrates business processes in a distributed way.

Event based choreography

An important feature of the service-oriented approach is the ability to aggregate, through programmable coordination patterns, the activities involved in service interactions. Two different approaches can be adopted to tackle service coordination: orchestration and choreography. In this paper, we introduce a formal methodology to handle coordination among services from the perspective of a global observer, in the spirit of choreography models. In particular, we address the problem of verifying compliance and consistency between the design of service interactions and the choreography constraints.

Checking Correctness of Transactional Behaviors

The Signal Calculus is an asynchronous process calculus featuring multicast communication. It relies on explicit modeling of the communication structure of the network (communication flows), and on handling sessions, even multi-party. The calculus is strongly motivated by the practical needs of Service-Oriented Computing, and there exists a Java implementation, called JSCL, with a graphical modeling framework. To the aim of adding to SC (and JSCL) a verification environment, in this work we introduce the abstract semantics of SC , based on bisimulation. We show an example exploiting bisimilarity to prove the correctness of an SC model with respects to a transactional isolation requirement.

Global Coordination Policies for Services

An important issue of the service oriented approach is the possibility to aggregate, through programmable coordination patterns, the activities involved by service interactions. Two different approaches can be adopted to tackle service coordination: orchestration and choreography. In this paper, we introduce a formal methodology purposed to handle coordination among services from the perspective of a global observer, in the spirit of choreography models. In particular, we address the problem of verifying compliance and consistency between the design of service interactions and the choreography constraints.

Model-driven development of long running transactions

The management of Long Running Transactions is a crucial aspect in the field of Service Oriented Architectures. This chapter reports on the usage of the ESC middleware in the design and implementation of long running transactions. The middleware has been formally defined as a process calculus and supports a model-driven methodology which clearly separates the development stages of long running transactions.

Debugging Distributed Systems with Causal Nets

Modern computing is typically distributed as data are stored on systems that are connected to form huge networks and computations take place on several locations. Moreover, emergent metaphors for programming modern networks (aka overlay computers) aim to dynamic composition of distributed computational units. For instance, the service oriented computing paradigm promotes the composition of distributed services (the unit of computation) that are available and can be dynamically bound and interact. Formal methods for deciding (and measuring) the properties of such systems are of course of paramount importance. However, they may require to master sophisticated techniques that programmers may lack. This issue can be mitigated by providing programmers with tools and techniques that are close to the usual programming practice. Following this approach, in [5] causal nets have been used to define a few debugging primitives that may help in the analysis of mobile code for the ambient calculus [1]. Figure 1 gives a pictorial representation of a trace of an ambient process in terms of causal nets. Places are labelled by either ambient names (if any) or by ◦ and denote the states of ambient processes (places carrying the same ambient names are told apart from indexes). Transitions are labelled by ambient capabilities (in, out , open) or by sync or (representing communication and the arrival (resp. departure) of an external (resp. internal) ambient). For instance, the ambient k in Figure 1 enters p after exiting its surrounding ambient. A key idea of [5] is the usage of causal nets that, transparently to the programmer, build up the causal information of mobile ambients along their evolution. In fact, in [5] a few debugging primitives are defined in terms of operations on the causal nets associated with ambients in order to trace their migrations/synchronization along the computation. Using the debugging primitives, programmers can “query” the causal nets in order to reconstruct how the

Refactoring long running transactions: a case study

Managing transactions is a key issue in Service Oriented Computing where particular relevance is given to the so called Long Running Transactions (LRT). Here, we show how to apply a formal approach to the specification and refactoring of LRT. Specifically, we consider a methodology arising on process calculi and show how it can be applied to a case study.