|
Two particular aspects of deployment mechanisms were investigated, namely (a) runtime self-management, and (b) service interactions. Runtime self-management involves dynamically adapting a service-oriented computing system according to changes in its execution environment, or to recover from anomalous behaviour or situations. Service interactions, on the other hand, pose certain unique challenges for service-oriented computing systems because of issues like heterogeneity, dynamicity, security etc. associated with these systems. Service-oriented applications are often deployed in dynamic computing environments. Accordingly, these applications require appropriate deployment support for handling runtime changes in their execution environments. In this report, the work on developing deployment mechanisms for supporting: (a) self-management of ervices, and (b) dynamic and adaptive composition of services is described.
For self-management of services, the work on modes is continued. In this report, the architecture, behaviour, and runtime policy forself-manangement of services using modes is described. For dynamic and adaptive composition of services, a new project called Dino is started. This report gives an overview of the Dino approach, and describes the design of the runtime infrastructure provided by Dino for enabling service composition in dynamic environments.
In this deliverable, we describe our approach to provide deployment and runtime support for dynamic and adaptive composition of services. Service-oriented applications deployed in open and dynamic environments often require services to discover and interact with each other at runtime, and thereby form a dynamic service composition. Moreover, such environments are frequently faced with the runtime changes in execution environment conditions, requiring the corresponding service composition to adapt to these changes. The work presented in this deliverable builds on the work reported in the deliverable D6.1.b. In D6.1.b, we outlined our approach to self-management of service-oriented architectures using the notion of architectural Modes, and our approach to dynamic and adaptive composition of services using the Dino runtime infrastructure. In this deliverable, we provide an integrated approach for specifying service-oriented architectures using a Modes profile, and automatically generating the deployment artifacts from the Modes-based architecture descriptions, as required by the Dino brokers for dynamic and adaptive service brokering. We describe our approach using example scenarios from the SENSORIA automotive case study. In this deliverable, we describe an enhanced approach to provide deployment and runtime support for dynamic and adaptive composition of services. Service-oriented applications deployed in open and dynamic environments often require services to discover and interact with each other at runtime, and thereby form a dynamic service composition. Moreover, such environments are frequently faced with the runtime changes in execution environment conditions, requiring the corresponding service composition to adapt to these changes. The work presented in this deliverable builds on the work reported in the deliverable D6.1.c and D6.3.c. In D6.1.c, we detailed how specifications of Service Modes are constructed (using modelling profiles) and how these specifications are transformed to deployment artifacts for the Dino runtime infrastructure. In this deliverable, we describe enhanced modes specification, architecture and behaviour analysis, and report on enhanced tooling support (new and extended tools based upon those reported in deliverable D6.3.c) for the service modes approach. This work is guided by the in-vehicle services scenarios case study and we demonstrate in an end-to-end example how our mode models, analysis, artifact generation and deployment mechanisms can assist service engineers in building such systems.
This document reports on the impact of service-oriented computing on existing software applications and on the challenges and issues that reengineering methods and techniques have to address in order to support the adaptation and evolution of such applications to a service-oriented paradigm. In particular, it identifies the major issues in what concerns the impact of SOA legacy systems, outlines the associated problems that have to be addressed by reengineering methods, techniques and tools, and proposes extensions to existing solutions for addressing such problems and issues. In previous deliverables for tasks T6.2 and T6.6 we have described a methodology and developed a prototype for migrating legacy applications, with a particular focus on supporting Service Oriented Architectures as target. The developed approach is based on a combination of techniques such as source code analysis, graph transformation, and code transformation and its main goal is to provide a systematic way of addressing, such reengineering projects with a high degree of automation while being largely independent of the programming language. The goal of this document is to further detail the prototype and report on the experiences and results obtained so far.
Services participating in a service-oriented computing system are likely to be autonomous. Autonomy of services implies that these services might be using heterogeneous technologies and standards. One of the primary objectives of service-oriented computing is to hide the heterogeneity, and allow composition of heterogeneous services. With an aim to fulfil this objective, we propose the use of a Service Bridge for enabling interactions between heterogeneous services.
Self-management properties are commonly divided into four categories: self-configuration, self-healing, self-optimization and self-protection. This report describes the support that Service Bridge provides for each of these four aspects of self-management. In addition, it presents self-management requirements for next-generation telecommunications platforms, as identified by TI Lab. These requirements will serve as a guide in developing the next version of self-management runtime for service-oriented applications. In this deliverable, we present design and implementation details of the prototype enhanced service-oriented deployment platform. This prototype platform implements the deployment and runtime approaches for service-oriented software systems, as presented in the deliverable D6.1.b and further expanded in the deliverable D6.1.c. This deliverable describes details of the Modes Tool Suite for specifying software architecture models using the Modes profile for UML, and generating and browsing deployment artifacts from these models. These deployment artifacts are used for runtime service brokering using the Dino brokers, details of which are also described in this deliverable.
This deliverable introduces the model-driven deployment approach and the transformations developed to support the generation of low-level configuration descriptors from high level engineering models. The presented methodology takes SENSORIA UML models as input and produces standards-compliant service descriptors (WSDL files) and configuration descriptors to reliable service middleware (RAMP). During the implementation, Viatra model transformation framework was used. Transformations were built in a modular way so the approach is easily extendable to integrate further aspects of service design. This deliverable introduces the model driven deployment approach and the transformations developed to support the generation of low-level configuration descriptors from high level engineering models. The presented methodology takes SENSORIA UML models as input and produces standards-compliant service descriptors (WSDL files) and configuration descriptors to reliable and secure service middleware of the Apache platform.
During the implementation, Viatra model transformation framework was used. Transformations were built in a modular way so the approach is easily extendable to integrate further aspects of service design. This work was carried out in Task 6.4: Model-driven deployment. This deliverable introduces the model driven deployment approach and the transformations developed to support the generation of low-level configuration descriptors from high level engineering models. The presented approach takes SENSORIA UML models as input and produces standards-compliant service descriptors (WSDL files) and configuration descriptors for reliable and secure service middleware of the Apache platform. During the implementation, the VIATRA2 model transformation framework was used. Transformations were built in a modular way so the approach is easily extendable to integrate further aspects of service design. This work was carried out in Task 6.4:Model-driven deployment.
Runtime support for service-oriented systems. Is addressed at two distinct levels of abstraction. The writing of service-oriented systems, and its deployment on a distributed system can be greatly simplified by the existence of the appropriate middleware. On a higher level of abstraction, this document reports on IMC, a middleware, and its application to the implementation of Dpi, a language featuring explicit distribution and code migration. The inherent interactive behaviour of service-oriented systems requires languages able to express concurrent activities. On a lower level of abstraction we focus on an intermediate language (more precisely on an assembly language) to program multi-core processors, thus addressing the challenges of writing multi-threaded code at the processor level. This deliverable reports on the development of middleware supporting the fast prototyping of service-centered applications. The distinctive nature of these efforts lies in the formal background the middleware rests upon, in the form of process calculi. Specifically, the report presents two middlewares: IMC, Implementing Process Calculi, and JSCL, Java Signal Core Layer. IMC directly supports all the primitives in the Sensoria core calculi, thus providing for the expedite implementation of programming languages built on top of these calculi. An exercise on implementing the Calculus of Services with Pipelines and Sessions, CaSPiS, is presented. JSCL supports event notification suitable for the orchestration and choreography of services, being specialized for long-running transactions. The report includes a description of the implementation of the Signal Calculus and that of long running transactions and the inherent compensation mechanism. A number of formalisms have been defined to support the specification and analysis of service-oriented applications. These formalisms have been equipped with tools (types or logics) to guarantee the correct behavior of the specified services. One critical point is then guaranteeing that the proved properties are preserved when running the specified systems over available implementation, because of the semantic gap between the formalism and the programming languages of service oriented overlay computers. With this aim in mind, we have defined a service oriented abstract machine, equipped with a formal structural semantics, that can be used to implement the service specification formalisms. We use our abstract machine to implement CaSPiS [3], one of the service oriented formalisms that have been recently proposed.
In this document, a model transformation techniques used in a methodology for the evolution of software towards new architectural styles is presented. This methodology is being implemented to support the migration to Service-Oriented Architectures (SOA) but is not restricted to that purpose. In our approach, we represent source code as graphs. These are compliant to a metamodel based on the source and target architectural styles. Prior to its representation, the source code is subject to a preparatory step of semi-automatic code annotation according to the contribution of each of its parts in the target architectural style. This enables the use of graph transformation rules on metamodel instances to describe the transformation. Using this technique, it is possible to automate the execution of the transformation at model level. |
