Agentes Móviles en Internet - Aglets SDK (II) (ES)

This is the first of a 3 articles serie. See the 1st an 3rd part.

En el artículo anterior hablamos de Agentes Móviles Autónomos. Pudimos ver que, después de todo, no son tan terribles y que, más aún, pueden llegar a ser de gran utilidad en el campo emergente de la computación masivamente distribuida. En el artículo que nos ocupa, vamos a presentar la aproximación al mundo de los AMAs que ha realizado IBM Japón sobre la plataforma Java: Aglets.

Siéndonos ya familiar el concepto de Agente Móvil Autónomo (AMA) y con un conocimiento suficiente de cómo funcionan y para qué se desarrollan, probablemente deseemos continuar nuestro camino haciendo algunas pruebas con agentes móviles. Puede, incluso, que tengamos en mente alguna aplicación realmente interesante que podría desarrollarse empleando ésta nueva tecnología. En cualquiera de los dos casos, lo más probable es que decidamos emplear alguna de las plataformas de desarrollo y ejecución de AMAs disponibles en Internet.

Un buen punto de referencia para conocer el Estado del Arte en materia de agentes en general, es la página principal de la Agent Society¹. En particular, encontramos allí información acerca de las plataformas disponibles para el desarrollo de AMAs. Las más importantes que podemos descargar y usar libremente (bajo las condiciones de licencia, como siempre) se describen en el cuadro PLATAFORMAS DE DESARROLLO Y EJECUCIÓN DE AMAs. De entre ellas, será el Aglets SDK la plataforma escogida para introducir al lector en el apasionante universo de los agentes móviles.

PLATAFORMAS DE DESARROLLO Y EJECUCIÓN DE AMAs

La Agent Society nos informa de la disponibilidad de las siguientes plataformas para el desarrollo de agentes móviles:

• Aglets: Desarrollado por IBM Tokyo Lab², presenta su producto como “Objetos móviles Java que pueden ejecutarse en un host, detener su ejecución súbitamente, despacharse a un host remoto, y proseguir su ejecución allí”.

• Concordia: Desarrollado en Mitsubishi Electric’s Horizon Systems Labs³. Descrito como un “Entorno completo para el desarrollo y gestión de aplicaciones de uso eficiente de la red, basadas en agentes móviles que acceden a información en cualquier tiempo, lugar y dispositivo que soporte Java”.

• Odyssey: Desarrollado por General Magic⁴, y descrito como “Sistema de agentes implementado como un conjunto de librerías de clases Java que proporcionan el soporte necesario para desarrollar aplicaciones móviles distribuidas”.

• Voyager: Desarrollado por ObjectSpace⁵, y descrito como “El primer Object Request Broker (ORB) mejorado para el uso de agentes 100% Java. Combina el poder de los agentes móviles autónomos y la invocación remota de métodos (RMI) con el soporte completo de CORBA”.

Aglets SDK

Aglets es un proyecto, aún en constante desarrollo, iniciativa del IMB Tokyo Lab (centro de I+D de IBM en Japón) [2]. Su objetivo: elaborar un entorno para el desarrollo, control y ejecución de AMAs sobre la plataforma Java (los AMAs se conocen dentro del proyecto como Aglets, según un lógico juego de palabras con los ya familiares Applets). En esencia, el Aglets SDK (es decir, lo que tú puedes bajarte desde la página principal) es el conjunto de herramientas necesarias para desarrollar tus propios Aglets y aplicaciones HOST para Aglets, proporcionando todo un conjunto de APIs Java que obvian los complejos aspectos de seguridad, transporte y comunicaciones entre agentes. Como no, también incluye una aplicación HOST (llamada Tahiti) completamente funcional para que podamos iniciarnos con facilidad en el mundo de los agentes móviles autónomos.

La idea de Aglets fue ocurrencia de Danny Lange (curiosamente ahora es miembro de General Magic, empresa que promociona Odyssey); cuando a éste, el inventor de Aglets, se le preguntó por su creación dijo: “Cuando inventé los aglets, estaba buscando un nivel de abstracción mayor para la computación distribuida. Para mí los aglets eran una respuesta a algunas preguntas que me hacía desde los 15 años: ¿qué viene después de la programación orientada a objetos?, ¿cuál es el siguiente paradigma?”. Por supuesto, lo que Lange pensaba cuando creó sus aglets no se trataba de algo nuevo; lo verdaderamente nuevo era que pensaba construir su trabajo sobre Java, capaz de obviar (hasta un cierto nivel) los problemas clásicos de los agentes móviles: la independencia de plataforma y los aspectos de seguridad.

Podemos conseguir el Aglet SDK (ASDK) más actualizado directamente desde la página principal de Aglets [2]. En el momento de escribir este artículo, el equipo de Aglets no ha sacado una versión 1.1 estable, por lo que todo la información que manejaremos será de la versión 1.0.3 del ASDK. Será más que suficiente para nuestros propósitos.

Arrancamos ahora ambas aplicaciones host para Aglets (Figura A). Cada cual correrá en su propio proceso de ejecución y dispondrá de sus propios subprocesos. La primera dispondrá de un Thread demonio escuchando constantemente al puerto 434, esperando la llegada de algún Aglet. La segunda atenderá al puerto 500 TCP/IP.

c:\Aglets1.0.3\bin\agletsd.bat y como parámetro de éste
–port 434 al primero y –port 500 al segundo.

Cualquiera de los dos host Tahiti, por ejemplo el que escucha al puerto 434, pulsaremos el botón Create. Se nos dará opción a crear uno de los Aglet ejemplo.

Escogeremos como primer Aglet el examples.hello.HelloAglet. La ventana de Tahiti mostrará información del nuevo agente creado y, a los pocos segundos, aparecerá su ventana de diálogo. En ella, el agente nos pedirá que escribamos un saludo y una dirección. Esta dirección será de la forma atp://nuestra_dirección:500 (que en mi caso podría ser atp://mike:500), donde le hemos dicho que emplee el protocolo de transporte de Aglets (atp), y que conecte con nuestro ordenador en el puerto 500, donde tenemos esperando a la otra aplicación host. En unos instantes, el Aglet desaparece de la primera ventana y reaparece en la segunda, mostrando el saludo que le pasamos previamente. Tras unos segundos, el Aglet da por finalizada su tarea y regresa a su host origen.

Listado 1 – Definición del agente HelloAglet

public class HelloAglet extends Aglet {
  transient Frame my_dialog = new MyDialog(this);
  String message = "Hello World!";
  String home = null;
  SimpleItinerary itinerary = null;

  /*Only called the very first time this aglet is created.*/
  public void onCreation(Object init) {
    itinerary = new SimpleItinerary(this);
    my_dialog.pack();
    my_dialog.resize(my_dialog.preferredSize());
    my_dialog.show();
    // Initialize the variables.
    home = getAgletContext().getHostingURL().toString();
  }

  /* Handles the message */
  public boolean handleMessage(Message msg) {
    if (msg.sameKind("atHome")) {
      atHome(msg);
    } else if (msg.sameKind("startTrip")) {
      startTrip(msg);
    } else if (msg.sameKind("sayHello")) {
      sayHello(msg);
    } else if (msg.sameKind("dialog")) {
      dialog(msg);
    } else {
      return false;
    }
  }

  /*Reports arrival home and disappears */
  public void atHome(Message msg) {
    setText("I'm back.");
    waitMessage(2 * 1000);
    dispose();
  }

  /*Starts the trip of this aglet to the destination.*/
  public synchronized void startTrip(Message msg) {
    String destination = (String)msg.getArg();

    try {
      itinerary.go(destination, "sayHello");
    } catch (Exception ex) {
      ex.printStackTrace();
    }
  }

  /* Say hello! */
  public void sayHello(Message msg) {
    setText(message);
    waitMessage(5 * 1000);
    // back home
    try {
      setText("I'll go back to.. " + home);
      waitMessage(1000);
      itinerary.go(home, "atHome");
    } catch (Exception ex) {
      ex.printStackTrace();
    }
  }

  /* Creates and shows the dialog window. */
  public void dialog(Message msg) {
    // check and create a dialog box
    if (my_dialog == null) {
      my_dialog = new MyDialog(this);
      my_dialog.pack();
      my_dialog.resize(my_dialog.preferredSize());
    }

    // show the dialog box
    my_dialog.show();
  }

}

El Listado 1 muestra la definición de la clase HelloAglet, clase que define al aglet al que acabamos de dar vida. Como veremos más tarde, siguiendo el modelo de eventos típico de Java, el agente HelloAglet inicia su “vida” cuando el entorno de ejecución crea el objeto Java y llama a su método onCreation()`. En dicho instante (seguir el Listado 1), su primera acción es crear un objeto SimpleItinerary (objeto itinerario predefinido en el Aglets API) que le facilitará la tarea de viajar; su segunda, mostrar la ventana de diálogo que ya vimos en pantalla.

Tras Introducir la dirección, el saludo y pulsar el botón GO!, la ventana de diálogo pasará el mensaje “startTrip” a nuestro agente HelloAglet. Como argumento (o cuerpo), el mensaje incluye la dirección del host a la que debe llevar el saludo. El método handleMessage() del recién creado agente recibirá este mensaje, respondiendo a “startTrip” con la llamada al método del mismo nombre e iniciando así el viaje hacia el destino especificado por nosotros. Gracias a las propiedades del objeto SimpleItinerary recibirá un mensaje a su llegada del tipo “sayHello”.

Una vez el agente HelloAglet alcanza el nuevo host, como respuesta al mensaje “sayHello”, muestra allí el mensaje que nosotros le dimos originalmente. Tras unos segundos regresará al host origen, donde recibirá un mensaje a su llegada del tipo “atHome”; ya en casa, se despedirá y autodestruirá como respuesta a este mensaje.

Como podemos apreciar, la “lógica” de programación de un agente asombra por su parecido con el desarrollo cotidiano de tareas.

Arquitectura del Aglets API

Vamos a ver a continuación (aunque ya disponíamos de un anticipo con el Listado 1) de qué forma se plasma toda la teoría que hemos visto en clases e interfaces Java absolutamente funcionales y familiares.

En la Figura B podemos ver la representación gráfica de una primera aproximación a la arquitectura del Aglets API.

Como desarrolladores de Aglets, esta representación nos muestra muy bien los principales elementos con los que nos debemos sentir familiares.

En primer lugar tenemos el AgletContext que, en este momento, representará para nosotros a la aplicación Host de la que tanto hemos hablado.

Sobre el AgletContext tenemos a los Aglets: objetos Java móviles que lo habitan (y que crearemos extendiendo la clase com.ibm.aglet.Aglet). Para el Aglet, sólo existe el AgletContext; es su punto de referencia y su fuente de recursos. Cuando quiere comunicarse, el Aglet pregunta al AgletContext por otros Aglets que lo habiten. El AgletContext le informará convenientemente retornándole una lista con los Aglets encontrados; una lista de objetos Java, por supuesto. Pero, ¡un momento! ¡Eso es peligroso! Y no falta razón, pues si nos dan acceso directo al Aglet como objeto Java, podríamos hacer uso de la introspección y activación de métodos en tiempo de ejecución: el agente estaría desnudo ante el primer aglet malintencionado que apareciera en el contexto. Para evitarse problemas de seguridad, la arquitectura del ASDK introduce los AgletsProxy, que no son más que objetos envoltorio de Aglets que realizan un “mapeado” de llamadas a métodos: un Aglet invoca un método de la interfaz pública del AgletProxy y éste, a su vez, invoca el método correspondiente del Aglet al que representa. De esta forma, el AgletContext sólo proporciona listas de AgletProxies; los Aglet trabajan con representaciones o interfaces generales de otros Aglets y nunca con estos últimos, evitando así innumerables problemas de seguridad.

Una vez obtenido un AgletProxy, el Aglet está en disposición de comunicarse con él, pues el representante provee métodos para el paso de mensajes.

Conclusiones

Con esta descripción general de la arquitectura del ASDK, debemos tener una idea más elaborada de cómo funcionan los AMAs, y cómo IBM Tokyo Lab los ha implementado en Java. Si se ha conseguido, démonos por satisfechos.

En el próximo artículo profundizaremos en el Aglets API, y aprenderemos a programar nuestros propios AMAs. Un abrazo.