Asynchronous Service Request Handling via Event Handlers
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Synchronous service models face performance issues due to maintaining persistent connections and threads, which limit concurrent operations and introduce single points of failure.
Innovation Solution
Implementing asynchronous handling of service requests by selecting independent event handlers for processing requests and outputs, allowing for termination of event handlers before receiving results and reducing reliance on persistent threads.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If a synchronous service model is used with persistent connections and threads, then request-response reliability is maintained, but service performance and concurrency are degraded
Solution Approach 1:
The patent segments the request-response process into independent event handlers that can be selected and executed independently. Instead of a single persistent thread handling the entire request-response cycle, the service breaks down processing into discrete events that can be handled by different event handlers, allowing for better resource utilization and concurrency while maintaining reliability through independent error handling for each segment.
Solution Approach 2:
The patent introduces an event handler selection mechanism as an intermediary between the request receiver and the processing logic. This mediator selects appropriate event handlers from a pool based on the specific request, allowing the system to maintain persistent connections without requiring persistent threads for each request, thereby improving performance while preserving reliability through the intermediary's coordination.
2Loss of time
If persistent threads are maintained throughout the request-response cycle, then request processing continuity is ensured, but processing cycle time is increased
Solution Approach 1:
The patent implements dynamic event handler selection where the system transitions from static persistent threads to dynamic event handler allocation. Event handlers are selected based on current system state and request characteristics, allowing the processing continuity to be maintained through dynamic reassignment rather than static persistence, thereby reducing processing cycle time while preserving operational continuity.
Solution Approach 2:
The patent performs preliminary action by pre-defining multiple event handlers that can be selected based on request characteristics. Instead of waiting for a persistent thread to become available, the system has event handlers ready in advance that can be immediately assigned to handle requests, reducing waiting time while ensuring continuity through the pre-prepared handler pool.
3Productivity
If persistent connections are maintained for the duration of the request-response cycle, then connection stability is improved, but concurrent operations are limited
Solution Approach 1:
The patent implements universal event handlers that can handle multiple types of requests and events through a single connection. Instead of requiring separate persistent connections for each operation, the system uses multi-functional event handlers that can process various request types through the same stable connection, thereby increasing concurrent operations capability while maintaining connection stability through the universal handler's ability to manage multiple functions.
4Reliability
If a single persistent thread handles requests, then thread management is simplified, but system reliability is reduced due to single point of failure
Solution Approach 1:
The patent applies local quality by making each event handler independent and self-contained with its own error handling and processing logic. Instead of a single thread where failure propagates system-wide, each event handler has localized error handling capabilities, so that failures are contained to individual handlers rather than affecting the entire system. This increases reliability through fault isolation while managing complexity through standardized local error handling patterns.
Data Source
AI summary
Techniques for asynchronous handling of service requests are disclosed. A service receives a request from a requesting entity. The request includes a function identifier and function input. Responsive to receiving the message, the service selects a first event handler to process the request. The service translates, via the first event handler, the function identifier to a native function call. The service initiates execution of the native function call using the function input, and receives output corresponding to the execution of the native function call. Responsive to receiving the output, the service selects a second event handler to process the output. The service generates, at least in part by the second event handler, a response based on the output. The service transmits the response to the requesting entity.