Despite the spread of web and distributed object technology, enterprise applications remain hard to build. Corba and other distributed-object based solutions require heavyweight investments of software on the desktop, and a fair amount of investment in the glue software. Web and e-mail are lightweight and pervasive, but currently used for document transport , not distributed computing. The goal in eGents is to adapt these transports to support distributed computations (specifically distributed agent computations), thus providing an agent platform that is useful, lightweight and leverages currently deployed technologies. In particular, eGents borrows the notion of agent communication languages as a messaging language from the agent world, and integrates it with email as a computational transport, XML as the enterprise EDI language, and java as the computational engine at the desktops.
To test our ideas, we are focusing on applications which benefit from
eGents leverage of the vast and pervasive email infrastructure, especially
those needing support for asynchronous and disconnected operations, message
queueing, firewall permeability, filtering, logging, and security.
The eGents framework is comprised of two types of agents: platform agents and task agents. Task agents are distributed java components that are wrapped using an agent wrapper framework so as to send, receive and respond to ACL messages. As their name indicates, they perform a particular task on a specific machine. Platform agents manage task agents, and mediate access to them. Task agents on a single machine are controlled by a per-machine platform agent which launches and terminates task agents (the task agents being threads executing as part of the platform agent process). Agent applications consist of communicating task agents that are dispersed across different machines (perhaps different administrative domains) across the WAN.
eGent task agents dispersed across a WAN communicate via a bi-level ACL bus using an email-based ACL bus between platform agents, and the JavaBeans protocol between a platform agent and a task agent, or two colocated task agents. ACL messages are addressed to a named task agent belonging to a specific platform agent, and each platform agent has a unique email address. The eGents framework converts the ACL performative into an XML document and emails it to the destination platform agent. The destination platform agent parses the XML ACL message into a java object, and forwards it to the local task agent using JavaBeans as a messaging protocol. Javabeans supports the observer design pattern whereby objects can subscribe to change events on other objects. Task agents use this to subscribe to changes in an ACL-mailbox object into which the platform agent stuffs incoming ACL messages.
The eGents ACL bus reuses standard Java, XML and email technology to build an ACL bus that has previously required proprietary KQML/FIPA ACL parsers and proprietary TCP/IP based transports. The use of XML as the EDI transport makes use of widely available XML parsers to parse the content at the receiving end, avoiding the engineering problems reported in some ACL-based agent efforts. JavaBeans provides similar benefits within a single machine.
The agent wrapper framework uses a simple microscripting language to map ACL messages into sequences of method invocations on the java component that implements the agent. One microscript statement corresponds to one task agent and one kind of performative. Blocks of microscript statements collectively specify how a particular agent type would respond to all ACL performatives that it handles. A per-machine agentmap file maintains the microscripts for all task agent types that are supported by a platform agent. The microscripting language emphasizes simplicity and minimality over full function workflow capabilities. As we gain experience with component wrapping, we will add to the language or consider integrating with other workflow specification mechanisms.
Agent wrappers use Java's dynamic class loading and reflection capabilities to execute the performative implementation based on a microscript specification. The microscript interpreter parses the microscript, dynamically loads the associated java class object, and uses reflection to dynamically compose the method invocation string and to execute methods on this class object. Script-based wrappers offer the potential advantage that agent implementations can be dynamically changed in a running agent computation.
* Venu Vasudevan now works for Motorola Labs.
This research is sponsored by the Defense Advanced Research Projects
Agency and managed by Rome Laboratory under contract F30602-96-C-0330.
The views and conclusions contained in this document are those of the authors
and should not be interpreted as necessarily representing the official
policies, either expressed or implied of the Defense Advanced Research
Projects Agency, Rome Laboratory, or the United States Government.