Site News  |   Monitor Keywords  |   Monitor Archive  |   Organizer  |   Account Info  |

Managing client-server requests/responses for failover memory managment in high-availability systems

Managing client-server requests/responses for failover memory managment in high-availability systems description/claims

1. Technical Field

The present invention relates generally to service request handling that facilitates efficient memory management in high availability client-server systems. In particular, the present invention relates to a method and system for utilizing a centrally accessible object pool in conjunction with exception condition objects to handle service requests in a manner reducing or eliminating memory leak that might otherwise occur incident to high-availability server failover.

2. Description of the Related Art

Client-server is a network architecture that separates requester or master side (i.e. client side) functionality from a service or slave side (i.e. server side functionality). A client application often includes a graphical user interface, such as provided by a web browser, which enables a user to enter service requests to be sent to and processed by a server application. Specific types of servers include web-page servers, file servers, terminal servers, and mail servers.

Client-server systems requiring highly reliable uninterrupted operability may be implemented as so-called high availability systems. High availability (HA) is a system design protocol and associated implementation that ensures a desired level of operational continuity during a certain measurement period. Such systems often utilize HA clusters to improve the availability of services from the server side. Generally, HA cluster implementations build logical and hardware redundancy, including multiple network connections and complex, multi-connected data storage networks, into a cluster to eliminate single points of failure. The key feature of HA clusters is to utilize redundant computers or nodes to maintain service when system components fail. Absent such redundancy, when a server running a particular application fails, the application may be unavailable until the failed server is fixed and brought back online. HA clustering addresses server node failure by autonomically starting the failing node application on another system in response to detected hardware/software faults. For example, high availability cluster redundancy can be achieved by detecting node or daemon failures and reconfiguring the system appropriately, so that the workload can be assumed by standby or backup cluster nodes. High availability clustering is essential for many modern organizations and institutions, especially those involved in industries having strict compliance and regulatory requirements.

The process of reconfiguring HA cluster servers responsive to a failure is known as a failover condition and may require the clustering software to appropriately configure the backup node before starting the application. For example, appropriate file systems may need to be imported and mounted, network hardware may need to be configured, and some supporting applications may need to be running as well.

In addition to an actual server failure, HA systems are susceptible to memory management problems arising from “soft” failures such as an unsuccessful request processing attempt caused by lack of present server capacity or an incompatible service role of a given server to handle a given request. For example, in a database cluster or object cache cluster, one server is typically configured as a master data server and the other servers are configured as replicas. In such a configuration, data updates are typically handled only by the master data server to maintain data integrity. Requests requiring read-only processing can be processed by either the master data server or replicas. However, if a request requiring an update or write operation is sent to a replica server, the request must be forwarded to the master data server.

Soft failures such as those caused by server overload or incompatible configuration arise more frequently than hard server failures and are difficult to directly manage or prevent due to extremely high traffic volumes and the sometimes shifting configurations and roles of clustered servers. For example, when a server is overloaded (i.e., has received more requests than it can presently process), the excess requests may proceed to a failure sequence or may be stored and retried at later time. Another alternative in the case of either server overload or incompatible server configuration is to forward the presently non-serviceable requests to peer servers having sufficient available capacity.

Request forwarding, retrying, or failures may result in memory management problems as uncleaned and/or non-deallocated request objects and associated objects may consume excessive memory resources, leaving servers to fail or operate at subpar levels. E-business and e-commercial server applications handle millions of transactions per hour, with each transaction comprising an associated request object, response object, and associated other objects. Responsive to hard and/or soft failures often requiring the request to be retried and/or forwarded, each request may traverse and be cached by multiple servers before a successful transaction response is achieved. Under such circumstances, memory leak may cause excessive memory consumption. Ideally, HA servers should maintain steady and stable memory usage over an extended period of time such as years. However, most servers cannot do so in reality and almost all enterprises schedule shutdown and re-start intervals to clean memory at regular intervals.

An important aspect of high availability systems relates to handling of client-server requests and responses, particularly for requests and responses interrupted by a hard or soft failure. Client-server requests/responses are substantial data units, carrying both instructions and data and may be reused in a high availability client-server system. Any given request/response may be reused by different clients or the original requesting client in different stages of client-server interactions to increase both client and server side performance. A given request may not be successfully processed by the original receiving server and may therefore need to be retried at the same server or forwarded to other servers for handling. Such request retries and forwarding results in cached request/response data across possibly multiple nodes which becomes a significant source of memory consumption given that typical servers receive requests at a rate of millions per hour.

A particularly problematic circumstance arises when hard or soft a failure occurs on a server having a large number of cached request/response data items. Under such circumstances, memory leak is likely to occur when the failure protocol requires the original requesting clients to resubmit the requests that were originally sent to the failed server. For reasons of operating efficiency during normal (i.e. non-failover) runtime conditions, memory management mechanisms do not adequately track memory that has been allocated to stalled service requests (i.e. requests required to be retried or forwarded) and which are subsequently misallocated due to a failover and client re-sending of the original request. The likelihood of memory leak is particularly high under circumstances that interfere with standard memory management such as when routing tables change or the server malfunctions. The substantial amount of memory allocated to the cached request/responses is often not automatically reallocated, resulting in substantial memory degradation of the server as well as client nodes in a HA system over time.

It can therefore be appreciated that a need exists for a method, system, and computer program product for managing client request handled by HA server systems in a manner that minimizes memory leak. The present invention addresses this and other needs unresolved by the prior art.

A system, method and computer-readable medium for managing service request exception conditions in a computer system that services client requests are disclosed herein. In one embodiment, an original client request is received by a server. The client request and responses to the request are generated using fuzzy logic selection from a request/response object pool. A fuzzy logic module is utilized for selecting the request object by correlating the original client request with multiple pre-stored request objects. In response to an exception condition occurring incident to processing the client request, an exception response object is generated containing the original client request and further including an exception object identifying the exception condition. In the case of a retry exception condition, the exception response object includes the client request and a RetryException object. In the case of a forward exception condition, the exception response includes the client request, a ForwardException object, and routing data.

The above as well as additional objects, features, and advantages of the present invention will become apparent in the following detailed written description.

The novel features believed characteristic of the invention are set forth in the appended claims. The invention itself however, as well as a preferred mode of use, further objects and advantages thereof, will best be understood by reference to the following detailed description of an illustrative embodiment when read in conjunction with the accompanying drawings, wherein:

FIG. 1 is a high-level block diagram illustrating a high availability system adapted to control memory leak incident to high availability server failover in accordance with the invention;

FIG. 2 is a block diagram depicting a data processing system that may be implemented as a server in accordance with a preferred embodiment of the present invention;

• Provisional Patent
• Utility Patent

• What Is a Patent?
• What Is a Trademark or Servicemark?
• What Is a Copyright?
• Patent Laws