A CSP-Based Approach for Managing the Dynamic Reconfiguration of Software Architecture

Introduction

Software architectures provide solutions for describing the structure of complex software systems (Medvidovic & Taylor, 2000). Software architecture¹ is the process of defining the structure of large software systems which are represented by a set of software components. This structure is constituted of architectural elements and describes how they are connected together. Software architectures have a hierarchical structure where components can be composed into complex components and these, in turn, can be composed into more complex components (Costa-Soria, 2011). Nowadays, 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 system failure (Saadi et al., 2018a). It describes how configurations, components, connectors, ports or interfaces can be created, interconnected, and/or removed during system execution.

Actually, two levels of dynamism in software architecture exist (Costa Soria, 2011): Dynamic Reconfiguration which addresses changes at the configuration level, and Dynamic Type Evolution which addresses changes at the type level. Dynamism in software architecture has been addressed from different perspectives. The aim is to maintain software consistency after reconfiguration and during execution. In order to support architecture-based run-time reconfiguration and evolution, architecture description languages (ADLs) must provide specific features to model dynamic changes and techniques for changing them into the running system (Cavalcante et al., 2015). However, a major challenge for ADLs is the ability of describing dynamic software architectures under both structural and behavioral viewpoints, as well as covering run-time changes on the structure and behavior of the architecture and its components or connectors (Cavalcante et al., 2015; Medvidovic & Taylor, 2000). Currently, most of existing ADLs assume that architectures are static and few ADLs propose a description of dynamic concerns. In these few ADLs, only basic reconfigurability is provided, reconfigurations generally are represented by programming a set of actions (e.g., to add, remove, connect, disconnect) that allow to instantiate and connect components at run-time (Alvares et al., 2017). Furthermore, most ADLs and proposed approaches do not support some important dynamic aspects. For example, they do not allow stopping, disabling, replacing or removing a component or a connector at run-time. Whereas the description of evolving architecture should not be limited to the specification of a unique static configuration, but must cover all correct future configurations. In some other existing approaches, reconfiguration decisions are taken at run-time by choosing the next configuration in function of the past history. To the best of the authors’ knowledge, regarding the software behavioral management, few existing solutions and works allow specifying the behavior of the software. However, they do not allow reconfiguring or replacing the behavior of internal components at run-time. Overall, the authors of this paper can say that the dynamic management of software architecture and its elements in the most of existing ADLs is limited.

The work that authors present in this paper thoroughly revises and extends their previous work done in (Saadi, 2017; Saadi et al., 2018a; Saadi et al., 2018b). Unlike these papers which do not deal with formal verification and validation of behavioral reconfiguration consistency, the authors present here a new CSP²-based approach called Dy-ReSA (Dynamic REconfiguration Software Architecture) for managing dynamic reconfiguration and evolution in software architecture. Moreover, their reconfiguration language has been thoroughly improved in comparison to that of (Saadi et al., 2018b) by adding more complex control structures which help to write scripts that deal with sophisticated reconfiguration transactions. Note that the authors have developed a tool prototype that implements and validates all their proposals.