Structuring integrated Web applications for fault tolerance

This paper discusses some of the typical characteristics of modern Web applications and analyses some of the problems the developers of such systems have to face. One of such types of applications is integrated Web application, i.e. application that integrates several independent Web services. The paper focuses on providing software fault tolerance for such systems. The solution we put forward employs the concept of co-ordinated atomic (CA) actions for structuring such applications and for providing fault tolerance using exception handling. The paper discusses important design and implementation decisions we have made while developing a travel agency (TA) case study and attempts to generalize them to allow CA actions to be easily applied for building dependable Web applications.

While typical solutions focus on fault tolerance (and specifically, exception handling) during the design and implementation phases of the software life-cycle (e.g., Java and Windows NT exception handling), more recently the need for explicit exception handling solutions during the entire life cycle has been advocated by some researchers. Several solutions have been proposed for fault tolerance via exception handling at the software architecture and component levels. This paper describes how the two concepts of fault tolerance and software architectures have been integrated so far. It is structured in two parts (overview on fault tolerance and exception handling, and integrating fault tolerance into software architecture) and is based on a survey study on architecting fault tolerant systems where more than fifteen approaches have been analyzed and classified. This paper concludes by identifying those issues that remain still open and require deeper investigation.

Practical exception handling and resolution in concurrent programs

A comparative study of exception handling mechanisms for building dependable object-oriented software

Exception handling in a complex concurrent and distributed system (e.g. one involving cooperating rather than just competing activities) is often a necessary, but a very difficult, task. No widely accepted models or approaches exist in this area. The object-oriented paradigm, for all its structuring benefits, and real-time requirements each add further difficulties to the design and implementation of exception handling in such systems. In this paper, we develop a general structuring framework based on the coordinated atomic (CA) action concept for handling exceptions in an object-oriented distributed system, in which exceptions in both the value and the time domain are taken into account. In particular, we attempt to attack several difficult problems related to real-time system design and error recovery, including action-level timing constraints, time-triggered CA actions, and time-dependent exception handling. The proposed framework is then demonstrated and assessed using an industrial real-time application-the Production Cell III case study.

Component-based software systems built out of reusable software components are being used in a wide range of applications which have high dependability requirements. In order to accomplish the required levels of dependability, it is necessary to incorporate into these complex systems means for to cope with software faults. Exception handling is a well-known technique for adding forward error recovery to software systems supported by various mainstream programming languages. However, exception handling for component-based applications at the architectural level introduces new challenges which are not addressed by traditional exception handling systems, such as unavailability of source code, specially when off-the-shelf components are employed. In this paper, we present an exception handling system which adds fault tolerance to component-based systems at the architectural level. Our solution considers issues which are specific to component-based applications, such as unavailability of source code. We also present a framework which implements the proposed exception handling system for applications built using the C2 architectural style.KeywordsService RequestException HandlingArchitectural LevelDependable SoftwareClient ComponentThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

On Architecting Software Fault Tolerance using Abstractions

Architectures based on Coordinated Atomic action (CA action) concepts have been used to build concurrent fault-tolerant systems. This conceptual model combines concurrent exception handling with action nesting to provide a general mechanism for both enclosing interactions among system components and coordinating forward error recovery measures. This paper proposes an architectural model to guide the formal specification of concurrent fault-tolerant systems. This architecture provides built-in CSP (Communicating Sequential Process) processes and predefined channels to coordinate exception handling of the user-defined components. As a result, a formal and general architecture supporting software fault-tolerance are ready to be used.

The feasibility test of a hard real time system must not only take into account the temporal behavior of the application tasks but also the behavior of the run-time support in charge of executing applications. The paper is devoted to the schedulability analysis of a run-time support for distributed dependable hard real time applications. In contrast to previous works that consider rather simple run-time supports (e.g. a real time kernel made of a simple tick scheduler and an unreliable communication protocol), our work deals with a complex run-time support with fault tolerance capabilities and made of multiple tasks that invoke each other.

Abstract— Mishandling of exceptional conditions is ranked as 10 in the OWASP Top 10 list in 2025, consisting of 24 sub-vulnerabilities. Web applications fail to predict, identify, and react to an unusual behavior of an application, revealing sensitive information in the form of a stack trace or error handling. Which is prone to security vulnerabilities like server crashes, outages, and sometimes a DDOS attack. Since these vulnerabilities expose sensitive information for attackers in gaining attacked system information, when exploited, this may cause serious reputational damage to the organization. In this research paper we will be talking about real-time test cases and possible mitigation methodologies. We will discuss possible remediation techniques that can be adopted by the developers when developing the product. Index Terms—OWASP, error handling, exception handling, web application vulnerability, vulnerability exception

New services based on the best-effort paradigm could complement the current deterministic services of an electronic financial exchange. Four crucial aspects of such systems would benefit from a hybrid stance: proper use of processing resources, bandwidth management, fault tolerance, and exception handling. We argue that a more refined view on Quality-of-Service control for exchange systems, in which the principal ambition of upholding a fair and orderly marketplace is left uncompromised, would benefit all interested parties.

Mobile agent systems often require sophisticated cooperation and coordination during error detection and recovery. In this paper we propose novel fault tolerance mechanisms that support co-operative exception handling in such systems. The paper demonstrates how mechanisms like these can be formally developed and analysed. We start with identifying the typical modes of failures in agents and analysing possible failure and recovery scenarios in mobile systems. Stepwise refinement is used as our formal framework for top-down development and verification. Using the framework we formally verify the essential model properties, such as interoperability, local and global state consistency and termination of error recovery. Our approach provides developers with formal generic patterns for incorporating fault-tolerance mechanisms into mobile agent systems. We also demonstrate how the results of our formal development can be instantiated and reused in developing real-world agent software.

Approximate Computing techniques have been successfully used to reduce the overhead associated with redundancy in fault-tolerant system designs. This paper presents a fault tolerance method to reduce the execution time overhead of the well-known Time Redundancy technique by means of an improvement proposed for the Approximate Computing software-based technique known as loop perforation. Time Redundancy is a software-based fault tolerance technique that involves executing replicas of a task at different times. We propose to approximate the tasks to be executed using a new approximate computing technique based on loop perforation, i.e., simplified iterations. The novelty of this method is the combined use of the fault tolerance technique, temporal redundancy, jointly with the new proposed Approximate Computing technique, simplified iterations. The proposal is validated through simulation-based fault injection campaigns on several test programs for the ARM and RISC-V microprocessor architectures. Experimental results verified not only the applicability of the proposal in different architectures, but also its effectiveness, showing a good trade-off between reliability, error and overhead. Results showed that using the proposed method, a normalized mean work to failure (MWTF) up to 5.28× was obtained with approximation errors lower than those obtained using the traditional loop perforation technique.

Web applications have been developed from a simple static information webpage to a more complex web application, supporting complex processes and transactional workflows. The existing of numerous modeling concepts and design features in web applications, thus raises new issues on modeling approach. In this paper, we present and discuss the uses of user interaction diagram, object-oriented approach and Unified Modeling Language (UML) notation for complex web applications. Our main objective is to propose a web application design model which is based on UML 2.0 profile and stereotypes. We propose user interaction diagram to capture users' information from use case diagram and specific UML modeling elements to model conceptual, navigational and user interface features of complex web applications. The uniqueness of our proposed design model stands in the design patterns modeling approaches. At the end of the paper, some future enhancements of the design model will be explained and briefly summarized.

With off-the-shelf software, software fault tolerance is almost the only means available for assuring better dependability than the off-the-shelf software offers, without the much higher costs of bespoke development or extra V&V. We report our experience with an experimental setup we have developed with off-the-shelf SQL database servers. First, we describe the use of a protective wrapper to mask the effects of a bug in one of the servers, without depending on an adequate fix from the vendors. We then discuss how to combine the diverse off-the-shelf servers into a diverse modular redundant configuration (N-version software or N-self-checking software). A wrapper guarantees the consistency between the diverse replicas of the database, serving multiple clients, by restricting the concurrency between the client transactions We thus show that diverse modular redundancy with protective wrapping is a viable way of achieving fault-tolerance with even complex off-the-shelf components, like database servers.KeywordsClient ApplicationSnapshot IsolationSoftware Fault ToleranceServer ThreadRead TransactionThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.