Self-Healing Software System Using Emulator-Based Vaccine
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current methods for handling software failures, such as proactive approaches and fault-tolerance schemes, often result in reduced system performance, user interaction issues, and inability to maintain high availability, especially in environments like e-commerce web servers, due to their reliance on user intervention and resource-intensive solutions.
Innovation Solution
A self-healing system that automatically detects and repairs software failures by emulating and updating application code using sensors and an emulator-based vaccine, allowing for immediate recovery from faults without user intervention and minimizing performance impact.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If proactive approaches and fault-tolerance schemes are used to make code dependable, then software reliability is improved, but system performance deteriorates and user interaction becomes monotonous
Solution Approach 1:
The system implements automatic self-healing capabilities where the application monitors itself for faults and automatically recovers without user intervention. The fault detection mechanism continuously checks for errors, and when faults are detected, the system automatically initiates recovery procedures including state restoration and thread management, eliminating the need for manual user actions while maintaining high performance
Solution Approach 2:
The system performs preliminary actions by maintaining backup state information and pre-configured recovery mechanisms before faults occur. When a fault is detected, the system can immediately restore from saved state without requiring user intervention, thus improving reliability without impacting ongoing system performance
2Reliability
If fault-tolerance schemes with voting among service instances are implemented, then software reliability is improved, but device complexity increases
Solution Approach 1:
The system extracts the complexity of fault tolerance from the application logic and implements it as a separate monitoring and recovery mechanism. Instead of requiring multiple service instances with voting logic embedded in the application, the system uses a dedicated fault detection and recovery layer that operates independently, simplifying the overall system architecture while maintaining reliability
3Reliability
If server applications are restarted to recover from faults, then software reliability is improved, but service availability deteriorates
Solution Approach 1:
The system segments the recovery process by maintaining separate state information for different components and threads of the server application. When a fault is detected in a specific component, only that component's state is restored while other components continue operating, allowing partial recovery without complete server restart and thus maintaining service availability
Solution Approach 2:
The system implements dynamic recovery where the application can adjust its operation mode based on detected faults. Instead of static restart procedures, the system dynamically modifies thread execution, state restoration, and resource allocation in real-time based on the nature and location of faults, enabling continuous service operation while recovering from errors
4Reliability
If antivirus programs are installed on mobile platforms to protect applications, then software reliability is improved, but device complexity increases and system performance deteriorates
Solution Approach 1:
The system merges the fault detection and protection functionality directly into the application runtime environment rather than using separate antivirus programs. The monitoring mechanisms are integrated at the operating system and application levels, combining security, reliability, and performance monitoring into a unified system that does not require additional standalone software
Data Source
AI summary
In accordance with the present invention, computer implemented methods and systems are provided that allow an application to automatically recover from software failures and attacks. Using one or more sensors, failures may be detected in the application. In response to detecting the failure, the portion of the application's code that caused the failure is isolated. Using the input vectors that caused the failure, information regarding the failure (e.g., the type of failure), a core dump file (e.g., stack trace), etc., an emulator-based vaccine that repairs the failure is constructed. In response to verifying that the vaccine repaired the failure, the application is automatically updated with the emulator-based vaccine without user intervention. Application community features that efficiently use the resources available in software monoculture is also provided. An application community may be defined that includes a plurality of devices and the application's code may be divided into smaller portions of code, which are assigned to each of the plurality of devices for monitoring. Each device also notifies the other devices of the failure.