Adaptation and Abstract Runtime Models

05/17/2018 ∙ by Thomas Vogel, et al. ∙ 0

Runtime adaptability is often a crucial requirement for today's complex software systems. Several approaches use an architectural model as a runtime representation of a managed system for monitoring, reasoning and performing adaptation. To ease the causal connection between a system and a model, these models are often closely related to the implementation and at a rather low level of abstraction. This makes them as complex as the implementation and it impedes reusability and extensibility of autonomic managers. Moreover, the models often do not cover different concerns, like security or performance, and therefore they do not support several self-management capabilities at once. In this paper we propose a model-driven approach that provides multiple architectural runtime models at different levels of abstraction as a basis for adaptation. Each runtime model abstracts from the underlying system and platform leveraging reusability and extensibility of managers that work on these models. Moreover, each model focuses on a specific concern which simplifies the work of autonomic managers. The different models are maintained automatically at runtime using model-driven engineering techniques that also reduce development efforts. Our approach has been implemented for the broadly adopted Enterprise Java Beans component standard and its application is presented in a self-healing scenario requiring structural adaptation.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Runtime adaptability or even self-manageability is often an important requirement for today’s complex software systems (cf. [1, 10, 16, 17, 22]). To accomplish self-management, a managed system is monitored and analyzed, and if changes are required, adaptations are planned and executed. These activities are performed by autonomic managers that are located externally to a managed system, which supports reusability and extensibility of managers. However, it requires appropriate representations of a running managed system for managers [1, 10, 15].

For such a representation, several approaches use an architectural model that is closely related to the specific implementation of a system and that covers different, but mostly one addressed concern for self-management, like performance for self-optimization or failures for self-healing. For example, to ease the connection between a model and a system, the model of Oreizy et al. [22] is a one-to-one mapping between implementation classes and model elements, and therefore rather at a low level of abstraction. Using the approach of Garlan et al. [10], one user-defined model is employed to cover all concerns of interest and their case studies primarily target at optimizing the performance and cost of a system.

We argue that it is beneficial to simultaneously have more than one kind of architectural model at runtime, especially for two reasons: First, a model reflecting a platform-specific or a one-to-one view on a system is rather related to the specific implementation and it does not always provide an appropriate abstraction of the system for autonomic managers. In contrast, additional models abstracting from the underlying platform or to different extents from implementation details are beneficial as they support the reusability of autonomic managers using these models across different managed systems. Moreover, models at higher levels of abstraction can be less complex than lower level ones, which can simplify the work of managers. Second, each model can focus on a specific concern and therefore on a specific self-management capability. If only one model is employed, it has to cover all required concerns, which increases the model’s complexity. For example, supporting self-optimization, self-healing and self-protection requires considering performance, failure and security concerns. In contrast, having a model for each addressed concern, the complexity of the specific models can be reduced. Likewise to appropriate abstraction levels, this can simplify the usage of these models by autonomic managers.

Similar to these ideas, but in contrast to their realized approach [22], Oreizy et al. consider different kinds of runtime models, but the considerations remain theoretical [23]. It is unclear whether different kinds of runtime models might be simultaneously employed with the framework of Garlan et al. that however provides many customization options [10].

In this paper we propose a model-driven approach that provides multiple architectural runtime models at different levels of abstraction as a basis for monitoring and adapting a running software system. Higher level models abstract from the underlying system and platform leveraging reusability and extensibility of autonomic managers. Moreover, each of them focuses on a specific concern, and together with appropriate abstractions, this simplifies the work of managers.

The different models are maintained automatically at runtime by model-driven engineering techniques, especially the incremental synchronization between models that are based on different metamodels. These techniques considerably ease the development by reducing the development efforts for representing and maintaining runtime models.

To support monitoring and adaptation, the models are causally connected to the running system, i.e., changes in a model are reflected in the system and vice versa. Thus, our notion of runtime models corresponds to the one of Blair et al. [2], who consider the causal connection and the representation of a system together with its concerns from problem space perspectives as key properties of runtime models.

The basic idea of using model synchronization techniques for monitoring and adaptation has been presented in a poster session [27]. Details about the monitoring part of our approach that covers the monitoring of architectural constraints, performance and failure states through distinct runtime models has been published in [28]. This paper presents our solution for the adaptation part and discusses the inherent challenges we had to resolve related to the abstraction involved. This solution facilitates parameter and structural adaptation using model synchronization techniques, and therefore our approach now leverages the whole feedback loop. Both parts have been implemented for the broadly adopted Enterprise Java Beans (EJB) component standard [6] and we will illustrate our approach with a self-healing scenario requiring structural adaptation.

The rest of the paper is structured as follows: Section 2 describes our basic approach, the applied model-driven engineering techniques and the monitoring part. The adaptation part together with our solutions to the adaptation challenges are discussed in-depth in Section 3. An application example is presented in Section 4 and the implementation of our approach in Section 5. After discussing related work in Section 6, we conclude with Section 7.

2 Basic Approach

A conceptual view on our basic approach is given by the generic architecture depicted in Figure 1, which extends the control loop concept proposed by Kephart and Chess [15].

Figure 1: Generic Architecture

A Managed System provides Sensors and Effectors that are used to observe and adapt the system, respectively. A runtime representation of the system in the form of a Source Model is provided by the sensors and effectors. This model is causally connected to the system. Therefore, adaptation can be conducted by directly using this model.

However, a source model represents all functionalities and concerns of the sensors and effectors. Therefore, it is usually quite complex and related to the solution space and platform of a managed system. Thus, a source model rather provides a view on a system at a low level of abstraction, which could make it laborious to use it as a basis for monitoring and adaptation activities by Autonomic Managers.

Therefore, several Target Models are derived from a source model at runtime. Each target model abstracts from the source model and it provides a specific view on a managed system required for a certain self-management capability. As an example, a target model might represent the performance state or failures of a system to address self-optimization or self-healing, respectively. A manager being concerned with self-optimization will use only the target models being relevant for optimizing a system, but does not have to consider target models addressing other capabilities like self-healing. This and appropriate abstractions of models reduce the complexity for specific managers in coping with runtime models and performing their activities.

Thus, target models tend to provide views related to problem spaces of different self-management capabilities and to abstract from the underlying system platform. This supports the reusability of managers that focus on problem spaces shared by different managed systems. Furthermore, as target models can be platform-independent, the kinds of target models used in our approach are rather defined by autonomic managers than by the underlying infrastructure.

Therefore, autonomic managers preferably use target models than a complex source model to monitor or adapt a system. This requires that a target model is causally connected to the source model. Thus, changes in the source model are reflected in target models for monitoring, and vise versa for adaptation. To maintain different target models at runtime and to realize causal connections between the models, we apply model-driven engineering techniques, especially our Model Transformation Engine that incrementally synchronizes models with each other [11, 12]. Details about these techniques, Metamodels and Triple Graph Grammar (TGG) Rules are provided in the following section.

As target models abstract from the source model, synchronizing source model changes to a target model for monitoring is not critical. However for adaptation, the opposite direction of propagating target model changes to the source model is critical, as these changes have to be refined in order to be reflected properly in the source model. Our solution to this refinement problem and to other challenges regarding restrictions and appropriate orders of adaptations is the contribution of this paper and discussed in Section 3.

2.1 Role of Model-Driven Engineering

Model-Driven Engineering (MDE) provides techniques to software system development using models. Each model is defined by a metamodel that defines the abstract syntax of a modeling language. As an example, Figure 2 shows the simplified111The metamodel depicted in Figure 2 is simplified as it does not show any attributes, operations and enumerations, and it hides some associations. Moreover, elements for concerns like security, transaction, timers or quiescence are hidden. metamodel for modeling software systems that are based on Enterprise Java Beans 3.0 (EJB) [6] technology. EJB is a specification for realizing component-based systems on top of the Java programming language. Components are based on Enterprise Beans that are either Message Driven Beans or Session Beans. The former one is accessed through asynchronous message passing, and the latter one provides interfaces to access its encapsulated functionality. Required functionality can be declared for beans through references that can be connected to interfaces provided by session beans. Beans can be customized through Simple Environment Entries that are kind of configuration properties. As unit of deployment, the EJB standard defines the EJB module that must contain at least one bean. The runtime environment for EJB components is called a container.

Figure 2: Simplified Metamodel for EJB-based Software Systems

Based on the simplified metamodel depicted in Figure 2, EJB-based systems can be described at three different layers. The top layer considers components types that correspond to artifacts from the development phase. These types define the configuration space for a system. Concrete configurations of a system are instances of these types that can be deployed in a container and are covered by the middle layer. Finally, the lower layer addresses bean instances and interactions by means of calls among them.

As metamodels are themselves models, a meta-metamodel is employed to define them. The Object Management Group (OMG) defines the Meta Object Facility (MOF) [21] as the standard meta-metamodel for MDE. The Eclipse Modeling Framework (EMF)222www.eclipse.org/emf/ (Jan 07, 2010) provides a partial implementation of the MOF meta-metamodel that is the basis for generating code from metamodels or for model transformation techniques.

Figure 3: Generic Model Transformation System

A generic Model Transformation System as depicted in Figure 3 completely transforms a Source Model to a Target Model or it synchronizes changes of a Source Model to a Target Model. If a system has bidirectional transformation capabilities, it also supports the transformation or even the synchronization in the opposite direction, i.e. from a target to a source model. The transformation and synchronization require that both models are instances of potentially different metamodels (Source Metamodel and Target Metamodel) that share the same Meta-Metamodel. Thus, metamodels are user-defined, while the meta-metamodel is usually the MOF. How two models are transformed and synchronized with each other is specified by Transformation Rules at the level of metamodels using a textual or graphical language. These rules are used by a Model Transformation Engine to perform the transformation or synchronization.

The transformation system used in our approach is based on Triple Graph Grammars (TGGs) [11, 12] and on EMF. It has bidirectional synchronization capabilities that work incrementally. Thus, only the parts of the models are processed by the engine that have been changed and need to be synchronized. To efficiently detect and locate changes in a model, our engine relies on the notification mechanism provided by EMF that reports when a model element has been modified. Consequently, the models have not to be completely scanned if changes have occurred locally. The engine is able to queue notifications and the synchronization can be triggered externally. This enables the synchronization of two models that differ in more than one change.

Before TGGs are presented, we introduce a metamodel for generic component-based software systems, which is depicted in a simplified version333The depicted metamodel is simplified as several attributes and three associations to navigate from a Component, Interface, or Property to their corresponding types are hidden. in Figure 4. A ComponentPlatform is a runtime environment for components. The configuration space for a system is defined by the ComponentTypes, their required and provided InterfaceTypes, and by PropertyTypes that specify options to parameterize components. Components conforming to ComponentTypes constitute concrete configurations of a system. A component provides at least one Interface and it can require Interfaces by means of functionality from other components. Connectors wire required and provided interfaces, and components are parameterized by setting the value attribute of Properties. The life cycle of a component can be controlled through its attribute state. Finally, the metamodel covers Failures that have occurred when using a provided interface.

Figure 4: Simplified Metamodel for Component-based Software Systems

Using this generic metamodel, EJB-based systems can be described in a platform-independent manner. Therefore, it serves as the target metamodel and the EJB metamodel depicted in Figure 2 as the source metamodel. Hence, instances of these metamodels describing the same system should be synchronized with each other as specified by TGG rules. This requires that for each concept that is represented in both models a TGG rule has to be created. A TGG rule specifies declaratively how a concept in one model is reflected in the other model and vice versa.

Therefore, a TGG combines three conventional graph grammars: one grammar describes a source model, a second one a target model, and a third one a correspondence model. A correspondence model explicitly stores the relationships between corresponding source and target model elements. The engine uses the correspondence model to efficiently navigate between the source and target models when it checks and reestablishes consistency during the synchronization. The bidirectional transformation or synchronization is actually performed by operational rules that are generated automatically from declarative TGG rules. There is no need to write any imperative code in addition to the rules, which eases the development of enabling the maintenance of models.

Figure 5: Example TGG Rule

Figure 5 shows a TGG rule that transforms and synchronizes an EjbInterface element to an Interface element, or vice versa. Model elements on the left refer to the source model, elements in the middle to the correspondence model, and elements on the right to the target model. The elements having no stereotype form the application context of the rule, i.e., they must already exist in the models before the rule can be applied. The elements being stereotyped with create are created by the rule. Thus, for each EjbInterface provided by a SessionBean that is part of an EjbModule in the source model an Interface is created in the target model and associated as a provided interface to the Component that corresponds to the EjbModule. Moreover, a CorrEjbInterface element as part of the correspondence model is created that stores the mapping between the EjbInterface and the Interface. Finally, the Interface is associated to the InterfaceType that corresponds to the EjbInterfaceType to which the EjbInterface is linked to. Likewise, if an Interface is created in the target model, it is transformed or synchronized to an EjbInterface in the source model. This rule also shows how attribute values are synchronized. The uid of an Interface is directly derived from the uid of the EjbInterface, and vice versa. Moreover, helper methods or Object Constraint Language expressions operating on the source or target models can be used to synchronize attribute values.

This rule exemplifies that not all concepts in one model need to be represented in the other model. A SessionBean in a source model is not reflected in the target model and therefore no correspondence model element exists that is connected to a SessionBean. Thus, target models can abstract from a source model.

Overall, eleven TGG rules were required to specify the transformation and synchronization between instances of the specific source and target metamodels. As these rules are similar to the rule depicted in Figure 5, they are not shown as figures, but the basic bidirectional mapping is as follows.

An EjbContainer corresponds to a ComponentPlatform, and an EjbModuleType to a ComponentType. EnterpriseBeanTypes and therefore SessionBeanTypes and MessageDrivenBeanTypes are not reflected in target models. Thus, the characteristics of a bean type, namely SimpleEnvironmentEntryTypes, EjbReferenceTypes and EjbInterfaceTypes are mapped to PropertyTypes, required and provided InterfaceTypes respectively, that are associated to the ComponentType representing the EjbModuleType the bean type is part of. Likewise, an EjbModule is mapped to a Component, while the EnterpriseBeans being part of an EjbModule are not represented in target models. However, the SimpleEnvironmentEntries, EjbReferences or EjbInterfaces of a bean are reflected by Properties, required or provided Interfaces that are associated to the Component representing the EjbModule the bean is part of. Connections among required and provided interfaces are reflected in source models as EjbConnectors and in target models as Connectors.

All source metamodel concepts of bean instances and calls are not considered in the target metamodel, except of ThrownExceptions. They are aggregated over all calls invoked on bean instances through a specific interface, and they are attached to the corresponding Interface in the target model.

Thus, a target model describes EJB-based systems in a platform-independent manner and at a higher level of abstraction with respect to the source model. A target model provides a black box view on EJB modules and their types, since modules and not single beans are the unit of deployment. Moreover, it maps failures to the architecture in a more amenable manner than the source model. Therefore, instead of the complex and low level source model, such a target model at a higher level of abstraction is used by autonomic managers for monitoring and adapting a system.

2.2 Monitoring

Using our approach for monitoring requires that changes in a source model, due to changes in a managed system, are reflected in target models. Synchronizing changes in this direction is not critical as target models are at a higher level of abstraction than source models. During synchronization, concepts that are represented in a source model but not in a target model are simply discarded, which causes the intended abstraction. Therefore, changes can be propagated from source to target models without any difficulty.

For example, when synchronizing a source to a target model, both conforming to the corresponding metamodels presented in Section 2.1, information about the internal structure of EjbModules, i.e. the beans inside a module, are discarded as the Components in the target model provide a black box view on modules. This is illustrated by the TGG rule depicted in Figure 5 where a SessionBean in the source model has no corresponding element in the target model.

We presented the monitoring of architectural constraints, performance and failures of a system by using different target metamodels for each concern [28]. The applied source metamodel is almost the same as the one shown in Figure 2. Moreover, we have evaluated our approach regarding its development costs and runtime performance. For both of them, the evaluation indicate that our solution is efficient.

3 Adaptation

Software adaptation can be generally conducted in two ways. Parameter adaptation modifies variables of a program and structural adaptation changes the software architecture by adding, removing or replacing components and connections among components [17]. In our approach, autonomic managers should perform both kinds of adaptation by modifying abstract target models rather than a complex and low level source model. Thus, a manager changes a target model and these changes should be reflected in the source model to adapt the managed system. Therefore, the bidirectional synchronization capabilities of our engine can in principal be used. For monitoring, it was required that changes in the source model are reflected in the target models (see Section 2.2). For adaptation, the opposite direction is required.

Until now and with our basic approach described in Section 2, we had no working solution for adaptation. While parameter adaptation is rather feasible without difficulty, we encountered several challenges for realizing structural adaptation. Both kinds of adaptation, the challenges and especially our solution that led to an extended architecture of our approach (Figure 6) are discussed in the following.

Figure 6: Extended Generic Architecture

3.1 Parameter Adaptation

Since parameter adaptation modifies program variables, it only requires the synchronization of changed parameter values from a target to a source model. Parameter values are generally of primitive data types, and therefore no complex changes are involved in parameter adaptation. Thus, a target model can only abstract from parameters in the source model by completely omitting them. This implies that adaptable parameters have to be reflected in target models, because managers work on target models and not on the source model (cf. Figure 6). Consequently, there is usually a bijective mapping between parameters in the source and in the target model, which enables the bidirectional synchronization of parameter values without difficulty.

For EJB-based software systems, parameter adaptation is performed by modifying values for simple environment entries of beans. Using models conforming to the metamodels described in Section 2.1, an entry is reflected in the source model as a SimpleEnvironmentEntry that is mapped one-to-one to a Property in the target model. Thus, the transformation engine can synchronize a changed value of the Property attribute value to the source model without any problems to finally adapt the parameter in the managed system.

3.2 Challenges for Structural Adaptation

In contrast to parameter adaptation, we encountered at least three research challenges as prerequisites for structural adaptation, which are discussed in the following. Other challenges are sketched in Section 7 and left for future work.

3.2.1 Refinement for Adaptation

As adaptation is performed on target models that are at higher levels of abstraction than a source model, changes performed by autonomic managers are also at a higher level of abstraction. If a target model abstracts too much from the source model, the relation between both models is only partial and need not to be bijective. Consequently, a bidirectional synchronization between both models is hindered since information about how to map abstract target model changes to the concrete source model could be missing. Such information has been discarded during monitoring to cause the intended abstraction of target models from the source model (cf. Section 2.2).

If the abstractions are of structural nature, propagating a change from a target to a source model is similar to refining an architecture, which requires additional information that constitute these refinements [9, 18]. Thus, the intended abstractions of target models and the need for refinements of changes can impede structural adaptation based on abstract target models. In MDE, this problem is generally discussed in round-trip engineering for the bidirectional synchronization of models representing disjoint concepts or concepts at different levels of abstraction [14, 26].

A refinement problem exists for the synchronization of source and target models conforming to the metamodels described in Section 2.1. When a Component together with its Properties, required and provided Interfaces is created in the target model, these changes cannot be synchronized to the source model without additional information. The cause for that is the missing information about EnterpriseBeans in the target model as its metamodel does not cover the concept of beans. The target model only reflects components representing EjbModules as black boxes such that the modules’ internal structures consisting of beans are hidden. Thus, additional information to create the internal structure of an EjbModule in the source model is required during synchronization. This includes information about associating the SimpleEnvironmentEntries, EjbInterfaces and EjbReferences, that correspond to Properties, provided and required Interfaces respectively, to the appropriate beans being part of the EjbModule. The TGG rule depicted in Figure 5 exemplifies this case for synchronizing a newly created provided Interface in the target model to an EjbInterface in the source model. It is undefined, how the SessionBean is created in the source model and to which SessionBean the newly created EjbInterface should be associated to, if the bean contains more than one session bean. Thus, a solution is required that fills the required, but missing information.

We think that this problem cannot be avoided. Otherwise, source and target models would be at the same level of abstraction, which would considerably diminish the benefits of having several target models besides the source model.

3.2.2 Restrictions to Adaptation

Another challenge is the definition of how to interface an autonomic manager with a target model. This means, what kind of changes are allowed on an abstract target model and how a manager performs these changes. As a target model abstracts from a managed system, it can theoretically allow a variety of changes that however could not be executed on the system, for example due to stronger system constraints.

For example, removing a required interface from a component by deleting an interface model element is usually not allowed as the component implementation within the managed system requires the corresponding functionality. Thus, arbitrary changes on a target model could not be supported. Moreover, a target model can be changed by directly adding, removing or modifying model elements, associations among model elements, or attribute values, or by invoking operations provided by model elements. Appropriate means to interface with a model have to be found. This is similar to the adaptation operators in Rainbow [10], which determine a set of specific actions a manager can perform on model and system elements for adapting the running system.

3.2.3 Ordering of Adaptation Steps

Finally, the last challenge addresses structural adaptation involving a set of atomic changes or steps that have to be synchronized at once from the target to the source model and even to the system. Thus, rather than propagating each single target model change to the source model and managed system by triggering the model transformation engine, a set of changes should be propagated by one run of the engine.

For example, when using an instance of the target metamodel depicted in Figure 4, the integration of a new component into a managed system requires at least the following steps. A Component element together with its properties, provided and required interfaces has to be created in the target model. The new component must be configured by setting Property values and by creating Connectors from or to other interfaces of already deployed components. Throughout the adaptation, the life cycle of the new component has to be controlled. Usually, there exists dependencies among these steps, like a component should only be started when it is configured appropriately. Otherwise, client applications or other components would be able to access the component though it is not completely configured, which is likely to result in failures. Thus, the order of changes matters and the order of changes performed on a target model might even differ from the order of performing corresponding changes to the source model or to the system. As already indicated, not suitable orders might affect the consistency of a system.

3.3 Our Solution for Structural Adaptation

This section describes our proposed solution for the challenges presented previously.

3.3.1 Refinement for Adaptation

As a solution for the required refinements to overcome the abstraction gap when transforming or synchronizing structural target model changes to a source model, two approaches have been considered. First, the missing information for a refinement could be filled with default values. However, this raised questions what meaningful default values for structural aspects are and how to change them subsequently as they would usually not represent the real situation.

Therefore, we applied another approach using Factories that are similar to the pattern of Abstract Factories using Factory Methods [8]. If structural abstractions between source and target model impedes the synchronization of target model changes to the source model, factories are employed to solve the refinement problem. Rather than conducting changes on the target model by creating or modifying model elements and trying to fill the missing information during synchronization, factories and the monitoring capabilities of our approach are used. Factories can be invoked on target models, while they operate on the source model as depicted in Figure 6. Thus, autonomic managers only interface with target models and the factory implementations work on the source model where the structural information is sufficiently complete because the abstraction gap does not occur at the source model level. Hence, the intended changes are performed by factories on the source model and afterwards they are synchronized to target models by the transformation engine, which makes them visible for managers.

In our example, a factory is required for creating a Component based on a certain ComponentType in the target model. The Component and its characteristics (Properties, required and provided Interfaces) are not created manually in the target model and then ineffectively synchronized to the source model, but a factory is used. This factory is invoked through the instantiate operation of the specific ComponentType in the target model to create or rather instantiate a Component of this type. The factory implementation does not introduce any additional information for the refinement as it works on the source model where the information about component types is complete to properly create an instance of a type. Thus, it can create the correct internal structure for an EjbModule, i.e., the contained EnterpriseBeans with their EjbInterfaces, EjbReferences etc., in the source model. Finally, these changes are synchronized to the target model by our monitoring capabilities, such that the desired Component and its characteristics appear in the target model.

Whether factories directly affect a managed system or not depends on the kind of coupling between the source model and the system. If a source model is closely coupled to a system, each single source model change would be directly executed to the system. In contrast, a set of source model changes could be executed to the system at once, on demand and temporally decoupled from the model changes. Our approach adopts the latter alternative, as it is rather a loose coupling and therefore more flexible.

Summing up, the factories can be seen as a pragmatic extension to the transformation engine as they bypass the engine for the adaptation case when the abstraction between source and target models is too large. However, the engine is used to synchronize changes performed by factories on the source model to target models. This solution gave us first insights towards a fundamental solution extending the capabilities of TGGs that might address the generic challenge of bidirectional model synchronization in MDE.

Nevertheless, the capabilities of the engine to synchronize target model changes to the source model is used for adaptation when components are (re)configured. This is discussed together with our proposed solution to the second challenge.

3.3.2 Restrictions to Adaptation

The second challenge addresses the kind of changes that are allowed on a target model and how they are performed on the model. Our proposed solution is similar to the adaptation operators that have to be defined for specific systems in Rainbow [10]. Thus, for target models conforming to the metamodel depicted in Figure 4, we defined the following actions or changes.

As already described, invoking the instantiate operation on a ComponentType creates a Component conforming to this type. The life cycle of a Component is controlled by modifying the value of its state attribute, which supports deploying, starting, stopping and undeploying a component. Parameter adaptation is supported throughout the life cycle of a component by modifying the value of its Properties attribute value. A connection among components can be established by creating a Connector element and by attaching the Connector to a required and provided Interface. Deleting a Connector element removes the connections among the components. All of these target model changes result in corresponding changes to the source model and therefore to the managed system. Finally, removing a Component or a ComponentType model element from the target model also removes the corresponding deployable component or respectively the component type from the managed system such that they cannot be used anymore. Other actions or changes performed on a target model are not valid adaptations and therefore they are not permitted.

3.3.3 Ordering of Adaptation Steps

Finally, the last challenge of executing a set of changes on a managed system in an appropriate order that does not affect the consistency of the system is addressed. This issue is critical as we aim at a loosely and temporally decoupled solution, i.e., each single target model change should not be directly synchronized to the source model and to the system. Therefore, rather a set of target model changes should be propagated to the source model on demand with one synchronization run. Likewise, after each synchronization run, the set of source model changes performed by the engine should be mapped to the system in one run. An advantage of such a decoupled solution is that model changes need not to be executed necessarily on the system, but they could be dismissed if the planned adaptation is not reasonable.

Our transformation engine is able to synchronize in one run two models that differ in more than change. Usually, several target model changes are synchronized in the same order to the source model as they have been conducted on the target model. However, there is no guarantee for that because subsequent changes can overwrite preceding ones that would not be processed by the engine. Thus, the engine might miss intermediate changes that are however relevant from the perspective of a managed system. A simple example is the life cycle management of a component. If the life cycle state of an undeployed component as part of the target model is changed to deployed and directly afterwards to started, the engine would synchronize these changes to the source model by starting an undeployed component without deploying it in between. This results in a failure as the deployment action has been overwritten by the starting action. To generally address the issue of ordering a set of changes, three options can be used.

The first option applies to a target model by appropriate modifications of the model and intermediate synchronizations to the source model and managed system. If change should be performed before change on the system, after performing on the target model the synchronization can be triggered. This ensures that a change corresponding to is performed on the source model and on the managed system. Then can be conducted followed by another synchronization. Hence, the order of changes can be controlled by intermediate executions of the synchronization.

Second, the design of the TGG transformation rules can affect the order in which the engine synchronizes several target model changes to the source model in one run. Constraints can be specified in a TGG rule and they serve as a condition that must hold before the rule can be applied. Likewise, a TGG rule has an application context by means of patterns in the source, correspondence and target models (e.g. model elements not being stereotyped with create in Figure 5) that must be present for applying the rule. Thus, the interplay of different rules can be utilized. For example, the changes and are already performed on the target model, but should be executed before on the source model and system. Therefore, the rule for synchronizing has a constraint or application context that is not fulfilled until the rule for has been applied. Thus, the synchronization of is only enabled when has been synchronized before, which results in the desired order of performing before . However, this option is at risk of modeling conflicts like cyclic dependencies between different rules.

Finally, the last option takes effect at the causal connection between a source model and a managed system. Therefore, arbitrary changes performed on a source model by the synchronization engine are generally ordered for executing them on a managed system. At first, components that should be stopped are stopped, then connections and components are removed, new components are deployed, connections are created, parameter values are set, and finally, components are started.

Thus, a basic ordering of adaptation steps is supported by the last option, while it is possible to determine more specific orders at design time by modeling appropriate transformation rules (cf. second option) or at runtime by triggering intermediate synchronizations (cf. first option).

4 Application Example

We demonstrate the application of our approach in a self-healing scenario requiring the replacement of a stateless component444For simplicity, a stateless component is replaced though basic support for state transfer and quiescence is provided.. The models depicted in this section are described in the abstract syntax as specified by the target metamodel (cf. Figure 4). The application example is a web shop system consisting of three components types that are depicted in Figure 7. The ComponentPlatform instance provides the ShopT, ShipmentT, and WarehouseT component types for the core web shop, the shipment of goods, and the ordering of goods from warehouses, respectively. ShopT provides the interface type IWebshop that specifies the usage of the shop by external client applications and it requires the interface types IShipment and IWarehousing that are provided by ShipmentT and WarehouseT, respectively. Finally, ShipmentT has a property type that defines the option to configure the shipping provider as a String value.

Figure 7: Component Types

A deployed configuration of this shop system is depicted by the white-shaded model elements in Figure 8. The three component types are instantiated to components, like ShopT to Shop555Actually, the elements in Figure 8 and their types in Figure 7 are part of one model and associated with each other. For illustration, they are depicted separately and the associations can be derived by the values of the name attributes., and they are configured. Thus, the Shop is wired to the Shipment and Warehouse components through the connectors c1 and c2, respectively. Finally, the Shipment component uses the company UPS as a shipping provider, which is configured by the property.

Figure 8: Components and their Configuration

This architectural view on the shop system is a concrete target model666In contrast to the 21 white-shaded elements of Figure 7 and 8, the corresponding source model consists of at least 39 nodes. Both numbers do not include the monitored failures. provided by our approach at runtime. It can be used to locate failures, that have occurred during execution, in the architecture. As defined by the metamodel depicted in Figure 4, these failures are attached to the specific provided interface whose usages have caused them. This is illustrated in Figure 8 for the IWarehousing interface provided by the Warehouse component. This information can be used by managers to identify the demand for adaptation to prevent further occurrences of failures. Therefore, an alternative for the currently used component type WarehouseT is required that provides the same interface type and that corrects the faulty behavior. As soon as new component types are available in the managed system, they appear in the target model due to the monitoring capabilities of our approach. For our example, the Warehouse2T component type depicted in Figure 9 would enrich the target model depicted in Figure 7.

Figure 9: Additional Component Type

Managers search the target model for component types providing the IWarehousing interface type to find with Warehouse2T an alternative for the faulty WarehouseT component type. In the following, the steps of modifying the target model to replace the Warehouse with the Warehouse2 component are outlined.

Invoking the instantiate operation on the Warehouse2T model element (Figure 9) creates the Warehouse2 component and its provided interface IWarehousing in the target model (grey-shaded elements in Figure 8) as described in Section 3.3.1. Initially, the new component is in state UNDEPLOYED and its provided interface is not attached to any connector. As the new component has not any required interface or property, it does not need to be configured and it can be directly deployed and started. Therefore, its state attribute is set to DEPLOYED and then to STARTED, each followed by a synchronization to the source model and managed system. Afterwards, the connector c2 is removed by deleting the corresponding model element and the new connector c3 is created an attached to the corresponding required and provided interfaces. These changes are synchronized to the underlying system and the Shop is now wired to Warehouse2 instead of Warehouse. As the Warehouse component is not used anymore, it is stopped and undeployed by appropriate modifications of the state attribute value, each followed by a synchronization. Finally, the model elements for the Warehouse component and WarehouseT component type are removed from the target model, which also removes the provided interface and interface type elements, respectively. Synchronizing these changes removes the faulty component and its type from the source model and managed system to prevent any future use of them.

This example showed how a target model is used for identifying adaptation demand and for conducting adaptations, while it abstracts from the underlying platform as it provides a generic component-based view on an EJB-based system.

5 Implementation

Our approach has been implemented on top of the mKernel infrastructure [3] that provides sensors and effectors for managing software systems being realized with Enterprise Java Beans 3.0 (EJB) [6] technology for the GlassFish v2777https://glassfish.dev.java.net/ (Jan 12, 2010) application server. EJB-based components are automatically instrumented by mKernel, such that management concerns are completely transparent to component developers. The sensors and effectors are provided as an application programming interface (API) that is not compliant to the Eclipse Modeling Framework (EMF). However, our metamodels and model transformation techniques are based on EMF though they can run decoupled from the Eclipse workbench.

Therefore, we developed an EMF-based metamodel for the EJB domain that captures the capabilities of the API and that serves as the source metamodel depicted in Figure 2. The compatibility to EMF ensures that a source model as an instance of this metamodel can be processed by our model transformation engine. A source model is causally connected to a running system, which is realized by an event-driven adapter that works incrementally. Therefore, events dispatched from mKernel sensors notifying about changes in the system are processed to update the source model. Likewise, if the source model is changed by the transformation engine, the model emits corresponding events that are mapped to invocations of effectors that actually adapt the system. For both directions, the events can be queued and processed on demand, which results in a loose coupling between the source model and the system. Likewise, the bidirectional synchronization of source and target models can be triggered on demand even if both models differ in more than one change. Thus, our approach achieves a loose coupling between different runtime models and the running system and therefore it can be used in a flexible manner.

To realize structural adaptation, one factory was required. It creates an EjbModule in the source model as described in Section 3. It also instantiates a corresponding module in the mKernel system, but it does not deploy the module and therefore it does not affect the actual system.

6 Related Work

Several approaches address runtime adaptation based on architectural models. In contrast to our approach, they do not provide simultaneously several runtime models at different abstraction levels or for different concerns, like performance or failures to cover different self-management capabilities.

The model of Oreizy et al. [22] is as complex as the managed system since it is a one-to-one mapping between model elements and implementation classes. More abstract models are not provided though they theoretically consider hierarchies of models in [23]. Thus, their model can be compared to our complex source model. Using the framework of Garlan et al. [10], it might be possible to simultaneously employ several runtime models at different levels of abstraction or for different concerns, which mainly depends on how the user tailors the framework. However, both case studies presented by Garlan et al. use one model to cover one or more concerns. Likewise, Caporuscio et al. [4] apply model-based adaptation using one architectural model, but they focus on performance management such that their model does not describe any other concern in addition to performance. All these approaches [4, 10, 22] use some form of architecture description languages and do not apply MDE techniques that can yield to benefits for runtime adaptation [2].

However, MDE approaches also do not provide multiple runtime models, while our approach does. Moreover, they do not work incrementally to maintain a model or they do not apply advanced MDE techniques like model synchronization. The model of Hein et al. [13] is created from scratch out of a system snapshot and it is only used for analysis as adaptation is not supported. The approach of Dubus and Merle [7] incrementally maintains a model that is however focused on the configuration and deployment of a system and does not cover any additional concern. Likewise, Morin et al. [19, 20] update their runtime model incrementally but it only reflects a structural view. However, they use model weaving techniques at runtime to transform models specified by the same metamodel to build new architectures for a managed system. All approaches discussed before do not use advanced MDE techniques like model synchronization at runtime, except of Morin et al. who apply endogenous transformations, i.e. source and target models share the same metamodel. In contrast, we apply exogenous synchronizations since source and target metamodels are not the same. Exogenous transformations from software models to analysis models for non-functional concerns are employed by Cortellessa et al. [5] and Sabetta et al. [24]. However, they utilize these transformation at design time for analyzing concerns early in the development phase and not at runtime.

Regarding exogenous model transformation or synchronization at runtime, only initial preliminary ideas exist. Song et al. [25] use an engine to synchronize models at runtime that however works only offline, i.e., models have to be read from files, which degrades performance. Moreover, their source model does not seem to be maintained at runtime, but rather created on demand from scratch, which might involve non-incremental synchronizations. In contrast, our approach completely works online and incrementally.

7 Conclusion & Future Work

In this paper we presented an approach that uses abstract runtime models and model-driven engineering (MDE) techniques for adaptation. In contrast to a complex source model, an abstract target model provides a more appropriate abstraction for autonomic managers and a more specific view for a self-management capability. Both aspects ease the work of managers. Moreover, target models can abstract from a concrete managed system and platform, which supports the reusability and extensibility of managers being able to operate on these models across different systems. With this work, our basic monitoring approach [28] has been extended with adaptation capabilities to move towards closed feedback loops. The approach has been implemented, which was eased for the model synchronization due to MDE techniques, and its application has been shown in an example.

As future work, we will investigate adaptations performed concurrently by different managers on different target models. Since each manager aims at a specific concern, adaptations can interfere with each other. This requires some form of coordination among managers to address interactions between different models, respectively their concerns. Finally, a distributed setting for our approach is considered.

References

  • [1] N. Bencomo. On the Use of Software Models during Software Execution. In Proc. of the ICSE Workshop on Modeling in Software Engineering. IEEE, 2009.
  • [2] G. Blair, N. Bencomo, and R. B. France. Models@run.time. Computer, 42(10):22–27, 2009.
  • [3] J. Bruhn, C. Niklaus, T. Vogel, and G. Wirtz. Comprehensive support for management of Enterprise Applications. In Proc. of the 6th ACS/IEEE Intl. Conference on Computer Systems and Applications, pages 755–762. IEEE, 2008.
  • [4] M. Caporuscio, A. D. Marco, and P. Inverardi. Model-based system reconfiguration for dynamic performance management. Journal of Systems and Software, 80(4):455 – 473, 2007.
  • [5] V. Cortellessa, A. D. Marco, and P. Inverardi. Integrating Performance and Reliability Analysis in a Non-Functional MDA Framework. In Fundamental Approaches to Software Engineering, volume 4422 of LNCS, pages 57–71. Springer, 2007.
  • [6] L. DeMichiel and M. Keith. JSR 220: Enterprise JavaBeans, Version 3.0: EJB Core Contracts and Requirements, 2006.
  • [7] J. Dubus and P. Merle. Applying OMG D&C Specification and ECA Rules for Autonomous Distributed Component-based Systems. In Proc. of the 1st Intl. Workshop on Models@run.time, 2006.
  • [8] E. Gamma, R. Helm, R. Johnson, and J. Vlissides. Design Patterns - Elements of Reusable Object Oriented Software. Addison-Wesley, 32 edition, 1995.
  • [9] D. Garlan. Style-Based Refinement for Software Architecture. In Joint Proc. of the 2nd Intl. Software Architecture Workshop and Intl. Workshop on Multiple Perspectives in Software Development, pages 72–75. ACM, 1996.
  • [10] D. Garlan, S.-W. Cheng, A.-C. Huang, B. Schmerl, and P. Steenkiste. Rainbow: Architecture-Based Self-Adaptation with Reusable Infrastructure. Computer, 37(10):46–54, 2004.
  • [11] H. Giese and S. Hildebrandt. Incremental Model Synchronization for Multiple Updates. In Proc. of the 3rd Intl. Workshop on Graph and Model Transformation. ACM, 2008.
  • [12] H. Giese and R. Wagner. From Model Transformation to Incremental Bidirectional Model Synchronization. Software and Systems Modeling, 8(1), 2009.
  • [13] C. Hein, T. Ritter, and M. Wagner. System Monitoring using Constraint Checking as part of Model Based System Management. In Proc. of the 2nd Intl. Workshop on Models@run.time, 2007.
  • [14] T. Hettel, M. J. Lawley, and K. Raymond. Model Synchronisation: Definitions for Round-Trip Engineering. In Proc. of the 1st Intl. Conference on Model Transformation, pages 31–45, 2008.
  • [15] J. Kephart and D. Chess. The Vision of Autonomic Computing. IEEE Computer, 36(1):41–50, 2003.
  • [16] J. Kramer and J. Magee. Self-Managed Systems: an Architectural Challenge. In Proc. of the ICSE Workshop on Future of Software Engineering, pages 259–268. IEEE, 2007.
  • [17] P. K. McKinley, S. M. Sadjadi, E. P. Kasten, and B. H. C. Cheng. Composing Adaptive Software. IEEE Computer, 37(7), 2004.
  • [18] M. Moriconi, X. Qian, and R. Riemenschneider. Correct Architecture Refinement. IEEE Transactions on Software Engineering, 21(4):356–372, April 1995.
  • [19] B. Morin, O. Barais, J.-M. Jézéquel, F. Fleurey, and A. Solberg. Models@Run.time to Support Dynamic Adaptation. Computer, 42(10):44–51, 2009.
  • [20] B. Morin, O. Barais, G. Nain, and J.-M. Jézéquel. Taming Dynamically Adaptive Systems using models and aspects. In Proc. of the 31st Intl. Conference on Software Engineering, pages 122–132. IEEE, 2009.
  • [21] OMG. Meta Object Facility (MOF) 2.0 Core Specification, 2004.
  • [22] P. Oreizy, N. Medvidovic, and R. N. Taylor. Architecture-based Runtime Software Evolution. In Proc. of the 20th Intl. Conference on Software Engineering, pages 177–186. IEEE, 1998.
  • [23] P. Oreizy, N. Medvidovic, and R. N. Taylor. Runtime Software Adaptation: Framework, Approaches, and Styles. In In Companion of the 30th Intl. Conference on Software Engineering, pages 899–910. ACM, 2008.
  • [24] A. Sabetta, D. C. Petriu, V. Grassi, and R. Mirandola. Abstraction-Raising Transformation for Generating Analysis Models. In Satellite Events at the MoDELS Conference 2005, Revised Selected Papers, volume 3844 of LNCS, pages 217–226. Springer, 2006.
  • [25] H. Song, Y. Xiong, Z. Hu, G. Huang, and H. Mei. A Model-Driven Framework for Constructing Runtime Architecture Infrastructures. Technical Report GRACE-TR-2008-05, GRACE Center, Japan, 2008.
  • [26] P. Stevens. Bidirectional model transformations in QVT: semantic issues and open questions. Software and Systems Modeling, 9(1):7–20, 2010.
  • [27] T. Vogel, S. Neumann, S. Hildebrandt, H. Giese, and B. Becker. Model-Driven Architectural Monitoring and Adaptation for Autonomic Systems. In Proc. of the 6th Intl. Conference on Autonomic Computing and Communications, pages 67–68. ACM, 2009.
  • [28] T. Vogel, S. Neumann, S. Hildebrandt, H. Giese, and B. Becker. Incremental Model Synchronization for Efficient Run-Time Monitoring . In Models in Software Engineering, Workshops and Symposia at MODELS 2009, Reports and Revised Selected Papers, volume 6002 of LNCS, pages 124–139. Springer, 2010.