On Behavioural Interfaces and Contracts for Software Adaptation (original) (raw)

On the specification of software adaptation

Electronic Notes in Theoretical Computer …, 2004

The problem of adapting heterogeneous software components that present mismatching interaction behaviours is one of the crucial problems in Component-Based Software Engineering. The aim of this paper is to contribute to setting a theoretical foundation for software adaptation. A formal analysis of adaptor specifications is presented, and their usage to feature different forms of flexible adaptations is illustrated.

On the semantics of software adaptation

Science of Computer Programming, 2006

The problem of adapting heterogeneous software components that present mismatching interaction behaviour is one of the crucial problems in Component-Based Software Engineering. A promising approach to solve this problem is based on an adaptation methodology relying on extending component interfaces with protocol information which describes their interaction behaviour, and using a high-level notation to express the intended connection between component interfaces. The adaptor specification defines a component-in-the-middle capable of making two components interact successfully, according to certain constraints. The aim of this paper is to contribute to setting a theoretical foundation for software adaptation following this approach. A formal analysis of adaptor specifications is presented, and their usage to feature different forms of flexible adaptations is illustrated.

Semi-Automatic Specification of Behavioural Service Adaptation Contracts

An adaptation contract describes composition constraints and adaptation requirements among several services which were not initially built to interoperate with each other. The manual writing of this specification by a designer is a difficult and error prone task, especially when services are reused taking their behavioural descriptions into account. In this paper, we present a semi-automatic approach to build adaptation contracts. To this purpose, we propose an adaptation contract design process supported by an interactive environment based on a graphical notation, and an engine capable of automatically generating contracts without any human intervention. We also present an experimental study that we carried out using the tool support that we implemented in order to evaluate our approach.

Context-Based Adaptation of Component Behavioural Interfaces

Coordination Models and …, 2007

In the development of component-based systems, components need to be adapted in most of the occasions to work under certain conditions which were not initially predicted by their developers. These conditions are likely to change at runtime, therefore it is very important to provide systems with the ability to alter their behaviour while they are running, depending on the changing conditions of the environment. This paper presents an expressive and graphically-based notation to specify flexible adaptation policies (or mappings) between the interfaces of two or more components to be integrated. In a second step, we propose an algorithm which automatically derives the resulting adaptor from a mapping, and a description of component interfaces. We illustrate our proposal using an E-book system.

Interactive Specification and Verification of Behavioural Adaptation Contracts

2009

Abstract Adaptation is a crucial issue when building new applications by reusing existing software services which were not initially designed to interoperate with each other. Adaptation contracts describe composition constraints and adaptation requirements among these services. The writing of this specification by a designer is a difficult and error-prone task, especially when service protocol needs to be considered and service functionality accessed through behavioural interfaces.

Towards unanticipated dynamic service adaptation

Steffen Becker, 2006

Coordination and Adaptation are two key issues when developing complex distributed systems, constituted by a collection of interacting entities -either considered as subsystems, modules, objects, components, or web services-that collaborate to provide some functionality. Coordination focuses on the interaction among computational entities. Adaptation focuses on the problems raised when the interacting entities do not match properly.

Automatic Generation of Adaptation Contracts

Software development based on the composition of black-box software like Web Services and Software Components is impeded by incompatibilities in their interfaces. Software adaptation has emerged as a solution to these incompatibilities by using processes in-the-middle (called adapters) that allow the correct interaction between the services. There are several approaches that focused on the automated generation of adapters guided by adaptation contracts which specify how the incompatibilities can be resolved. However, the generation of these contracts is not automated and most existing approaches require these contracts to be specified by hand, which obliges the designer to know all the service details. In this paper, we propose an approach to automatically generate adaptation contracts from the behavioral description of the services. These contracts overcome incompatibilities at signature and behavioral levels. Finally we present our prototype tool that accepts as input the service behaviors written in abstract BPEL and generates adaptation contracts using a combination of an A* algorithm and an expert system.

Component adaptation through flexible subservicing

Science of Computer Programming, 2006

Component adaptation is widely recognised to be one of the crucial problems in Component-Based Software Engineering (CBSE). We present here a formal methodology for the soft adaptation of components presenting mismatching interaction behaviour. The notions of access rights (associating components with the services they are allowed to use) and subservicing (providing alternative services in place of those requested by components lacking the required access rights) are exploited to feature a secure and flexible adaptation of third-party components. e e J J J J J o o

Adaptation for Hierarchical Components and Services

Electronic Notes in Theoretical Computer Science, 2007

Software coordination and adaptation are tightly related to modular software entities and access points. These entities (components or services) may be complex, dissimilar (various models) and designed at different granularity levels. In order to allow interoperability we need rich interface descriptions including service hierarchisation, flexible declarations and precise specifications. In this article we present a Hierarchical Behavioural interface description language that enables the structuring of services, their encapsulation and it also facilitates the use of component interfaces. We also investigate in this work the adaptation and coordination for Hierarchical Behavioural IDL. We recall various adaptation problems and we introduce modelling techniques and some solutions within hierarchical context considering precision of the interfaces, their layering and flexibility.

An approach to adapt service requests to actual service interfaces

2008

Research about service oriented architectures produced, in the last years, some frameworks that enable the development of self-adaptive service compositions supporting dynamic binding. A developer can specify, at design time, an abstract service. At run time a concrete implementation of the abstract service is dynamically selected. In this scenario service selection is usually performed assuming that all the implementations of an abstract service have the same interface or protocol. This assumption is not necessarily true in an open world setting, where services built by different organizations are made available. In this paper we address the problem of invoking services having an interface or protocol different from those originally expected by the service requester. We have identified a number of possible mismatches between services and some basic mapping functions that can be used to solve simple mismatches. Such mapping functions can be combined in a script to solve complex mismatches. Scripts can be executed by a mediator that receives an operation request, parses it, and eventually performs the needed adaptations. The definition of the scripts can be partially automated.