Beyond Java: Merging Corba-based Mobile Agents and WWW

Authors: Fritz Hohl, Joachim Baumann, Markus Straßer
Affiliation: The authors are members of the research staff of the IPVR (Institute of Parallel and Distributed High-Performance Systems) of the University of Stuttgart, Germany. They are part of the Mole project, which deals with research in the Mobile Agent area and with the construction of an object-oriented Mobile Agent system with the same name, which uses Java as one agent language.
Contact author:

The W3 is a very popular and still rapidly growing information system, but there are areas which are unsuitable to the current web techniques. "Mobile code" approaches like Java or the "interacting distributed objects" model of CORBA try to solve some of the disadvantages of the existing web, but they either lack a more general interaction and communication model (e.g. Java) or the possibilities to transfer code and the right distribution granularity (e.g. CORBA).

An approach that provides both mobile code and interacting objects (or object clusters) is the object-oriented Mobile Agent model. A Mobile Agent is a special object that has a data state (other non-agent-objects), a code state (the classes of the agent and the other referenced objects) and an execution state (the control threads running in the agent). A Mobile Agent is active because it may follow a program, mobile because it may migrate from host to host, and autonomous because it doesn't need to consult a human or non-human supervisor (it may if it wants of course).

A Mobile Agent is executed in a secure manner (because nobody wants to host e.g. "worms") by an agent server. Agent servers are mainly runtime environments for the agent languages, and Mobile Agents can't execute without them. Two important components of an agent system are traders and accounting mechanisms. Traders may return a list with agent addresses according to a service specification given in a request. Accounting mechanisms allow the system to stop agents that have exceeded their resources or to give more resources to agents that provide services deemed useful to the system or other agents. As in Java, Agent languages don't consist of only normal language elements like control structures and variables, but also platform independent GUI elements. These elements allow an application to work on every supported platform on one hand and without the restrictions of a limited presentation model like HTML on the other hand.

The agent servers communicate with each other via normal CORBA interaction (i.e. RPCs), they may support different object-oriented languages (due to the availability of CORBA IDLs for different languages) and they use some of the CORBA services e.g. externalization, persistence (for fail-safe execution), database access etc., thus putting a layer on top of CORBA that knows how to migrate agents, how to execute programs safely and so on.

A scenario for the use of Mobile Agents for WWW would consist of agent servers at web servers and clients. Some of the immediate benefits of this technology would be:

clients may send agents to web servers

this may be used for web search engines which could work in parallel (at the same time on every server in the system!) and with less communication costs because the search engines don't need to transmit every document from a server but the processed result which may be smaller.

secure CGI scripts using Mobile Agents

executing CGI scripts at the server poses severe security problems because they run under the account and with the access rights of a user. Mobile Agents, on the contrary, are executed in an environment that is able to exercise absolute control over foreign programs.

secure client-side programs

a subset of the proposed functionality is provided by the so-called "applets" in HotJava and the Netscape WWW-Browser. But the proposed programs are, in contrary to applets, addressable from other agents, and may, as first-class objects in agent terms, address other agents.

active objects whose lifetime is not restricted (e.g. by viewing a page)

this implies that, apart from the possibility of permanent addition of functionality at the client's side, e.g. an agent may have permanent state which helps the user the next time he uses this application.

asynchronous net interaction

as agents are autonomous, they can fullfil their orders without the user having run a client program permanently, but to migrate (e.g. for getting a file) to a target and return when the aim is reached. This is a basis for what we think will come after the Worldwide Web, the so-called network centric computing

Apart from the impacts on existing web technology, the mobile agent model may make the client-server approach redundant, because Mobile Agents systems implement not only client-server, but also peer-to-peer interaction, combined with asynchronous execution.
This may result in a system

without separate web servers

as every user who has access to an agent system can offer www documents

with global load balancing

as an active web document may (technically) replicate itself and migrate to areas from where it's loaded repeatedly

with support for Electronic Commerce

as the accounting mechanisms, the peer character of every agent system and the uniformity of the agent services constitute a good framework for these services which may be even commercial if a commonly used electronic money mechanism exists. This provides support for even small electronic services offered by every web user