xml-dev - new project: Persistent and mobile agents on an extensible P2P network

[Bill la Forge <b.laforge@jxml.com>]

This is an open invitation to participate in the design and development of QARE, a new project on SourceForge:

    https://sourceforge.net/forum/forum.php?forum_id=36458

The proposal here is to create a Java Servlet to act as an Agent Platform for processing XML Posts. Quick (see the jxquick project)
would be used to transform XML into Object trees, where those trees are themselves agents which operate within the context of the
QARE servlet.

Code is transfered as "plugins", where each plugin contains a QJML binding schema. These binding schema define the mapping between
an XML markup language and the classes included in the plugin. However, plugins are the exceptions that are installed only when a
new service is to be supported.

Some preliminary work has been done as part of a reciently completed SBIR project--see
http://www.jxml.com/sbir1/SBIR_99.2-42_Gold.html However, the design developed here will be from scratch, except to draw on the
jxquick project.


      Proposed functionality for QARE:

      1. Plugins
      2. Extensible P2P
      3. Persistent and Mobile Agents
      4. Debugging


      1. Plugins

      QARE provides a basic framework, with plugins providing a QJML binding schema, and the Java classes. XML posts are converted
to agents using the plugin identified in the file portion of the URL which invokes the QARE servlet.

      Plugins are just a set of .jar files in a directory. The name of each jar file contains (1) a schema name, (2) a schema
version number, and (3) an implementation name. Mapping XML posts to plugins is done using the schema name and version number, but
not the implementation name, allowing multiple implementations to be used with each schema.


      2. P2P

      P2P (Peer-to-peer) looks quite attractive, if its done carefully so that it doesn't overburden either the network or the
clients/peers. Building an extensible P2P system looks even better.

      Lets say all the clients in a given P2P network provide a minimum functionality--the means to identify all other clients which
have various identifying characteristics. And lets say that the use of a plugin marks a client as supporting the associated schema.
This then allows us to create virtual P2P subnets which support various schema for document exchange.


      3. Persistent and Mobile Agents

      An XML post may simply be a request for service, where the agent created from the post performs the desired service--think of
this capability as a alternative to SOAP that adds tremendous flexibility.

      But lets add a means of registering an agent. Now other agents can find and interact with the registered agent.

      Next, lets provide a snapshot and restart capability. Not too hard using Quick! When QARE restarts, it in turn loads and
restarts all the persistent agents.

      Now lets allow for P2P searches for those same registered agents. Agents/services can now move about the network as needed and
where loading permits. Idle machines attract busy agents, while busy machines repel them.


      4. Debugging

      A event-listener methods are needed on QARE for collecting statistics and exception-events from agents. Similarly,
agent/services need to be able to register with QARE to receive those same statistics and exception-events. This forms the basis for
any number of debugging tools.

      Debugging plugins is very important. Further, you must be able to demonstrate to non-developers that agents using your plugin
are well behaved before very many clients will install your plugin. (Conversely, P2P should allow clients to see how many systems
have a particular plugin installed.)