Massimiliano Menarini

Rich Services: The Integration Piece of the SOA Puzzle

One of the key challenges to successful systems-of- systems integration using Web services technologies is how to address crosscutting architectural concerns such as policy management, governance, and authentication, while still maintaining the lightweight implementation and deployment flavor that distinguishes Web services from earlier attempts at providing interoperable enterprise systems. To address this challenge, this article introduces the notion of a Rich Service, an extension of the standard service notion, based on an architectural pattern that allows hierarchical decomposition of system architecture according to separate concerns. Rich Services enable the capture of different system aspects and their interactions. By leveraging emerging Enterprise Service Bus technologies, Rich Services also enable a direct transition from a logical to a deployed service-oriented architecture (SOA). This results in immediate benefits not only in SOA design, implementation, deployment, and quality assurance, but also in the traceability of architectural requirements to an SOA implementation.

Runtime verification of interactions: from MSCs to aspects

Runtime verification is one systematic strategy for analytical quality assurance of complex distributed systems. Model-based development approaches are promising in this context because they provide models of manageable size and complexity describing the systems under development, enabling systematic engineering processes for all development phases on various levels of detail. For runtime verification, executing implementations are monitored continuously for correctness against the specification. This requires the insertion of monitors into the software under test to gather information on system states and their evolution. In this paper we describe how we use aspect-oriented development techniques to enhance existing code with runtime monitors checking the interaction behavior of applications against their specifications. We use Message Sequence Charts (MSCs) to specify the interaction behavior of distributed systems and as basis for automatic runtime monitor generation. This uniquely ties interaction interface specifications with the monitoring infrastructure for their realization.We explain themonitor generation procedure and tool set using a case study from the embedded automotive systems domain, the Central Locking System (CLS).

A Verification Approach for GALS Integration of Synchronous Components

Starting with modules described in Signal synchronous programming language, we present an approach to verification of GALS systems. Since asynchronous parts of a GALS system can not be described in Signal, we use a mixture of synchronous descriptions in Signal and asynchronous descriptions in Promela. Promela is the input language to the SPIN asynchronous model checker. This allows us to achieve globally asynchronous composition (Promela) of locally synchronous components (Signal). Here we present three key results: first, we present a translation from Signal modules to Promela processes and prove their equivalence. Second, we present a technique to abstract a communication bus designed for GALS, the Loosely Time-Triggered Architecture (LTTA) bus, to a finite FIFO channel. The benefit of this abstraction is improved scalability for model checking larger specifications using SPIN. Third, we prove the trace equivalence of the model of the GALS system in Promela and a hardware implementation of it. This allows the verification of GALS systems based on the Promela model. We then use our technique to verify a central locking system for automobiles built on a GALS architecture using the LTTA.

Addressing the Integration Challenge for Avionics and Automotive Systems—From Components to Rich Services

Automotive and avionics systems are complex, distributed, software-intensive systems-of-systems (SoS). Consequently, system integration is a central challenge in both domains. Important cross-cutting requirements aspects, such as security, authorization, and failure management, are best understood as properties of the interplay among sub-systems. Yet, traditional development processes address the integration challenge only late, at the level of implementation and deployment. Consequently, potentials for reuse within and across product lines are left unrealized. Furthermore, late integration leads to high calibration, configuration and redesign costs. Service-Oriented Architectures (SOAs) have emerged as a solution to the integration challenge. However, inappropriate application of SOA-principles results in a high degree of fragmentation and scattering of functionality-this leads to additional difficulties in requirements traceability and quality assurance. In this article, we give a comprehensive overview of these SOA-challenges, and present Rich Services as a hierarchical SOA blueprint and development process enabling SoS integration in a dependable way. Rich Services introduce services as hierarchical, partial interaction patterns; these interactions are then augmented with infrastructure elements to inject behaviors that address cross-cutting requirements aspects. Rich Services also seamlessly address the mapping from logical to deployment architectures. Using end-to-end failure management as an example, we illustrate the utility of Rich Services.

Rapid Systems of Systems Integration - Combining an Architecture-Centric Approach with Enterprise Service Bus Infrastructure

Rapid, yet methodical, systems of systems integration is in high demand. Application areas such as homeland security and disaster response add to the challenge because of a unique set of integration requirements; three examples are: (1) a high demand for flexibility with respect to the configuration and support of business processes to anticipate and cater to changing threat and mitigation scenarios, (2) high agility demands during both development and production to address legacy and emergent capabilities, processes, applications and technologies, (3) wide variety of trust relationships among and across stakeholders and their organizations. In this paper we report on an approach for balancing challenging integration requirements while rapidly delivering a high-quality, value added, integrated system architecture and service-based implementation infrastructure. In particular, we show how the choice of an enterprise service bus as a deployment infrastructure helps discharge many of the obligations induced by the mentioned requirements - if it is combined with an agile, yet systematic approach for architecture discovery and design

Interaction-based Runtime Verification for Systems of Systems Integration

Complex distributed systems pose great challenges for quality assurance. Size, complexity and concurrency of these systems often render traditional verification techniques impractical. In particular, this is true for systems integration efforts, where additional challenges arise from the independent evolution of the composed systems. Runtime verification provides a systematic strategy for analytical quality assurance of such systems. Key elements of runtime verification are system models, ways to inject these models into the observed system and a framework for analysing and monitoring the runtime behaviour against the models. The approach we present in this article is based on interaction models. We specify expected system interactions using Message Sequence Charts (MSC), from which we generate distributed runtime monitors for each of the components. We use aspect-oriented programming (AOP) techniques to inject the monitors into the implementation of the components. Thereby, we verify the adherence of the distributed system interactions with the MSC model. The focus of this article is the runtime verification in the systems integration domain; here, Enterprise Service Buses (ESB) have emerged as a powerful infrastructure for integrating complex distributed systems. In the context of an ESB we leverage the Spring AOP framework to inject the runtime monitors. As a result we obtain a comprehensive, tool-supported approach for model-based runtime verification of interactions. We demonstrate our approach using the Central Locking System as running example of an integrated embedded system.

A Fault Tolerance Approach for Enterprise Applications

Service oriented architectures (SOAs) have emerged as a preferred solution to tackle the complexity of large-scale, complex, distributed, and heterogeneous systems. Key to successful operation of these systems is their reliability and availability. In this paper, we propose an approach to creating fault tolerant SOA implementations based on an architectural pattern called Rich Services. Our approach is model-driven, focuses on interaction specifications as the means for defining services and managing their failures, and is technology independent. We leverage an enterprise service bus (ESB) framework to implement a system based on the fault tolerant Rich Service pattern. We evaluate our approach by measuring availability and reliability of an experimental system in the e-business domain.

A Rich Services Approach to CoCoME

Systems-of-systems integration projects present exquisite challenges for software and systems engineering researchers and practitioners. Traditional integration approaches involve time-consuming rework bearing major financial and technical risk. Service-Oriented Architectures (SOAs) have emerged as a widely accepted solution to this challenge because they use standards-based infrastructure to forge large-scale systems out of loosely-coupled, interoperable services. SOAs can create systems-of-systems by mapping existing systems into services, then orchestrating communication between the services. New functionality can be created by either adding new services or modifying communication among existing services. Because of these features, SOA projects are particularly amenable to agile development processes. Consequently, well executed SOAs can drive down financial and technical risk by improving flexibility and reducing time to market.

Aspect-oriented modeling approach to define routing in enterprise service bus architectures

System-of-systems integration is a fundamental challenge to Software Engineering. Enterprise Service Bus (ESB) technologies help overcoming this challenge by addressing loose coupling of services while provisioning for crosscutting concerns. ESBs use aspect-oriented techniques and flexible message routing and filtering to support decoupling of the business logic from crosscutting concerns such as encryption and failure management. These characteristics have led to an increasing adoption of ESBs in the enterprise business domain. However, currently there is no systematic development approach for Service-Oriented Architectures (SOAs) ranging from requirements analysis to architecture design to ESB deployment. A core challenge is the precise specification of the routing capabilities of the ESB. A viable solution should maintain the decoupling of crosscutting concerns from the business logic while being able to reason about the integrated interaction pattern. In this paper we leverage the Rich Service architectural blueprint in combination with Aspect-Oriented Modeling techniques to address this problem.

A Service-Oriented Blueprint for COTS Integration: the Hidden Part of the Iceberg

The use of commercial off-the-shelf (COTS) software can greatly reduce the development cost and effort for complex software systems. Reusing software can also improve the general quality of a system by leveraging already proven implementations. One of the limiting factors in the adoption of COTS software is the complexity of integrating it with the rest of the system under development. Often, requirements do not entirely match the functionalities available in COTS components, increasing the complexity of the glue software that needs to be written. In this paper, we present the blueprint of a service-oriented architecture that can guide the engineer both in specifying the functionalities of a complex software system and as a deployment architecture to seamlessly integrate COTS components implementing such functionalities. The COTS integration concern, typically a deployment issue, is addressed in the service architecture, and is treated as first-class citizen of the development process.