Making Sound Policies for Self-healing Systems (original) (raw)

A formal architecture-centric approach for safe self-repair

… Conference on Web …, 2009

Ce papier propose une approche formelle centrée architecture pour la spécification de politiques correctes de réparation architecturale. Une politique est considérée correcte si, une fois exécutée, elle permet de remettre le système dans un état sain vis-à-vis de ses propriétés. Les politiques et les théorèmes de preuve sont formellement définis en notation Z, et les spécifications sont implémentées sous l'outil de preuve Z/Eves. Nous définissons également un profile UML qui vise de décrire la structure d'une politique de réparation conformément à notre approche. Nous validons l'approche sur le style architectural Publier/Souscrire. ABSTRACT. In this paper, we propose a formal architecture-centric approach for specifying correct architectural repair policies. By correctness, we mean that once executed, the policy will make the system in a correct state w.r.t its properties. Policies and proof theorems are formally defined in Z notation and specifications are implemented in the Z/Eves theorem prover. We also define an UML profile which aims to describe the structure of a repair policy following our approach. We validate the approach on an increasingly commonly used architectural style for component-based systems : Publish/Subscribe style.

Exploiting architectural design knowledge to support self-repairing systems

Proceedings of the 14th international conference on Software engineering and knowledge engineering, 2002

In an increasing number of domains software is now required to be self-adapting and self-healing. While in the past such abilities were incorporated into software on a per system basis, proliferation of such systems calls for more generalized mechanisms to manage dynamic adaptation. General mechanisms have the advantage that they can be reused in numerous systems, analyzed separately from the system being adapted, and easily changed to incorporate new adaptations. Moreover, they provide a natural home for encoding the expertise of system designers and implementers about adaptation strategies and policies. In this paper, we show how current software architecture tools can be extended to provide such generalized dynamic adaptation mechanisms.

Increasing System Dependability through Architecture-Based Self-Repair

Lecture Notes in Computer Science, 2003

One increasingly important technique for improving system dependability is to provide mechanisms for a system to adapt at run time in order to accommodate varying resources, system errors, and changing requirements. For such "self-repairing" systems one of the hard problems is determining when a change is needed, and knowing what kind of adaptation is required. In this paper we describe a partial solution in which stylized architectural design models are maintained at run time as a vehicle for automatically monitoring system behavior, for detecting when that behavior falls outside of acceptable ranges, and for deciding on a high-level repair strategy. The main innovative feature of the approach is the ability to specialize a generic run time adaptation framework to support particular architectural styles and properties of interest. Specifically, a formal description of an architectural style defines for a family of related systems the conditions under which adaptation should be considered, provides an analytic basis for detecting anomalies, and serves as a basis for developing sound repair strategies.

MeidyaCoM‐policy: Approach for modelling and checking repair policies for self‐healing systems

IET Software, 2021

The architecture of distributed systems is subject to certain failures: component failure, downed connections etc. These failures come from the dynamicity and complexity of these systems. As a solution to cure this weakness, adaptation plans can be added. However, the main difficulty of self-adaptation emerges while considering the soundness of the adaptation and preservation of stylistic constraints of the system. The MeidyaCoM-Policy, an architecture-centric approach for modelling and checking repair policies to guarantee the success of the adaptation, is presented. This approach is a solution for applying self-healing. A new unified modelling language (UML) profile that provides a visual notation for modelling repair policies is proposed to automatically transform UML models to Z notation using transformation rules coded in eXtensible styles language transformation (XSLT) language. These specifications are implemented under the Z/ EVES theorem prover to prove specification soundness and consistency to guarantee the success of the adaptation. MeidyaCoM-Policy applies to all architectural styles. It is instantiated for the publish/subscribe style and illustrated with a case study. An outline of the developed software environment is provided. This is an open access article under the terms of the Creative Commons Attribution License, which permits use, distribution and reproduction in any medium, provided the original work is properly cited.

Architectural style requirements for self-healing systems

Proceedings of the first workshop on Self-healing systems - WOSS '02, 2002

This paper argues for a set of requirements that an architectural style for self-healing systems should satisfy: adaptability, dynamicity, awareness, observability, autonomy, robustness, distributability, mobility, and traceability. Support for these requirements is discussed along five dimensions we have identified as distinguishing characteristics of architectural styles: external structure, topology rules, behavior, interaction, and data flow. As an illustration, these requirements are used to assess an existing architectural style. While this initial formulation of the requirements appears to have utility, much further work remains to be done in order to apply it in evaluating and comparing architectural styles for self-healing systems.

Functionality Recomposition for Self-healing

ICSOFT'09: Proceedings of the 4th International Conference on Software and Data Technologies, 2009

Autonomic computing aims to provide self-management and adaptation in the implementation of complex (large, heterogeneous, distributed) systems over time. Such adaptations must be stable, in the sense of maintaining the system’s high-level goals across environmental changes, which may lead to functionality loss. In this paper we present FReSH, a decentralised component-based framework which main objective is to self-heal the operation of complex systems in the face of behavioural disruptions. FReSH deals with formally specified components that provide a single piece of functionality. The reusable and shareable nature of these building blocks makes them eligible for dynamically recomposing the functionality provided by any failing component of the system without human intervention. FReSH supports the construction of more flexible, adaptive and robust software structures suitable to cope with the environmental changes of complex systems.

A Fault-Tolerant Software Architecture for Component-Based Systems

Lecture Notes in Computer Science, 2003

Component-based software built from reusable software components is being used in a wide range of applications that have high dependability requirements. In order to achieve the required levels of dependability, it is necessary to incorporate into these complex systems means for coping with software faults. However, the problem is exacerbated if we consider the current trend of integrating off-the-shelf software components, from independent sources, which allow neither code inspection nor changes. To leverage the dependability properties of these systems, we need solutions at the architectural level that are able to guide the structuring of unrehable components into a faulttolerant architecture. In this paper, we present an approach for structuring faulttolerant component-based systems based on the C2 architectural style.

Improving system dependability by enforcing architectural intent

Proceedings of the 2005 workshop on Architecting dependable systems - WADS '05, 2005

Developing dependable software systems requires enforcing conformance between architecture and implementation during software development and evolution. We address this problem with a multi-pronged approach: (a) automated refinement of a component-and-connector (C&C) architectural view into an initial implementation, (b) enforcement of architectural structure at the programming language level, (c) automated abstraction of a C&C view from an implementation, and (d) semi-automated incremental synchronization between the architectural and the implementation C&C views. We use an Architecture Description Language (ADL), Acme, to describe the architecture, and ArchJava, an implementation language which embeds a C&C architecture specification within Java implementation code. Although both Acme and ArchJava specify C&C views, a number of structural differences may arise. Our approach can detect structural differences which correspond directly to implementation-level violations of the well thoughtout architectural intent. Furthermore, supplementing the C&C view extracted from the implementation with architectural types and styles can uncover additional violations.

From Design for Adaptation to Component-Based Resilient Computing

2012 IEEE 18th Pacific Rim International Symposium on Dependable Computing, 2012

The evolution of systems during their operational lifetime is becoming ineluctable. Dependable systems, which continuously deliver trustworthy services, must evolve in order to comply with changes having different origins, e.g. new fault tolerance requirements, or changes in available resources. These evolutions must not violate their dependability properties, which leads to the notion of resilient computing. This paper presents a methodology for developing adaptive fault tolerance mechanisms, from the design to the actual runtime reconfiguration, leveraging component-based middleware which enable fine-grained manipulation of software architectures.