A Pattern-Based Approach to Protocol Mediation for Web Services Composition

Xitong Li, Stuart Madnick, Quan Z. Sheng, Yushun FanSSRN 2008 · DOI

TL;DR

This paper tackles the challenge of integrating web services that don't speak the same "protocol" (message exchange sequence). They introduce a pattern-based approach to automatically generate "mediators" – intermediaries that translate between incompatible services. This work is crucial for enabling seamless integration in Service-Oriented Architectures (SOA).

What Problem Does This Paper Address?

In the world of Service-Oriented Architecture (SOA), web services are designed to be loosely coupled and interoperable. However, in practice, services developed independently often have incompatible message exchange sequences, making direct composition difficult. This "protocol mismatch" is a significant hurdle for seamless application integration. While signature mediation (handling different data types) has seen much progress, protocol mediation (handling the order and logic of message exchanges) remains a challenging open problem. Existing solutions often lack control logic, can't handle complex mismatches, and struggle to generate executable code.

Methods

The authors propose a pattern-based approach to protocol mediation. Here's a breakdown of their methodology:

  • Basic Mismatch Patterns: They identify six fundamental "mismatch patterns" (e.g., extra messages, missing messages, splitting/merging messages, extra/missing conditions) derived from workflow patterns. They argue these are comprehensive building blocks for all protocol mismatches.
  • Basic Mediator Patterns: For each basic mismatch pattern, they define a corresponding "mediator pattern" (e.g., Simple Storer, Simple Constructor, Splitter, Merger, Storing Controller, Constructing Controller). These are designed to be modular and composable.
  • Message Mapping for Identification: To semi-automatically identify mismatches and select appropriate mediator patterns, they introduce a technique based on message mapping. Developers define how message parts correspond between services. This mapping is then used with a heuristic rule to suggest suitable mediator patterns.
  • BPEL Templates for Code Generation: They develop BPEL (Business Process Execution Language) templates for their mediator patterns. These templates act as pseudo-code, allowing for the automatic generation of executable mediator code.
  • Service Mediation Toolkit (SMT): A prototype system, SMT, is built to support this approach. It includes a GUI workbench for developers to visualize services, identify mismatches, select and configure mediator patterns, and compose them into a composite mediator. SMT also incorporates a mediation verifier (using CPN models) and a CPN2BPEL transformer for code generation.

Datasets

Not discussed in the paper. The paper focuses on a motivating example (a search client and search engine) and a real-world case study (the Semantic Web Service Challenge scenario) to demonstrate their approach.

Key Insights and Ideas

  • Decomposition of Complexity: The core idea is to break down complex protocol mismatches into a set of basic, manageable patterns. This makes the problem more tractable.
  • Pattern Reusability: By defining basic mediator patterns, they enable a "building block" approach, allowing developers to compose more complex mediators from simpler ones. This promotes reusability and modularity.
  • Semi-Automation: While full automation is challenging, their message mapping approach provides a heuristic to guide developers, reducing manual effort in identifying mismatches and selecting patterns.
  • Formal Foundation: The use of Colored Petri Nets (CPN) provides a formal basis for modeling services and mediators, enabling verification of correctness and deadlock detection.
  • Bridging Conceptual and Executable: The BPEL templates serve as a crucial bridge, translating conceptual mediator designs into executable code.

Key Results

The paper demonstrates the feasibility and effectiveness of their approach through a motivating example and a case study. They show how their system can:

  • Identify protocol mismatches using message mapping.
  • Select appropriate basic mediator patterns.
  • Compose these patterns into complex mediators to resolve mismatches, including those involving iteration and conditional logic.
  • Generate BPEL code for these composite mediators.

The prototype system, SMT, provides a user-friendly interface to support these tasks, significantly assisting developers.

Limitations and Future Work

  • Developer Intervention: The authors acknowledge that developer intervention is still required, particularly for complex mismatches involving choice and iteration structures, and for specifying message mappings.
  • Semantic Descriptions: The lack of semantic descriptions in current Web services standards hinders full automation of message mapping and mediator selection.
  • Evidence for Message Construction: For certain mediator patterns (like Simple Constructor), sufficient "evidence" or information is needed to construct the required messages, which can be a challenge.

Future work will focus on:

  • Leveraging semantic web initiatives to automate message mapping and mediator selection.
  • Developing more advanced mediator patterns and improving the SMT system to handle more complex, real-world scenarios.

Summary updated

BibTeX
@misc{li2008pattern,
  author = {Xitong Li and Stuart Madnick and Quan Z. Sheng and Yushun Fan},
  title = {{A Pattern-Based Approach to Protocol Mediation for Web Services Composition}},
  year = {2008},
  doi = {10.2139/ssrn.1269038},
  howpublished = {SSRN},
}
Figure