1. Modèle de programmation par agents

1.2. Rappels

    Les agents AAA sont des objets java passifs qui se comportent suivant un modèle d’exécution événement/réaction. Un message est représenté par une notification. Lorsqu’un agent reçoit une notification, il doit exécuter la réaction appropriée. Un agent est donc un ensemble de règles condition = réaction. Les agents ne peuvent communiquer entre eux que via des notifications. Chaque agent est identifié de manière unique par un identificateur (agentId).

    Propriétés :

• Persistance : L’état d’un agent est persistant.
• Atomicité : La réaction d'un agent est atomique. Cela veut dire qu’une réaction se termine normalement ou bien qu’elle est annulée. En particulier, toutes les notifications envoyées durant une réaction ne sont effectivement émises que lorsque la réaction est validée.
• Asynchronisme : l’exécution des agents producteurs et consommateurs d’événements peuvent être découplées dans le temps.
• Fiabilité : Toute notification envoyée est garantie d’arriver à destination malgré l’occurrence de panne machine ou réseau.
• Causalité : Les notifications sont délivrées à leur destinataires suivant leur ordre causal d’émission.

1.3.1. Les agents

    Tout agent doit hériter de la classe Agent qui contient le comportement de base de tous les agents. Les méthodes suivantes sont définies dans Agent :

• public Agent(short to) : un constructeur d’agent, "to" indique le site de déploiement de l’agent
• public Agent(short to, String n) : idem, n représente le nom symbolique de l’agent.
• public final void deploy() : Cette méthode permet de déployer un agent sur son site d’exécution.
• public String toString() : Permet d’obtenir une chaîne de caractère représentant l’agent.
• public final AgentId getId() : Permet d’obtenir l’identificateur d’un agent.
• protected void setField(SetField not) : Permet de fixer à distance un attribut public d’un agent.
• public void react(AgentId from, Notification not) : Chaque agent doit définir une méthode "react" qui spécifie le comportement de l’agent. Lorsqu’une notification n0 arrive, la méthode "react" est appelée avec pour paramètre : l’id de l’agent émetteur de la notification et la notification n0. C’est dans la méthode "react" que sont analysées les notifications entrantes et que les actions correspondantes sont effectuées. Cette méthode doit être surchargée par les sous classes d’Agent.
• protected final void sendTo(AgentId id, Notification not) : Permet d’envoyer la notification not à l’agent id.

Pour assurer la propriété de persistance, tous les objets java associés aux agents doivent être sérialisable en étendant l'interface Serializable.java.

    Une notification est un objet java serializable. Toutes les notifications doivent étendre la classe Notification.java. Pour pouvoir émettre des notifications externes à destination d'agents (internes), comme on ne se trouve pas dans une réaction on ne dispose pas de sendTo, on s'adresse directement au composant "Channel" du bus à messages dont la mission est l'acheminement des dits messages en utilisant le code suivant : Channel.sendTo(AgentId, Notification);

1.3.3. Les serveur d’agents

    Tous les agents s’exécutent dans des serveurs d’agents. Un serveur d’agents est un unique flot d’exécution qui gère un ensemble d’agents. Plusieurs serveurs peuvent résider sur la même machine. Tous les serveurs d’agents sont interconnectés et peuvent communiquer entre eux. Chaque serveur possède un thread d’exécution en charge d’activer la réaction d’un agent en fonction des notifications reçues. Cela implique qu’une seule réaction d’agent s’exécute à la fois au sein d’un serveur d’agent. Chaque serveur d’agents met en œuvre une part du bus logiciel.

1.3.4. Fichier de configuration

    Dans la version actuelle du bus à agents, tous les serveurs d’agents sont connus statiquement et doivent être enregistrés dans un fichier de configuration "a3servers.xml". Ce fichier de configuration doit être disponible sur tous les sites exécutant un serveur d’agent. A ce fichier au format "xml" est associé à un fichier décrivant sa structure "a3config.dtd". Voici un exemple de fichier a3servers.xml qui définit deux serveurs d’agents (0 et 1) qui s’exécutent sur la même machine.

<?xml version="1.0"?>
<!DOCTYPE config SYSTEM "a3config.dtd">
<config>
    <domain name="D1" />
    <server id="0" name="s0" hostname="localhost">
      <network domain="D1" port="11731"/>
    </server>
    <server id="1" name="s1" hostname="localhost">
          <network domain="D1" port="11732"/>
    </server>
</config>

1.3.5. Lancement d’un serveur d’agent

 
java fr.dyade.aaa.agent.AgentServer num rac
// num : numéro du serveur d’agent
// rac : racine de persistance du serveur d’agent, c’est un répertoire contenant les images persistantes des agents contenus dans le serveur.
// Ex :  java fr.dyade.aaa.agent.AgentServer 1 s1

Il est possible de lancer un serveur d’agents par programme de la manière suivante :

  ...
 main () {
   ...
   try {
    AgentServer.init(args); // initialisation du serveur
    /*
    * création des objets localement, réalisation des initialisations nécessaires et 
    * déploiement de ceux-ci sur les serveurs qui leur ont été respectivement affectés.
    */
    AgentServer.start(); // lancement du serveur
   }catch(Exception e) {
    e.printStackTrace(System.out);
   }
  }
  ...

Le programme principal de votre application doit utiliser la seconde manière afin de pouvoir déployer les agents sur les différents serveurs et accéder au bus à messages pour émettre des notifications externes. Les arguments fournis à "init" sont les mêmes que ceux devant être fournis à "AgentsServer" : le numéro du serveur et sa racine de persistance. Dans tous les cas votre classpath doit contenir l’accès aux librairies : a3.jar ;xerces.jar.

    L’exemple suivant à pour but de montrer les principes de programmation des agents AAA. Dans cet exemple, deux agents vont être créés et déployés :

• Un agent HelloWorld qui doit réagir à une notification de type HelloWorldNot en affichant le message " helloworld " à l’écran.
• Un agent HelloWorldClient qui réagit à une notification de type StartNot en envoyant une notification HelloWorldNot à un agent helloworld.

• L’agent HelloWorld.java

package work.TP.IS.tp1.v1;

import java.io.*;
import fr.dyade.aaa.agent.*;


public class HelloWorld extends Agent {

  public HelloWorld(short to) {
    super(to);
  }



  public void react(AgentId from, Notification n) throws Exception {
      
          if (n instanceof HelloWorldNot) System.out.println(((HelloWorldNot)n).msg); 
          else super.react(from,n);
  }

}

• La notification HelloWorldNot.java

package work.TP.IS.tp1.v1;
import fr.dyade.aaa.agent.*;

    public class HelloWorldNot extends Notification {
        public String msg = "helloworld";
        public HelloWorldNot(String msg) {
        this.msg = msg;
    }
}

• L’agent HelloWorldClient.java
package work.TP.IS.tp1.v1;
import java.io.*;
import fr.dyade.aaa.agent.*;
            
public class HelloWorldClient extends Agent { 
  public AgentId dest;
  public HelloWorldClient(short to) {
       super(to);
  }

  public void react(AgentId from, Notification n) throws Exception {
     if (n instanceof StartNot) {
        sendTo(dest, new HelloWorldNot("HelloWorld"));
     }else super.react(from,n);
  }
}

• La notification StartNot.java
package work.TP.IS.tp1.v1;
import fr.dyade.aaa.agent.*;
 

public class StartNot extends Notification {}

1.4.2. Lancement

•     Lancer le premier serveur d’agent : java fr.dyade.aaa.agent.AgentServer 1 s1
•     Lancer le programme principal : java work.TP.IS.tp1.v1.Launch 0 s0

2. Travail à réaliser

2.1 Réaliser le programme principal
    Ecrivez le programme principal "Launch" qui permet de déployer dans 2 serveurs différents 2 agents ag0 et ag1 respectivement de type HelloWorldClient et HelloWorld de telle sorte que ag0 envoie ses notifications à ag1.

2.2. Lancer l’exemple
    Il s’agit de lancer l’exemple décrit plus haut pour vérifier la validité de l’installation de l’environnement A3. La chaîne Hello World doit s’afficher à l’écran.

2.3. Vérification des propriétés
    Ecrivez des programmes permettant de vérifier les propriétés des agents AAA :

• Asynchronisme des communications (mode déconnecté)
• Persistance des agents
• Atomicité de la réaction
• Fiabilité des communications
• Ordonnancement causal des notifications