Automata-Based Approach to Manage Self-Adaptive Component-Based Architectures

Introduction

Software architecture represents the structures of a software system and the discipline of creating such structures and systems, each structure comprises software elements, relations among them, and properties of both elements and relations (Clements et al., 2010). Software architecture allows defining the structure of software systems which are represented by a set of software components and connectors. Software¹ architecture is an important level of description for software systems. At this level of abstraction, a set of concepts can be found: components, protocols of interaction between those components, global system properties, and life-cycle issues (Abowd, 1995). Actually, there are two types of software architecture: the static architecture and the dynamic architecture (Medvidovic & Taylor, 2000). In a static architecture, components and their configurations are defined in the specification, the composition and the structure of static architecture cannot change during execution. However, a dynamic architecture allows planning topology changes that happen at run-time. A dynamic architecture can therefore manage a changing environment and adapt itself to the new context. It describes how configurations, components, connectors, ports or interfaces can be created, interconnected, and/or removed during system execution (Saadi et al., 2018). Such dynamic software systems must adapt themselves in response to changes in their environments in order to ensure the continuous satisfaction of their requirements. This adaptation must thus be performed along with preserving the conditions and intended properties (Saadi et al., 2018).

Dynamic architectures represent an appropriate means to manage the self-adaptive software which has become important to address the new challenges of complex systems. These systems must provide specific features to model dynamic changes and techniques for changing them into the running environment. However, a major challenge is the ability of describing dynamic software architectures according to both structural and behavioral viewpoints, as well as handling run-time changes in the structure and behavior of the architecture and its elements (Medvidovic and Taylor, 2000).

Many existing solutions proposed to deal with self-adaptive software tries to use component-based architecture and ADLs (Architecture Description Language). However, these approaches do not properly manage the dynamic of software architecture. Moreover, the description of changing software architectures should not be limited to the specification of a unique static configuration, but must cover all correct future configurations (Saadi et al., 2017). In fact, adaptation decisions need to be taken at run-time by choosing the next configuration depending on the past history. Some of existing solutions assume that architectures are static, whereas others propose a description of dynamic concerns by using simple and basic changes, adaptations generally are represented, therein by programming a set of actions (e.g., add, delete, connect, disconnect) that allow to instantiate and connect components at run-time (Alvares et al., 2017). Furthermore, most of such approaches do not support some important dynamic aspects. For example, they do not allow stopping, restarting, disabling, replacing or removing a component or a connector at run-time.