Service Oriented Architecture (SOA) is an emerging software engineering paradigm for developing distributed applications in the Internet era. In this paradigm, web services from different organizations are composed to realize business goals. One important requirement for a service composition is to check whether a service composition ensures application consistency, because applications may violate transactional requirements, incur semantic conflicts or react to inaccurate underlying contexts. In this project, we investigate these issues and develop the solutions.
1) Atomicity is a highly desirable property for achieving application consistency in service compositions. To achieve atomicity, a service composition should satisfy the atomicity sphere, a structural criterion for the backend processes of involved services. Existing analysis techniques for the atomicity sphere generally assume complete knowledge of all involved backend processes. Such an assumption is invalid when some service providers do not release all details of their backend processes to service consumers outside the organizations. To address this problem, we propose a process algebraic framework to publish atomicity-equivalent public views from the backend processes. These public views extract relevant task properties and reveal only partial process details that service providers need to expose. Our framework enables the analysis of the atomicity sphere for service compositions using these public views instead of their backend processes. This allows service consumers to choose suitable services such that their composition satisfies the atomicity sphere without disclosing the details of their backend processes. Based on the theoretical result, we present algorithms to construct atomicity-equivalent public views and to analyze the atomicity sphere for a service composition. More details can be referred to our TSE'09, ICSE'06 papers.
2) Atomicity is a desirable property for business processes to conduct transactions in Business-to-Business (B2B) collaboration. Although it is possible to reason about atomicity of B2B collaboration using the public views, yet such reasoning requires the presence of a trustworthy party who has complete knowledge of these views. It is inapplicable when some parties may want to keep the confidentiality of their collaborative partners for privacy and other business reasons, or the trustworthy party is not available. To address this problem, we propose a novel approach that allows each party to jointly conduct local atomicity checking with its direct partners. It is based on iterative forwarding and regression of compensability properties between each pair of direct partners. This approach is applied to a case study based on a real-life insurance process in the motor damage claims domain. More details can be referred to our FSE'06 paper.
3) Atomicity is a desirable property that safeguards application consistency for service compositions. A service composition exhibiting this property could either complete or cancel itself without any side effects. It is possible to achieve this property for a service composition by selecting suitable web services to form an atomicity sphere. However, this property might still be breached at runtime due to the interference between various service compositions caused by implicit interactions. Existing approaches to addressing this problem by restricting concurrent execution of services to avoid all implicit interactions however compromise the performance of service compositions due to the long running nature of web services. In this work, we propose a novel static approach to analyzing the implicit interactions a web service may incur and their impacts on the atomicity property in each of its service compositions. By locating afflicted implicit interactions in a service composition, behavior constraints based on property propagation are formulated as local safety properties, which can then be enforced by the affected web services at runtime to suppress the impacts of the afflicted implicit interactions. We show that the satisfaction of these safety properties exempts the atomicity property of this service composition from being interfered by other services at runtime. More details can be referred to our FSE'07 paper.
4) Context-awareness allows services to adapt the behavior automatically when the surrounding environment changes. However, contexts are usually inaccurate, noisy and even inconsistent in practice (e.g., two RFID readers may report different amount for the same packages). Such problematic contexts may cause context-aware services behave abnormally or even crash. It is thus desirable to resolve context inconsistency for context-aware applications. Existing approaches address this issue merely by modifying the contexts (e.g., filtering or repairing problematic contexts). Approaches such as these however are inaccurate and incomplete due to the difficulty to identify the sources of context inconsistency. As a result, context-aware applications may still be affected by problematic contexts, or behave even worst due to incorrect resolution of inconsistent contexts. To address this issue, we propose a hybrid approach to locate problematic contexts and resolve the context inconsistency issue with the help of context-aware application semantics. By combining low-level context inconsistency resolution with high-level application error recovery, our approach can resolve the inconsistent contexts more effectively. Moreover, the error recovery cost for context-aware applications is also reduced to a large extent. The experimental results show that our approach outperforms existing work in terms of more accuracy of inconsistency resolution and less error recovery cost. More details can be referred to our PerCom'11 paper.
5) In SOA, independently developed web services can be dynamically composed. However, the composition is prone to producing semantically conflicting interactions among the services. For example, increasing production is inconsistent with a sales promotion given the business goal of clearing out the inventory. Resolving this issue is challenging especially when services are loosely coupled and their interactions are not carefully governed. To address this problem, we propose a novel distributed service choreography framework. Specifically, by modeling disallowable conflicting behavior as safety constraints, distributed choreography agents along with optimally placed coordinators on a federated publish/subscribe platform enforce reliable and efficient service interactions. Experimental results show negligible overhead in preventing the semantic conflicts, and significant performance advantage over a centralized approach in terms of runtime latency. More details can be referred to our WWW'11 paper.
This project is supported in part by an Ontario Early Researcher Award, MITACS NCE Canada, the National Natural Science Foundation of China under the Grant No. 60903052, and a grant from the Research Grants Council of Hong Kong (project No. HKUST6170/03E).
In service-oriented architecture, Web services are usually encapsulated and published as black-box components accessible to service consumers following the principles of component-based design. This however restricts the flexibility and adaptability of Web services to react to changing requirements, which are commonplace today, especially in the emerging smart Internet and smart interactions domain. In this project, we propose a grey-box approach to compose and evolve Web services to increase their flexibility and adaptability. By exposing the services’ internal state changes at runtime as events, our approach allows services involved in service compositions to share and consume events from partner services, and make use of these events to evolve and adapt their behavior. Please refer to the chapter (pp.197-215) in the book "The Smart Internet" for our preliminary results.
Whitening the testing of service-oriented applications can provide service consumers confidence on how well an application has been tested. However, to protect business interests of service providers and to prevent information leakage, the implementation details of services are usually invisible to service consumers. This makes it challenging to determine the test coverage of a service composition as a whole and design test cases effectively. To address this problem, we propose an approach to whiten the testing of service compositions based on events exposed by services. By deriving event interfaces to explore only necessary test coverage information from service implementations, our approach allows service consumers to determine test coverage based on selected events exposed by services at runtime without releasing the service implementation details. We also develop an approach to design test cases effectively based on event interfaces concerning both effectiveness and information leakage. The experimental results show that our approach outperforms existing testing approaches for service compositions with up to 49% more test coverage and an up to 24% higher fault-detection rate. Moreover, our solution can trade off effectiveness, efficiency and information leakage for test case generation. More details can be referred to our TSE'13 paper.
Middleware Support for Service Subscription
Web services have played a vital role in our daily life for some time now. A wide spectrum of online applications have been developed in diverse domains such as banking, shopping, gaming, and video streaming. However, the end-user does often not have the means to tune the applications to her personal needs and interests, especially not across services from different providers. Moreover, the end-user can not take full advantage of the myriad of useful resources and services available on the Web, as inter-operation among different services is often not given. Hence, the new Web application paradigm called Personal Web has emerged. The key idea behind the Personal Web is to have Web services exploit Web data that is collected and organized automatically according to the end-users’ context and preferences. This paper introduces a new concept that enables Personal Web applications, namely, service subscription and consumption. This new concept is driven by events exposed from Semantic Web resources and Web services through PADRES, a distributed content-based publish/subscribe messaging substrate, and POLARIS an approach for event exposure at service interfaces. We explain service subscription and consumption based on a comprehensive scenario and design a framework and architecture that realizes the approach. Please refer to the chapter (pp.49-64) in the book "The Personal Web" for more details.