Management by Delegation permits downloading management functionality to managed systems at runtime. Its major advantage lies in the fact that managed systems need not store extensive management functionality in advance but can be provided with functionality only on demand. The corresponding agents are therefore quite small. Using the paradigm of distributed objects, management by delegation is feasible between any kind of object; it is therefore possible that agents cooperate without the participation of the managing system.
A typical problem domain where the use of inter-agent cooperation seems promising is fault management. The following example shows the use of this concept: In many cases, applications do not work properly because of errors in an underlying layer. To avoid network traffic caused by the exchange of data between a managing and a managed system, it is desirable to run detailed diagnostic and error correlation routines already on the system where the error occurred: Upon detection of a fault in an application, the agent in charge of the application may request the testing of the underlying communication system from another agent managing these parts of the system. The agent then has to perform a lookup to determine which testing services are available in the CORBA environment; this is done by querying the interface repository. Having obtained information about the interfaces of an object containing adequate functionality, a call to this object is issued through the DII requesting the delivery of the desired error detection services. These are then sent via the ORB to the agent and executed.
Further error detection, error correlation and even troubleshooting functionality may be downloaded to the requesting agent in the same way. A large part of the management tasks is therefore performed already on the managed system. The managing system shall then be provided with a summary of the results and can, if necessary, perform some additional actions.
For implementing Management by Delegation, it is crucial to by-pass the CORBA restriction of not allowing objects to be copied by value between different systems. The main idea of the work-around lies in the fact that a CORBA client is able to pass parameters in calling a method of a server object. Therefore, if it is feasible to insert an object as a parameter to a remote method call, its reference is marshaled and converted to a proxy object at the agent's side. After this has happened, the methods of the delegated object can be accessed by the agent.
The remaining question is how objects can be flattened into a data stream in memory. This can be accomplished by using the CORBA Externalization Service, whose purpose is to enable the internal state of an object to be obtained in an external representation. [11] states that "objects which support the appropriate interfaces and (...) can be externalized to a stream (in memory, on a disk file, across the network, etc.) and subsequently be internalized into a new object in the same or a different process". Apart from the Externalization Service, there is an alternate way to transfer objects in ORB environments by using either the move or the copy operation from the Object LifeCycle Service. The main difference between these services is that the Externalization Service breaks the task of copying an object into two parts and is therefore more flexible than the copy operation of the LifeCycle service: First, the data is flattened into a stream by calling the externalize_to_stream operation on the target object. After the stream object has been transferred across the ORB, a new object is built from it by invoking the internalize_from_stream method of the stream object. The main advantage of splitting the copy operation in two parts is that using this feature, any object can be exported and imported from the ORB to other systems and vice-versa.
The conclusion to be drawn is that it is possible to implement Management by Delegation in CORBA-based environments. Following this concept, one can combine the advantages of both the service-based and the management-by-delegation approach: While CORBA assures the availability of uniform service interfaces and transparent access to their functionality, scripting languages as Java guarantee portability of the service implementations. As OMG is going to standardize an IDL/Java language mapping in 1996, it will be possible to implement delegatable distributed management services in a portable, object-oriented interpreted language.