We are developing frameworks for the construction of autonomic systems , following an architecture-based approach. One such framework, called Jade, is targeted towards autonomic management of complex systems including legacy software. An example of such system is a set of J2EE servers deployed on a cluster of nodes, each tier of the system being replicated for better performance and availability.

To be administered by Jade, a system must first be organized as a collection of interconnected components, each of which wraps the underlying legacy code (e.g., a Tomcat server, a JOnAS server, etc.) within an envelope that provides a standard management interface. This interface, which includes such functions as lifecycle management, binding management, composition management, is used in turn by the actuators of the control loops that implement the various autonomic functions.

The Jade framework is organized in three main parts:

• A set of  autonomic managers, each of which implements a control loop for a specific function, as described in the autonomic computing presentation.
• A set of common services, which provide various functions needed for the construction of the autonomic managers.
• The managed system, in the form of a set of  interconnected components, wrapped as explained above to provide a uniform management interface.

The common services provide the following functions:

• Maintaining a representation of the managed system. This is the knowledge base needed by the autonomic managers to fulfil their function. This representation is derived from a description of the structural organization of the managed system.
• Discovering available nodes in the cluster.
  
• Allocating a node, and installing a set of components on that node.
• Deploying a system on a set of nodes, using the above services (see a more detailed description of the deployment service).

The knowledge that Jade maintains about the managed system includes the following information:

• The system's composition, i.e., a description of its elements, including the underlying infrastructure (i.e., the nodes of a cluster and their operating systems, etc.). This also includes the list of failed nodes or software modules.
  
• The system's architecture, i.e., the mutual bindings of these elements (e.g., interconnections between components, placement of software components on the nodes).
• The system's current execution state (e.g., whether a node or component is active, stopped, etc.).
  

The Jade framework ensures that the system representation, which encapsulates this knowledge, is causally connected to the actual system. Any change to the representation is reflected to the system, and vice versa. More details on the system description may be found here. 

 

The management interface allows the following actions to be performed on the managed system (be it an individual component or the whole system):

• Configure the component, i.e., assign a value to each of its attributes. 
• Manage the component's lifecycle (e.g., start, suspend, stop).
• Inspect the component's properties.
• For a composite component (a component that includes other components), manage its contents, e.g., by adding or removing a subcomponent or by changing subcomponents' bindings.
  

Note that the notion of a composite component allows a complex sequence of actions to be performed by a single operation, e.g., recursively stopping all the components of an application, or configuring all or part of the nodes of a cluster. 

 

More details on Jade may be found in this paper.

Sara Bouchenak, Noël De Palma, Daniel Hagimont, and Christophe Taton. Autonomic management of clustered applications. In IEEE International Conference on Cluster Computing, Barcelona, Spain, September 2006.

 

See also the results of some experiments in self-management using Jade: self-optimization, self-repair, self-protection