Service Integration

Context

A major issue one meets when designing a software system is its complexity. Complexity stems first from the size of the system, or from the different aspects that are to be taken into account when developing it. With recent outcomes both in industry (inter-enterprise applications) and for the end-users (social networks, electronic devices and increased connected mobility), software systems get more distributed, shared, and subject to on-demand construction and change than before. Accordingly software complexity increases since several software entities constituting the systems have to be taken into account. Further, these entities do not exist independently from one another. Their interactions are an important part of the problem as they can lead both to benefits (achieving some form of collaboration or cooperation) or to major drawbacks (deadlocks, starvation or incorrect multiple access to resources, etc.).

To solve out such complexity issues, approaches based on the decomposition of a system into sub-systems can be put into practice, whether is it for design, verification, or implementation. Behind the scene of such a decomposition, lies an important concept: structuring. It has been instantiated several times in the past years with approaches based on modules [Parnas, 1972], objects/classes [Dahl and Nygaard, 1966, Meyer, 1997], software components [Szyperski, 1998], services [Papazoglou and Georgakopoulos, 2003], aspects [Filman et al., 2005] or software product lines [Pohl et al., 2005].To solve out such complexity issues, approaches based on the decomposition of a system into sub-systems can be put into practice, whether is it for design, verification, or implementation. Behind the scene of such a decomposition, lies an important concept: structuring. It has been instantiated several times in the past years with approaches based on modules [Parnas, 1972], objects/classes [Dahl and Nygaard, 1966, Meyer, 1997], software components [Szyperski, 1998], services [Papazoglou and Georgakopoulos, 2003], aspects [Filman et al., 2005] or software product lines [Pohl et al., 2005].

All the above-mentioned approaches lead to new software design processes with two distinct tasks (The terms “designing in-the-large” and “designing in-the-small” are variations inspired from the terms “programming in-the-large” and “programming in-the-small” first introduced in [DeRemer and Kron, 1976]):

  • “designing in-the-small”, the design, verification, and implementation or reuse of sub-systems satisfying a subset of the system’s functionalities or corresponding to deployment units
  • “designing in-the-large”, the structuring of the system as a set of sub-systems linked by dependency or interaction relations, a kind of structural blueprint of the system. In an analogy to building construction where buildings are constructed using an assembly plan for sub-parts (ground, walls, roof), such a blueprint can be referred to as the architectural plan or software architecture of the system, and the person in charge for its definition can be called a software architect.

In our works we have been interested into the application of formal methods to support in-the-large development of composite systems, mainly through techniques for automatic composition, adaptation, and testing (the latter being discussed in another entry of the team works).

The composition (or coordination) of reusable software services enables, in theory, to gain time and money. In practice, if it is not automated, it is a complex and time-consuming activity: one must understand what a service does, how to reuse it and combine it with others, and check that the resulting assembly fulfills in practice the initial composition requirements. Automated service composition [Marconi and Pistore, 2009] tackles this issue with techniques for the discovery, selection, and assembly of services into composite services than can be deployed automatically. After being concerned about facilitating the enterprise software architects duties, automated service composition finds new applications with on-demand composition for the end-users and the “software as a service” cloud paradigm. The expressiveness and precision of the techniques is mainly related to the expressiveness and precision of the service descriptions, that is of their interfaces for which there are four different description levels: signature (operations), behavioral (usage protocol), non-functional (QoS, transactional properties), semantic (data annotations, capability).

Services being developed by different third-parties, may present mismatch at the different interface description levels that prevents them from being composed. Solving such mismatch out is the objective of software adaptation [Seguel et al., 2008], or adaptation for short. Adaptation consists in building automatically one (orchestration) or several (distributed orchestration) software pieces called adaptors restoring compatibility in a non intrusive way.

Results

Semi-Automatic Adaptation. 

Reusable software entities are subject to mismatch preventing their correct composition. We have studied solutions to this issue through semi-automatic and automatic software adaptation approaches. We have first addressed semi-automatic component adaptation [A5]. Based on adaptation contracts and component behavioral interfaces, a behavioral adaptor is constructed. The result of this work is a fully tool-supported centralized adaptation technique that combines the benefits of existing related work, being both restrictive and generative, and that apply system-wide, on any number of composed components. In order to enhance the efficiency of the adaptation process, incremental adaptation [IP18] and a new kind of behavioral reduction [IP19] have been studied too. Finally, application to a real component model (Windows Workflow Framework) has been done [IP22].

More recently, we have addressed semi-automatic orchestration adaptation [A6]. This is an end-to-end application of adaptation to services with transformations from/to BPEL. Other contributions in this work include the direct support for data being exchanged and efficiency of the adaptation process through an on-the-fly technique for behavioral restriction and adaptor model reduction.

Automatic Adaptation. 

The work presented above is based on signature and behavioral interface descriptions only. Thus, it requires the existence of adaptation contracts in order to support solving out signature mismatch. In order to remove this constraint, we have studied automatic distributed semantic adaptation [IP23]. Using semantic annotations in service signatures, adaptation is performed at the information (data) level rather than at the message level. The bottleneck of centralized adaptation is avoided reusing local controller and projection techniques, yielding sets of local distributed adaptors that can be implemented as a set of distributed orchestrators, i.e., as an adaptive choreography.

Composition. 

Adaptation and automatic composition are much related. Authors had shown that adaptation could go further than avoiding deadlocks and could be used to ensure system-wide properties. Still a remaining issue in composition is abstraction mismatch between composition requirements (activities or capabilities) and service description levels (operations). We therefore proposed techniques for automatic composition of semantic services [IP30]. With reference to existing work, the main contribution is to integrate adaptive features in the composition process, supporting conversations both for composition requirements and for service descriptions, and solving out both horizontal and vertical mismatch.

Repair. 

Service compositions get broken as a consequence of users mobility, requirement change, and unavailable sub-services. As an alternative to solutions based on replacement or complete recomposition, we have proposed techniques for service orchestration repair [IP29]. Experiments on big size benchmarks constructed with a service composition challenge generating tool have demonstrated that repair gives solutions to broken compositions of equivalent quality but in better computation time.

Selected Publications. 

A6 - Radu Mateescu, Pascal Poizat, and Gwen Salau ̈n. Adaptation of Service Protocols using Process Algebra and On-the-Fly Reduction Techniques. IEEE Transactions on Software Engineering, xx(x):xxx–xxx. IEEE Comp. Soc., 2011. (to appear, available in the journal online PrePrint section).

A5 - Carlos Canal, Pascal Poizat, and Gwen Salau ̈n. Model-Based Adaptation of Behavioural Mismatching Components. IEEE Transactions on Software Engineering, 34(4):546–563. IEEE Comp. Soc., 2008.

IP30 - Pascal Poizat and Yuhong Yan. Adaptive Composition of Conversational Services through Graph Planning Encoding. In Proceedings of the International Symposium On Leveraging Applications of Formal Methods, Verification and Validation (ISoLA 10), volume 6416 of Lecture Notes in Computer Science, pages 35–50. Springer, 2010.

IP29 - Yuhong Yan, Pascal Poizat, and Ludeng Zhao. Repairs vs. Recomposition for Broken Service Compositions. In Proceedings of the International Conference on Service Oriented Computing (ICSOC 10), volume 6470 of Lecture Notes in Computer Science, pages 152–166. Springer, 2010.

IP23 - Tarek Melliti, Pascal Poizat, and Sonia Ben Mokhtar. Distributed Behavioural Adaptation for the Automatic Composition of Semantic Services. In Proceedings of the International Conference on Fundamental Approaches to Software Engineering (FASE 08), volume 4961 of Lecture Notes in Computer Science, pages 146–162. Springer, 2008. 

IP22 - Javier Cubo, Gwen Salau ̈n, Carlos Canal, Ernesto Pimentel, and Pascal Poizat. A Model- Based Approach to the Verification and Adaptation of WF/.NET Components. In Proceedings of the International Workshop on Formal Aspects of Component Software (FACS’07), Electronic Notes in Theoretical Computer Science, volume 215, pages 39–55, 2008.

IP19 - Serge Haddad and Pascal Poizat. Transactional Reduction of Component Compositions. In Proceedings of the IFIP International Conference on Formal Methods for Networked and Distributed Systems (FORTE 07), volume 4574 of Lecture Notes in Computer Science, pages 341–357. Springer, 2007.

IP18 - Pascal Poizat and Gwen Salau ̈n. Adaptation of Open Component-based Systems. In Proceedings of the IFIP International Conference on Formal Methods for Open Object-Based Distributed Systems (FMOODS’07), volume 4468 of Lecture Notes in Computer Science, pages 141–156. Springer, 2007

Related Projects

You are here Application Domains Service Integration