Jade

JADE

Today’s computing environments are becoming increasingly sophisticated. They involve numerous complex software that cooperate in potentially large scale distributed environments. These software are developed with very heterogeneous programming models and their configuration facilities are generally proprietary. Therefore, the administration of these software (installation, configuration, tuning, repair, …) is a much complex task which consumes a lot of resources:

• human resources as administrators have to react to events (such as failures) and have to reconfigure (repair) complex applications,
• hardware resources which are often reserved (and overbooked) to anticipate load peaks or failures.

A very promising approach to the above issue is to implement administration as an autonomic software. Such a software can be used to deploy and configure applications in a distributed environment. It can also monitor the environment and react to events such as failures or overloads and reconfigure applications accordingly and autonomously. The main advantages of this approach are:

• Providing a high-level support for deploying and configuring applications reduces errors and administrator’s efforts.
• Autonomic administration allows the required reconfigurations to be performed without human intervention, thus saving administrator’s time.
• Autonomic administration is a means to save hardware resources as resources can be allocated only when required (dynamically upon failure or load peak) instead of pre-allocated.

Jade is a framework for the development of autonomic administration software. It relies on the following key design choices:

• The administrated environment is modelized as a component-based software architecture which provides means to configure and reconfigure the environment. The same model is used for developing the administration software itself, thus enabling self-administration.
• A system representation provides a consistent and reliable view (snapshot) of the whole administrated system.
• Control loops link probes to reconfiguration services and implement autonomic behaviors.

Jade has been initially used for the administration of clustered J2EE applications. These applications rely on very complex software (e.g. Apache, Tomcat, Jonas, Mysql) and their deployment and administration was greatly facilitated by the use of the prototype.

Applying Jade to DIET

DIET is a middleware environment which aims at balancing computation load in a large-scale grid infrastructure. It is built on top of different tools which are able to locate an appropriate server depending on the client requested function, the data location (which can be anywhere on the system, because of previous computations) and the dynamic performance characteristics of the system. The aim of DIET is to provide transparent access to a pool of computational servers at a very large scale. DIET mainly relies on the following components:

• Client is an application which uses DIET to solve problems.
• Master Agents (MA) receive computation requests from clients. Then a MA chooses the best server and returns its reference to the client. The client then sends the computation request to that server.
• Local Agents (LA) aim at transmitting monitoring information between servers and MAs. LAs don’t take scheduling decision, but allow preventing MAs overloads when dealing with large-scale infrastructures.
• Server Daemons (SeD) encapsulate computational servers (processors or clusters). A SeD declares the problems it can solve to its parent LA and provides an interface to clients for submitting their requests. A SeD can give performance prediction for a given problem with FAST which is a dynamic performance forecasting tool.

The DIET middleware represents an interesting example for the Jade autonomic management environment, since it brings together many of the challenges addressed by Jade:

• the management of a distributed organization of legacy software (MA, LA and SeD).
• distributed configuration, since DIET requires the configuration of these software (through a set of configuration files) to implement a consistent hierarchical structure.
• self-repair: due to several reasons (hardware or software), a server may stop functioning. The goal is to detect the failure and repair it automatically.

This work was done in February 2012. Questions about Jade can be directed to Daniel Hagimont