A Fault-Tolerant Software Architecture for Component-Based Systems (original) (raw)
Related papers
A Configurable Fault Tolerant Architecture for Component-Based Systems
2009
Component-based software engineering is an emerging paradigm for software development. Benefits of component-based development include significant reduction in the development cost, time and improvement in the dependability requirements. Commercial offthe-shelf (COTS) components are used without any code modification and inspection. When such components are integrated to build safety-critical systems, faults within individual COTS components or faults due to their collaboration may cause catastrophic failures. Therefore, for systems with high dependability requirements, it is essential to incorporate ways for tolerating the software faults at architectural level to deal with the faults that are not catered within the components. The existing component based fault tolerant architectures provide fault tolerance through either exception handling or design diversity. In this paper, we propose a fault tolerant architecture, which supports design diversity and exception handling fault tol...
Structuring exception handling for dependable component-based software systems
Proceedings. 30th Euromicro Conference, 2004., 2004
Component-based development (CBD) is recognized today as the standard paradigm for structuring large software systems. However, the most popular component models, such as Enterprise Javabeans and DCOM, provide almost no guidance about how to incorporate exception handling into component-based systems. The problem of how to employ language-level exception handling mechanisms to incorporate fault-tolerance in component-based systems is recognized by CBD practitioners as very difficult and often not adequately solved, with negative impact on reliability and maintainability. We believe that the construction of dependable component-based systems requires both (i) a global exception handling strategy for inter-component composition and (ii) a local exception handling strategy for dealing with errors within the reusable components. In this paper we describe a general strategy for the development of fault-tolerant software components and their integration into dependable component-based software systems.
Architecting Fault-tolerant Component-based Systems: from requirements to testing
2007
Fault tolerance is one of the most important means to avoid service failure in the presence of faults, so to guarantee they will not interrupt the service delivery. Software testing, instead, is one of the major fault removal techniques, realized in order to detect and remove software faults during software development so that they will not be present in the final product. This paper shows how fault tolerance and testing can be used to validate component-based systems.
Component-Based Applications: A Dynamic Reconfiguration Approach with Fault Tolerance Support
Electronic Notes in Theoretical Computer Science, 2002
This paper presents a mechanism for dynamic reconfiguration of component-based applications and its fault tolerance strategy. The mechanism, named generic connector, allows composing a component-based application as a set of services with no previous knowledge about the specific components that will provide some services. The components will be selected at runtime. The objective of this work is to offer a mechanism that tries to satisfy every invocation under its responsibility and makes failures as transparent as possible. It is an important tool to compose applications through the reuse of existing components because it frees the programmer from the task of searching components in order to use them and, also, from solving some types of failures.
Wads, 2003
The ever-increasing c omplexity of software systems makes it progressively more difficult to provide dependability guarantees for such systems, especially when they are deployed in unpredictably changing environments. The Component Based Software Development initiative addresses many of the complexity related difficulties, but consequently introduces new challenges. These are related to the lack of component intrinsic information that system integrators face at system integration time, as well as the lack of information on the c omponent running-context that component providers face at component development time. We propose an addition to existing component models, for enabling new capabilities such as adaptability, performance optimisation and tolerance to context-driven faults. The concept of 'component redundancy' is at the core of our approach, implying alternate utilisation of functionally equivalent component implementations, for meeting application-specific dependability goals. A framework for implementing component redundancy in component-based applications is described and an example scenario showing the utility of our work is given.
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.
A generic approach to structuring and implementing complex fault-tolerant software
This paper addresses the practical implementation of means of tolerating residual software faults in complex software systems, especially concurrent and distributed ones. There are several inherent difficulties in implementing such fault-tolerant software systems, including the controlled use of extra redundancy and the mixture of different design concerns. In an attempt to minimise these difficulties, we present a generic implementation approach, composed of a multi-layered reference architecture, a configuration method and an architectural pattern. We evaluate our implementation approach using an industrial control application whose control software we equip with the ability to tolerate a variety of software faults. The preliminary evidence shows that our approach can simplify the implementation process, reduce repetitive development effort and provide high flexibility through a generic interface for a wide range of fault tolerance schemes
Towards an Error Modeling Framework for Dependable Component Based Systems
DATE Workshop on …, 2008
Component-Based Development (CBD) of software, with its successes in enterprise computing, has the promise of being a good development model due to its cost effectiveness and potential for achieving high quality of components by virtue of reuse. However, for systems with dependability concerns, such as real-time systems, the major challenge in using CBD will be predicting dependability attributes, or providing dependability assertions, based on the individual component properties and architectural aspects. In this paper, we propose a framework which aims to address this challenge. Specifically, we describe a revised error classification, error propagation aspects and briefly sketch how to compose error models within the context of Component-Based Systems (CBS). The ultimate goal is to perform the analysis on a given CBS, in order to find bottlenecks in achieving dependability requirements and to provide guidelines on the usage of appropriate error detection and fault tolerance mechanisms.
Companion of the 18th annual ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications - OOPSLA '03, 2003
The ever-increasing c omplexity of software systems makes it progressively more difficult to provide dependability guarantees for such systems, especially when they are deployed in unpredictably changing environments. The Component Based Software Development initiative addresses many of the complexity related difficulties, but consequently introduces new challenges. These are related to the lack of component intrinsic information that system integrators face at system integration time, as well as the lack of information on the c omponent running-context that component providers face at component development time. We propose an addition to existing component models, for enabling new capabilities such as adaptability, performance optimisation and tolerance to context-driven faults. The concept of 'component redundancy' is at the core of our approach, implying alternate utilisation of functionally equivalent component implementations, for meeting application-specific dependability goals. A framework for implementing component redundancy in component-based applications is described and an example scenario showing the utility of our work is given.