A Case Study of Web Services Orchestration

Abstract

Recently the term Web Services Orchestration has been introduced to address composition and coordination of Web Services. Several languages to describe orchestration for business processes have been presented and many of them use concepts such as long-running transactions and compensations to cope with error handling. WS-BPEL is currently the best suited in this field. However, its complexity hinders rigorous treatment. In this paper we address the notion of orchestration from a formal point of view, with particular attention to transactions and compensations. In particular, we discuss web π _∞ an untimed subcalculus of web π [15] which is a simple and conservative extension of the π-calculus. We introduce it as a theoretical and foundational model for Web Services coordination. We simplify some semantical and pragmatical aspects, in particular regarding temporization, gaining a better understanding of the fundamental issues. To discuss the usefulness of the language we consider a case study: we formalize an e-commerce transactional scenario drawing on a case presented in our previous work [12].

Manuel Mazzara, Sergio Govoni

A Correct Abstract Machine for Safe Ambients

Abstract

We describe an abstract machine, called GcPan, for the distributed execution of Safe Ambients (SA), a variant of the Ambient Calculus (AC).

Our machine improves over previous proposals for executing AC, or variants of it, mainly through a better management of special agents (forwarders), created upon code migration to transmit messages to the target location of the migration.

We establish the correctness of our machine by proving a weak bisimilarity result with a previous abstract machine for SA, and then appealing to the correctness of the latter machine.

More broadly, this study is a contribution towards understanding issues of correctness and optimisations in implementations of distributed languages encompassing mobility.

Daniel Hirschkoff, Damien Pous, Davide Sangiorgi

A Process Calculus for QoS-Aware Applications

Abstract

The definition of suitable abstractions and models for identifying, understanding and managing Quality of Service (QoS) constraints is a challenging issue of the Service Oriented Computing paradigm. In this paper we introduce a process calculus where QoS attributes are first class objects. We identify a minimal set of primitives that allow capturing in an abstract way the ability to control and coordinate services in presence of QoS constraints.

Rocco De Nicola, Gianluigi Ferrari, Ugo Montanari, Rosario Pugliese, Emilio Tuosto

Abstract Interpretation-Based Verification of Non-functional Requirements

Abstract

The paper investigates a formal approach to the verification of non functional software requirements, e.g. portability, time and space efficiency, dependability/robustness. The key-idea is the notion of observable, i.e., an abstraction of the concrete semantics when focusing on a behavioral property of interest. By applying an abstract interpretation-based static analysis of the source program, and by a suitable choice of abstract domains, it is possible to design formal and effective tools for non-functional requirements validation.

Agostino Cortesi, Francesco Logozzo

Coordination Systems in Role-Based Adaptive Software

Abstract

Software systems are becoming more open, distributed, pervasive, and connected. In such systems, the relationships between loosely-coupled application elements become non-deterministic. Coordination can be viewed as a way of making such loosely coupled systems more adaptable. In this paper we show how coordination-systems, which are analogous to nervous systems, can be defined independently from the functional systems they regulate. Such coordination systems are a network of organisers and contracts. We show how the contracts that make up the coordination-system can be used to monitor, regulate and configure the interactions between clusters of software entities called roles. Management and functional levels of contracts are defined. Management contracts regulate the flow of control through the roles. Functional contracts allow the specification of performance conditions. These contracts bind clusters of roles into self-managed composites — each composite with its own organiser role. The organiser roles can control, create, abrogate and reassign contracts. Adaptive systems are built from a recursive structure of such self-managed composites. The network of organiser roles and the contracts they control constitute a coordination-system that is a separate concern to the functional system. Association aspects are suggested as a mechanism to implement such coordination-systems.

Alan Colman, Jun Han

Coordination with Multicapabilities

Abstract

In the context of open distributed systems, the ability to coordinate the agents coupled with the possibility to control the actions they perform is important. As open systems need to be scalable, capabilities may provide the best-fit solution to overcome the problems caused by the loosely controlled coordination of Linda -like systems. Acting as a ‘ticket’, capabilities can be given to the chosen agents, granting them different privileges over different kinds of data—thus providing the system with a finer control on objects’ visibility to agents. One drawback of capabilities is that they can only be applied to named objects—something that is not universally applicable in Linda since, in contrast to tuple-spaces, tuples are nameless. This paper demonstrates how the advantages of capabilities can be extended to tuples, with the introduction of multicapabilities, which generalise capabilities to collections of objects.

Nur Izura Udzir, Alan M. Wood, Jeremy L. Jacob

Delegation Modeling with Paradigm

Abstract

Within one model, behavioural consistency of its constituents is often problematic. Within UML such horizontal behavioural consistency between the objects of a concrete model, is particularly needed in the context of dynamic patterns. Here, we investigate delegation, which is fundamental to patterns that separate the locality of receiving a request, and one or more localities actually handling it. We specify delegation by means of the coordination language Paradigm. In particular, we present some variants of delegation in the context of a broker pattern and clarify how the Paradigm notions are the basis for understanding a solution as well as for adapting it to deal with other dynamic features.

Luuk Groenewegen, Niels van Kampenhout, Erik de Vink

Dynamically Adapting Tuple Replication for Managing Availability in a Shared Data Space

Abstract

With its decoupling of processes in space and time, the shared data space model has proven to be a well-suited solution for developing distributed component-based systems. However, as in many distributed applications, functional and extra-functional aspects are still interwoven in components. In this paper, we address how shared data spaces can support separation of concerns. In particular, we present a solution that allows developers to merely specify performance and availability requirements for data tuples, while the underlying middleware evaluates various distribution and replication policies in order to select the one that meets these requirements best. Moreover, in our approach, the middleware continuously monitors the behavior of application and system components, and switches to different policies if this would lead to better results. We describe our approach, along with the design of a prototype implementation and its quantitative evaluation.

Giovanni Russello, Michel Chaudron, Maarten van Steen

Enforcing Distributed Information Flow Policies Architecturally: The SAID Approach

Abstract

Architectural security of a distributed system is best considered at design time rather than further down the software life cycle where it may become very expensive to make even minor modifications to the software architecture. In this paper we take Architectural Interaction Diagrams (AID) [9,8], an architecture description framework with an unique ability to encode communication efficiently and augment actions of AID components with security levels to produce SAID. This new architecture description language enables the designer to impose information flow restriction policies on system communications at design time which in turn allows a reduction of the information flow analysis problem for distributed systems to the simpler problem of information flow analysis of individual components of the distributed system.

Arnab Ray

Experience Using a Coordination-Based Architecture for Adaptive Web Content Provision

Abstract

There are many ways of achieving scalable dynamic web content. In previous work we have focused on dynamic content degradation using a standard architecture and a design-time “Just In Case” methodology. In this paper, we address certain shortcomings witnessed in our previous work by using an alternate coordination-based architecture, which has interesting applicability to run-time web server adaptation. We first establish the viability of using this architecture for high-volume dynamic web content generation. In doing so, we establish its ability to maintain high throughput in overload conditions. We go on to show how we used the architecture to achieve a “Just In Time” adaptation to achieve dynamic web content degradation in a running web application server.

Lindsay Bradford, Stephen Milliner, Marlon Dumas

Global Computing in a Dynamic Network of Tuple Spaces

Abstract

We present a calculus inspired by Klaim whose main features are: explicit process distribution and node interconnections, remote operations, process mobility and asynchronous communication through distributed tuple spaces. We first introduce a basic language where connections are reliable and immutable; then, we enrich it with two more advanced features for global computing, i.e. failures and dynamically evolving connections. In each setting, we use our formalisms to specify some non-trivial global computing applications and exploit the semantic theory based on an observational equivalence to equationally establish properties of the considered case-studies.

Rocco De Nicola, Daniele Gorla, Rosario Pugliese

Mobile Agent Based Fault-Tolerance Support for the Reliable Mobile Computing Systems

Abstract

To support the fault tolerance of mobile computing systems, many checkpointing coordination and message logging schemes have been proposed. However, due to the mobility of mobile hosts, coordination and control of these schemes are quite complicate and have the possibility of inefficiency. In this paper, a fault-tolerance scheme based on mobile agents is proposed. In the proposed scheme, a set of mobile and stationary agents are used to trace and maintain the recovery information for the mobile host. The mobile agents properly trace the mobile host and manage the suitable distance between the recovery information and the mobile host. Also, the migration of the recovery information of the mobile host can be performed asynchronously with the hand-off of the mobile host and hence the fault-tolerance service by mobile agents dose not incur any unnecessary hand-off delay.

Taesoon Park

Preserving Architectural Properties in Multithreaded Code Generation

Abstract

Architectural descriptions can provide support for a formal representation of the structure and the overall behavior of software systems, which is suitable for an early assessment of the system properties as well as for the automated generation of code. The problem addressed in this paper is to what extent the properties verified at the architectural level can be preserved during the code generation process for multithreaded programs. In order to limit the human intervention, we propose to separate the thread synchronization management from the thread behavior translation. While a completely automated and architecture-driven approach can guarantee the correct thread coordination, we show that only a partial translation based on stubs is possible for the behavior of the threads, with the preservation of the architectural properties depending on the way in which the stubs are filled in.

Marco Bernardo, Edoardo Bontà

Prioritized and Parallel Reactions in Shared Data Space Coordination Languages

Abstract

Reactive programming has been added to the traditional Linda programming style in order to deal with the dynamic aspects of those applications in which it is important to observe modifications of the environment which occur quickly. Reactive programming is embedded in shared data spaces by defining the observable entities and the corresponding reactions that usually are processes possibly executing coordination primitives. Typical observable entities are the presence in the space of a datum (state-based) or the execution of a particular primitive (event-based). In this paper we consider different models of reaction execution adopted in the coordination literature so far, namely the prioritized model (used e.g. in MARS [3], TuCSoN [8] and LIME [9]) and the parallel execution model (considered e.g. in JavaSpaces [13 ], TSpaces [14] and WCL [11]). Prioritized reactions are usually implemented at server-side as during their execution no other coordination primitives can take place; parallel reactions, more suited when reactions are executed at client-side, are executed in parallel with the other processes in the system (thus other coordination primitives can interleave with the reactions). Using a process algebraic setting we perform a rigorous investigation of the relative advantages and disadvantages of these two models for reaction execution.

Nadia Busi, Gianluigi Zavattaro

Synchronized Hyperedge Replacement for Heterogeneous Systems

Abstract

We present a framework for modelling heterogeneous distributed systems using graph transformations in the Synchronized Hyperedge Replacement approach, which describes complex evolutions by synchronizing local rules. In order to deal with heterogeneity, we consider different synchronization algebras for different communication channels. The main technical point is the interaction between synchronization algebras and name mobility in the π-calculus style. The power of our approach is shown through a few examples.

Ivan Lanese, Emilio Tuosto

Synthesis of Reo Circuits for Implementation of Component-Connector Automata Specifications

Abstract

Composition of a concurrent system out of components involves coordination of their mutual interactions. In component-based construction, this coordination becomes the responsibility of the glue-code language and its underlying run-time middle-ware. Reo offers an expressive glue-language for construction of coordinating component connectors out of primitive channels. In this paper we consider the problem of synthesizing Reo coordination code from a specification of a behavior as a relation on scheduled-data streams. The specification is given as a constraint automaton that describes the desired input/output behavior at the ports of the components. The main contribution in this paper is an algorithm that generates Reo code from a given constraint automaton.

Farhad Arbab, Christel Baier, Frank de Boer, Jan Rutten, Marjan Sirjani

Tagged Sets: A Secure and Transparent Coordination Medium

Abstract

A simple and effective way of coordinating distributed, mobile, and parallel applications is to use a virtual shared memory (VSM), such as a Linda tuple-space. In this paper, we propose a new kind of VSM, called a tagged set. Each element in the VSM is a value with an associated tag, and values are read or removed from the VSM by matching the tag. Tagged sets exhibit three properties useful for VSMs:

1

Ease of use. A tagged value naturally corresponds to the notion that data has certain attributes, expressed by the tag, which can be used for later retrieval.

2

Flexibility. Tags are implemented as propositional logic formulae, and selection as logical implication, so the resulting system is quite powerful. Tagged sets naturally support a variety of applications, such as shared data repositories (e.g., for media or e-mail), message passing, and publish/subscribe algorithms; they are powerful enough to encode existing VSMs, such as Linda spaces.

3

Security. Our notion of tags naturally corresponds to keys, or capabilities: a user may not select data in the set unless she presents a legal key or keys. Normal tags correspond to symmetric keys, and we introduce asymmetric tags that correspond to public and private key pairs. Treating tags as keys permits users to easily specify protection criteria for data at a fine granularity.

This paper motivates our approach, sketches its basic theory, and places it in the context of other data management strategies.

Manuel Oriol, Michael Hicks

Time-Aware Coordination in ReSpecT

Abstract

Tuple centres allow for dynamic programming of the coordination media: coordination laws are expressed and enforced as the behaviour specification of tuple centres, and can change over time. Since time is essential in a large number of coordination problems and patterns (involving timeouts, obligations, commitments), coordination laws should be expressive enough to capture and govern time-related issues.

Along this line, in this paper we discuss how tuple centres and the ReSpecT language for programming logic tuple centres can be extended to catch with time, and to support the definition and enforcement of time-aware coordination policies. Some examples are provided to demonstrate the expressiveness of the ReSpecT language to model timed coordination primitives and laws.

Andrea Omicini, Alessandro Ricci, Mirko Viroli

Transactional Aspects in Semantic Based Discovery of Services

Abstract

In a Service Oriented Architecture (SOA), services may need to dynamically discover non-functional properties of possible other services to cooperate with. Among these non-functional properties, transactional support is particularly relevant to enable coordination. In this paper we model the transactional support of Web services in a machine readable format (using OWL-S); in our model transactional support can be defined as negotiable thus requiring a run time multi step interaction among services to agree on the supported transaction type. We use the Business Transaction Protocol (BTP), a distributed transaction protocol, to carry out this negotiation. Specifically, we use an implementation of the bidding negotiation in BTP with the asynchronous pi calculus in order to provide a formal framework for these coordination issues.

Laura Bocchi, Paolo Ciancarini, Davide Rossi

Springer Professional

Coordination Models and Languages

7th International Conference, COORDINATION 2005, Namur, Belgium, April 20-23, 2005. Proceedings

Inhaltsverzeichnis

Frontmatter

A Case Study of Web Services Orchestration

A Correct Abstract Machine for Safe Ambients

A Process Calculus for QoS-Aware Applications

Abstract Interpretation-Based Verification of Non-functional Requirements

Coordination Systems in Role-Based Adaptive Software

Coordination with Multicapabilities

Delegation Modeling with Paradigm

Dynamically Adapting Tuple Replication for Managing Availability in a Shared Data Space

Enforcing Distributed Information Flow Policies Architecturally: The SAID Approach

Experience Using a Coordination-Based Architecture for Adaptive Web Content Provision

Global Computing in a Dynamic Network of Tuple Spaces

Mobile Agent Based Fault-Tolerance Support for the Reliable Mobile Computing Systems

Preserving Architectural Properties in Multithreaded Code Generation

Prioritized and Parallel Reactions in Shared Data Space Coordination Languages

Synchronized Hyperedge Replacement for Heterogeneous Systems

Synthesis of Reo Circuits for Implementation of Component-Connector Automata Specifications

Tagged Sets: A Secure and Transparent Coordination Medium

Time-Aware Coordination in ReSpecT

Transactional Aspects in Semantic Based Discovery of Services

Backmatter

Premium Partner