Jade appliqué cours 1 : hello world, et fenêtres pour agent

HelloS world
dimanche 30 juin 2019
par  Emmanuel Adam
popularité : 2%

Cet article décrit quelques codes de base pour développer son/ses premiers agents en Jade.

Agent cordial

Classiquement, lorsqu’on apprend un langage, on tente de créer un exemple qui affiche « Hello world ».

Voici le code associé :

  1.  public class HelloAgent extends Agent {
  2.   protected void setup() {
  3.     System.out.println("Hello world, I'm " + this.getLocalName());
  4. }}

Pour lancer un agent de type HelloAgent, il faut charger la plateforme Jade et lui demander d’instancier un agent.
Cela peut se faire en ligne :
java jade.Boot monPremierAgent:HelloAgent

Des lignes apparaissent sur la console montrant l’installation en mémoire de Jade, puis le message de l’agent apparaît.

Pour lancer plusieurs agents :
java jade.Boot a1:HelloAgent;a2:HelloAgent;a3:HelloAgent

Il est possible de passer des paramètres (séparés par des virgules , )
java jade.Boot a1:HelloAgent(hello);a2:HelloAgent(salut);a3:HelloAgent(coucou)

On modifie le code précédent pour récupérer le paramètre :

  1. public class HelloAgent extends Agent {
  2.   protected void setup() {
  3.     Object[] args = getArguments();
  4.     String text = ((args.length>0)?(String)args[0]:"Hello");
  5.     System.out.println(text + "!, I'm " + this.getLocalName());
  6. }}

On peut également demander le chargement de la plateforme à partir d’une classe java :

  1. /**class that launch Jade and the agents*/
  2. import jade.core.Profile;
  3. import jade.core.ProfileImpl;
  4. import jade.util.ExtendedProperties;
  5. import jade.util.leap.Properties;
  6. import jade.core.Runtime;
  7.  
  8. public class LaunchAgents {
  9.  public static void main(String[] args) {
  10.   // préparer les arguments pout le conteneur JADE
  11.   Properties prop = new ExtendedProperties();
  12.   // demander la fenêtre de contrôle
  13.   prop.setProperty(Profile.GUI, "true");
  14.   // nommer les agents
  15.   prop.setProperty(Profile.AGENTS, "a1:HelloAgent(hello);a2:HelloAgent(salut);a3:HelloAgent(coucou)");
  16.   // créer le profile pour le conteneur principal
  17.   ProfileImpl profMain = new ProfileImpl(prop);
  18.   // lancer le conteneur principal
  19.   Runtime rt = Runtime.instance();
  20.   rt.createMainContainer(profMain);
  21.   }
  22. }

(Remarque, le paramètre -gui permet d’afficher une fenêtre de contrôle liée à la plateforme)

code / git

Agent et comportements

Un agent peut posséder un ou plusieurs comportements.
Jade exécute les agents en tant que processus et, pour chaque agent, prend chacun de ses comportements, exécute son action, vérifie ensuite s’il est fini (`done`) et doit être retiré de la liste.

Le code présent ici crée des agents qui affiche alternativement ’bonjour’, ’salut’ et se retire de la plateforme au bout de 10 secondes.

PingPong

Un exemple classique de test de communication est de créer deux agents, ping et pong, qui se renvoie un message contenant un texte.

Le code présent ici crée ces deux qui s’envoient des messages 30 fois.

Agent et Fenêtre

Un agent étant un processus, de même qu’une fenêtre, la communication entre une fenêtre et un agent doit passer par une gestion d’événements.

Un agent lié à une interface graphique doit étendre la classe GuiAgent et doit surcharger la méthode protected void onGuiEvent(GuiEvent ev) pour pouvoir traiter les événements émis par cette interface.
Cette méthode est activée dès qu’un événement lancée par la fenêtre est reçu.

Voici ci-dessous un extrait de fenêtre (à télécharger plus bas) :

  1. public class Window4Agent extends JFrame  implements ActionListener{
  2.  // .......
  3.   /**agent lié à cette interface */
  4.   GuiAgent myAgent;    
  5.   /**texte associé au bouton Quitter */
  6.   private final String QUITCMD = "QUIT";
  7.   /**code associé au bouton Quitter*/
  8.   public final static int QUITCODE = -1;
  9.   // .....
  10.        
  11.  /**Traitement d'un événement utilisateur et transmission à l'agent*/
  12.   public void actionPerformed(ActionEvent evt) {
  13.    //
  14.     String source = evt.getActionCommand();
  15.     if(source.equals(QUITCMD)){
  16.       GuiEvent ev = new GuiEvent((Object)this, QUITCODE);
  17.       myAgent.postGuiEvent(ev);
  18.     }
  19.   }
  20. }

Notez la fonction myAgent.postGuiEvent(ev); qui propage un élément de type GuiEvent qui se construit avec deux paramètres : un pointeur sur la fenêtre émettant l’événement, et un code entier.

Un agent `fenêtré` est alors légèrement adapté pour recevoir l’événement :

  1. public class HelloAgent extends GuiAgent{
  2.   /** petite console d'affichage graphique*/
  3.   public Window4Agent window;
  4.  
  5.  /** initialisation de l'agent  */
  6.   protected void setup() {  
  7.     String [] args = (String[]) this.getArguments();
  8.     String msg = ((args!=null && args.length>0)?args[0]:"hello");
  9.     window = new Window4Agent(this);
  10.     window.println(msg + "!, je suis  " + this.getLocalName());
  11.   }
  12.  
  13.   /**réaction à un événement fenêtre (GuiEvent)*/
  14.   protected void onGuiEvent(GuiEvent ev) {
  15.     switch(ev.getType()) {
  16.       case Window4Agent.QUITCODE:
  17.         window.dispose();
  18.         doDelete();
  19.         break;
  20.     }
  21.   }
  22. }

Télécharger

Ici se trouve les sources d’agents fenêtrés, 4 agents sont lancés, a,b,c et d.
Au clic sur `go` l’agent `a` envoie un message aux agents `b`, `c`, `d` qui l’affichent sur leurs consoles.

Protocoles

En programmation objet, si un objet o1 lance une méthode d’un objet o2 qui n’existe pas ; une erreur est déclenchée.

En programmation agent, si un agent a1 envoie un message à un agent a2 et que cet agent a2 ne comprend pas le message ou choisit de ne pas le traiter, rien ne se passe, et l’agent a1 n’est pas nécessairement mis au courant de l’échec à sa requête.

Les protocoles de communications permettent d’établir des cadres stricts d’échanges.
La norme FIPA propose plusieurs protocoles,

  • AchieveRE est un protocole où le destinataire est obligé de répondre, soit qu’il a bienreçu et traité le message, soit qu’il le refuse, soit que ce message est considéré comme un erreur
  • ContractNet est un protocole de type appel à propositions.
  • SimpleAchieveRE, ...

Une protocole peut être vu comme un comportement. Des méthodes sont exécutées automatiquement à la réception de messages selon leurs performatifs (Inform, Request, .....)

Le code situé ici montre un exemple de dialogue entre 2 agents par le protocole AchieveRE. Un agent soumet une requête à un autre agent et gère ses réponses.

Les négociations peuvent être codées sous forme de protocoles.


code sur github

Documents joints

Simple fenêtre pour Jade agent
hello world en agent JADE

Navigation

Articles de la rubrique