Dou Sun

SEDA4BPEL: A staged event-driven architecture for high-concurrency BPEL engine

Current BPEL engine products are difficult to meet the highly concurrent demands of increasing mission-critical business processes application. We follow the ideas of SEDA and propose a new architecture for high-concurrency BPEL engine, which we call SEDA4BPEL. In SEDA4BPEL, the implementation of BPEL related web services protocols is encapsulated into four primary event-driven stages, to provide independence, isolation and modularity. We also introduce two controllers to manage excessive concurrent process instances. We present the SEDA4BPEL design and the implementation of a BEPL engine based on this architecture. The evaluation results show that SEDA4BPEL applications exhibit high performance and robustness when handling massive concurrency.

SEDA4SC: A staged event-driven architecture for adaptive service computing runtime

The rapid development of web service technology brings up a number of crucial requirements for designing service computing runtime, such as supporting multiple message exchange patterns, switching among different transports, integrating various extended web service protocols and achieving robust performance under high concurrency. Based on staged event-driven architecture, we propose a novel architecture for an adaptive web-service-centric service computing runtime, named SEDA4SC. In SEDA4SC, the process of basic and extended web service protocols is divided into four primary event-driven stages to enable system independence and module isolation. Moreover, this architecture allows messages to be handled in two independent pipelines: the input pipeline and the output pipeline. Arbitrary message exchange patterns can be supported through a combination of the two pipelines. With SEDA4SC, we design and implement a service computing runtime system. The performance evaluation results show that our system exhibits robust performance under high concurrency.

An operational semantics of WS-BPEL based on abstract BPEL machine

It is very difficult to construct a correct BPEL engine, which is the runtime environment supporting the execution of BPEL processes. The main reason is the complexity of informal specification. It leads to that the programmers build the system without knowing precisely what they do. In this paper, we provide an operational semantics of BPEL based on Abstract BPEL Machine (ABM). ABM is a formal model that simulates the execution environment of BPEL. The functional behavior of a BPEL engine can be described as the input-output state transitions on ABM. It can be further divided into the execution behavior of each BPEL constructs, such as activities and handlers. The aim of our work is to provide the precise understanding on execution model of BPEL, and narrow the gap between BPEL specification and BPEL implementation. The result can be used as a formal specification to construct a correct BPEL engine.

Towards Verifying Global Properties of Adaptive Software Based on Linear Temporal Logic

Increasingly, software needs to dynamically adapt its structure and behavior at runtime in response to changing conditions in the supporting computing, network infrastructure, and in the surrounding physical environments. By high complexity, assurance of high dependability of these software is a great challenge. Effective modeling of behavior and flexibly specifying requirements are the key issues for developing trusted adaptive software. This paper introduces a formal model for the behavior of adaptive software and an extended linear temporal logic to specify global properties. We use state machines to describe programs in different behavioral modes of adaptive software and consider these machines as different versions of programs. Specifications are classified into three categories, local, adaptation and global properties from perspective of dynamic adaptation. To specify and verify global properties on our model, we propose the versioned LTL (vLTL) which extends Linear Temporal Logic by adding version related element and enables describing properties on different versions. We also discuss verifying approach of vLTL by transforming them into LTL formulae and illustrate a study case.

An Approach to Preserving Consistency of SOAs in Dynamic Evolution

Service oriented system is very popular in both academic and industry. One reason is that a new complex application can be agilely implemented via the collaboration of the existent services. In the dynamic web service environment, the web service based applications often suffer from the leaving of component services dynamically, which will result in partial executed conversations, namely the inconsistency of the system. In the paper, we discuss how the inconsistency is produced and present an approach to handle the problem, preserving the system consistency.

Orchestra Designer: an open-source tool for scientific workflow modeling

Scientific workflow has become an important tool used by scientists to operate distributed resources in current scientific research. However, the gap between scientific domain and workflow specification has increased the difficulty of adopting scientific workflow. Further, the lack of collaborative mechanism has gradually become a major obstacle for scientists to share scientific workflow. In this paper, we introduced an open-source tool for scientific workflow modeling, called Orchestra Designer. It solves above problems by isolating domain tasks from workflow specification and providing a service-oriented collaboration bus. Meanwhile, Orchestra Designer supports the design of cross domains scientific workflows.

Reliability Quantification of the Tree Structure Based Distributed System

Due to unpredictable failures in the network or the components, tree-structure, one of the common structures of distributed system, is partial fault-tolerance. A simple but effective method to enhance the reliability of a tree is to maintain a neighbor set for each node in the tree. Obviously, a larger neighbor set results in a higher reliability, but also increases the maintenance cost. The contribution of the paper is to give an algorithm to figure out the reliability of a tree theoretically. We also give an analysis of the results that obtained through the algorithm with various inputs.