Guoquan Wu

Flexible Pattern Monitoring for WS-BPEL through Stateful Aspect Extension

The execution of composite web services with WS-BPEL relies on externally autonomous Web services. This implies the need to constantly monitor the running behavior of the involved parties. Moreover, monitoring the execution of such processes is critical to enforce business policies and meet reliability goals. This paper proposes a stateful aspect extension to WS-BPEL, as a solution to support flexible behavior pattern monitoring for composite Web services. Specifically, in the stateful aspect, history-based pointcut specifies the pattern of interest within a range, while advice describes the associated action to manage the process if the specified pattern occurs. We also present its implementation based on finite state automata through runtime weaving mechanism. Our experiments indicate the proposed monitoring approach incurs minimal overhead.

Runtime monitoring composite web services through stateful aspect extension

The execution of composite Web services with WS-BPEL relies on externally autonomous Web services. This implies the need to constantly monitor the running behavior of the involved parties. Moreover, monitoring the execution of composite Web services for particular patterns is critical to enhance the reliability of the processes. In this paper, we propose an aspect-oriented framework as a solution to provide monitoring and recovery support for composite Web services. In particular, this framework includes 1) a stateful aspect based template, where history-based pointcut specifies patterns of interest cannot be violated within a range, while advice specifies the associated recovery action; 2) a tool support for runtime monitoring and recovery based on aspect-oriented execution environment. Our experiments indicate that the proposed monitoring approach incurs minimal overhead and is efficient.

Developing a Concurrent Service Orchestration Engine Based on Event-Driven Architecture

WS-BPEL (BPEL for short) represents the de-factor standard for the Web services composition. Service orchestration engines, also named BPEL engines, are in charge of executing and managing the workflow specified in BPEL. As a kind of server application, high performance under massive concurrency is necessary to design a scalable BPEL engine, and it is a challenging problem to implement a correct and highly concurrent BPEL engine. We propose an approach based on event-driven architecture to design BPEL engine and introduce the FSM (finite state machines) to describe the semantics of the BPEL process. We also test our BPEL engine and prove the improvement in capability of handling the massive concurrency comparing to the one based on the thread-based concurrent paradigm.

Detecting Data Inconsistency Failure of Composite Web Services Through Parametric Stateful Aspect

Runtime monitoring of Web service compositions with WS-BPEL has been widely acknowledged as a significant approach to understand and guarantee the quality of services. However, most existing monitoring technologies only track patterns related to the execution of an individual process. As a result, the possible inconsistency failure caused by implicit interactions among concurrent process instances cannot be detected. To address this issue, this paper proposes an approach to specify the behavior properties related to shared resources for web service compositions and verify their consistency with the aid of a parametric stateful aspect extension to WS-BPEL. Parameters are introduced in pattern specification, which allows monitoring not only events but also their values bound to the parameters at runtime to keep track of data flow among concurrent process instances. An efficient implementation is also provided to reduce the runtime overhead of monitoring and event observation. Our experiments show that the proposed approach is promising.

Generating test cases to expose concurrency bugs in Android applications

Mobile systems usually support an event-based model of concurrent programming. This model, although advantageous to maintain responsive user interfaces, may lead to subtle concurrency errors due to unforeseen threads interleaving coupled with non-deterministic reordering of asynchronous events. These bugs are very difficult to reproduce even by the same user action sequences that trigger them, due to the undetermined schedules of underlying events and threads. In this paper, we proposed RacerDroid, a novel technique that aims to expose concurrency bugs in android applications by actively controlling event schedule and thread interleaving, given the test cases that have potential data races. By exploring the state model of the application constructed dynamically, our technique starts first to generate a test case that has potential data races based on the results obtained from existing static or dynamic race detection technique. Then it reschedules test cases execution by actively controlling event dispatching and thread interleaving to determine whether such potential races really lead to thrown exceptions or assertion violations. Our preliminary experiments show that RacerDroid is effective, and it confirms real data races, while at the same time eliminates false warnings for Android apps found in the wild.

Runtime Monitoring of Data-centric Temporal Properties for Web Services

Runtime monitoring of Web service compositions has been widely acknowledged as a significant approach to understand and guarantee the quality of services. However, existing runtime monitoring solutions consider only the constraints on the sequence of messages exchanged between partner services and ignore the actual data contents inside the messages. As a result, it is difficult to monitor some dynamic properties such as how message data of interest is processed between different participants. To address this issue, we propose an efficient, non-intrusive online monitoring approach to dynamically analyze data-centric properties for service-oriented applications involving multiple participants. By introducing Par-BCL - a Parametric Behavior Constraint Language for web services - to define monitoring parameters, various data-centric temporal behavior properties for Web services can be specified and monitored. This approach broadens the monitored patterns to include not only message exchange orders, but also the data contents bound to the parameters. To reduce runtime overhead, we statically analyze the monitored properties to generate parameter state machine from the event pattern automata to optimize monitoring. The experiments show that our solution is efficient and promising.

Towards self-healing web services composition

To achieve self-healing web services composition, much work has been studied in the area of web services composition recently. However, most work addresses the problem of runtime monitoring, diagnosis and recovery in isolation. What is missing, however, is a unified solution that can be used to tackle this challenge in a principled manner. This paper presents a fresh view on self-healing web services composition. In particular, rather than building baseline system model a priori, we advocate using statistical learning theory(SLT) technique to extract it by observing the behavior of web services composition and locate the potential anomaly.

Migrating Load Testing to the Cloud: A Case Study

Cloud computing has emerged as a new paradigm for the delivery of computing resources. It brings great opportunities to software testing, especially to load testing. In this paper, we focus on migrating conventional load testing tools to the cloud, for which the two significant issues are about multi-tenancy and load simulating resource management. We propose a four layer model for cloud-based load testing, along with the approach of test request admission control and scheduling to solve these issues. We carried out a concrete case study on our proposed approach and made the efficiency of cloud-based load testing shown successfully by two contrast experiments.

X-Check: A Novel Cross-Browser Testing Service Based on Record/Replay

With the advent of Web 2.0 application, and the increasing number of browsers and platforms on which the applications can be executed, cross-browser incompatibilities (XBIs) are becoming a serious problem for organizations to develop web-based software. Although some techniques and tools have been proposed to identify XBIs, they cannot assure the same execution when the application runs across different browsers as only explicit user activity is considered, and thus prone to generating both false positives and false negatives. To address this limitation, this paper describes X-Check, a platform that enables cross-browser testing as a service by leveraging record/replay technique. Comparing to existing techniques and tools, X-Check supports to detect cross-browser issues with high accuracy. It also provides useful support to developers for diagnosis and (eventually) elimination of XBIs. Our empirical evaluation shows that X-Check is effective, improves the state of the art.

MORE: A Model-Driven Operation Service for Cloud-Based IT Systems.

The operation of a cloud-based IT system (system for short) is time-consuming and error-prone due to the system scale, heterogeneity and configuration dependency. Although administrators can manage their systems with various configuration management tools, a plenty of knowledge spanning various domains is necessary. To alleviate this situation, we present a model-driven service MORE (Model-driven Operation seRvicE) to automate the initial deployment and the dynamic configuration of a system. Firstly, a model is proposed to specify the high-level view of a system in the form of a desired deployment topology. Then the topology model is transformed into executable code automatically, bridging the gap between high-level abstractions and low-level details. With those executable code as input, a runtime framework is designed based on a transaction-based self-configuration protocol to achieve automation and configuration consistency. Finally, we evaluate the service abilities (including modeling system topology, automating system provisioning, performing runtime reconfiguration) with a case study.