|
What is the Model for Self-Managing Java Servers?
The Model for Self-Managing Java™ Servers is intended to be a working model of a non-stopping, Java-based server (which could be a Web server, application server, etc.). The server has the self-configuration and self-healing aspects of an autonomic computing, self-managed server.
Autonomic Computing (AC) systems are capable of managing themselves to fit the new environment. Four main aspects of self-managed systems are self-configuration, self-healing, self-optimization, and self-protection.
Normally, whenever an abnormal event happens in any Java server during a transaction, the server logs the exception or error and aborts the current transaction. The server isn't capable of dynamically managing the problems and proceeding to handle new transactions. Human intervention is an unavoidable scenario here. Unless the problem is analyzed and fixed by the administrator, the system behaves the same way for repetitive occurrences of the problem. This approach involves some time, which might be very costly for critical businesses. Human intervention always has some room for errors. Today, the aim is to provide an automated solution as much as possible. Implementing servers using the suggested method addresses this issue.
How does it work?
The suggested way of converting a Java-based server into a non-stop server (like the downloadable demonstration here) consists of taking a few corrective steps inbetween the normal flow. These steps are as follows:
- The server throws an exception or error and logs it.
- A self-healing module of the proposed autonomic computing system gathers the exception information by parsing the log file.
- An analyzer module analyzes the cause and decides the necessary action to be taken using the predefined policies.
- The healing module takes the appropriate action.
The Self-Managing Java Server model has the following components: Analyzers, PolicyManager, HealingManager, Healers, and Policies.
Per autonomic computing architecture, implementation of self-managing attributes involves an intelligent control loop. This loop collects information from the system, makes decisions, then adjusts the system as necessary. The control loops can be organized into two major elements:
- Managed element (what the autonomic manager is controlling)
- Autonomic manager (a component that implements a particular control loop).
Analyzer, PolicyManager, HealingManager, and the Healers together constitute the Autonomic Manager. Policies in a file are the Knowledge base. Any Java server is the Managed Element that is being managed by the Autonomic Manager.
Analyzer monitors the log file for any exceptions, analyzes the exception using the Policies (Knowledge), then delegates the exception to the HealingManager for planning. The HealingManager gets the input from PolicyManager, and decides which Healer to call to take corrective action for the problem. The delagated Healer executes the corrective action for the problem.
The Self-Managing Java Server model will normally work using the following steps:
- Analyzer is configured to poll a target medium for exceptions or errors. Once an exception or error occurs, it analyzes the cause and intimates it to the HealingManager.
- From the information it got from the Analyzer, the HealingManager uses the PolicyManager to decide which Healer to delegate the problem to.
- Once the control is delegated to a particular Healer, it gets the rules from the PolicyManager and fixes the problem.
- The entire process is logged into a file for reference.
Further information is available in a paper at developerWorks®.
|
