Partie I. Etat de l’art et travaux connexes
V. Contribution 2: Architecture du système
VI.5. Présentation du prototype
VI.5.3. Implémentation d’agents
Dans la plateforme supportant l’exécution du système de découverte et composition proposée, on distingue 2 groupes d’agents : agent de gestion de ressources et agents mobiles :
1. Les agents de gestion sont : Agent administrateur, agent d’infrastructure, agent de composition, agent statistiques, agent de prétraitement, agent de matching, agent de qualité et agent de catégorisation. Dans cette section on ne s’intéresse qu’à présenter les principales lignes du code des trois premiers agents (l'agent de composition suit le même principe que le reste des agents de gestion … ce qui fait que son code ressemble au code des autres agents) vue leur importance pour la gestion de chaque nœud Cloud.
2. Les agents mobile sont : Agent de découverte, agent de ressources, agent interface, Agent de communication, et agent de mis-a-a-jours. Dans cette section on ne s’intéresse qu’à présenter les principales lignes du code des deux premiers agents, vue leur importance pour le bon fonctionnement du système.
La communication entre agent se fait par l’échange de messages, FIPA-ACL en respectant les comportements et algorithmes définis dans les chapitres 4 et 5, par la machine à état fini (Finit State Machine). Enfin, les comportements d’agent sont implémentés en utilisant la class FSMBehaviour comme suit :
1. Agent administrateur : le Protocole général d’exécution de l’agent administrateur est comme suit :
1. import jade.core.Agent;
2. import jade.core.behaviours.CyclicBehaviour;
3. import jade.core.behaviours.FSMBehaviour; 4. public class Agent_Admin extends Agent{ 5. protectedvoidsetup(){
6. // création d’un comportement FSM pour l’agent administrateur 7. FSMBehaviourAgen_Admin = new FSMBehaviour();
8. //definition des etats
9. Agen_Admin.registerFirstState(new Attendre(),"A");
10. Agen_Admin.registerFirstState (new InitiateurNœud(),"B"); 11. Agen_Admin.registerState(new StockFichier(),"C");
12. Agen_Admin.registerState(new DistributeurTâches(),"D"); 13. Agen_Admin.registerState(new ContratRessources(),"E"); 14. Agen_Admin.registerLastState(new GestionADR(),"F"); 15. Agen_Admin.registerState(new MisàJourNœud(),"G"); 16. //définition des transactions
17. Agen_Admin.registerDefaultTransition("A","B"); 18. Agen_Admin.registerDefaultTransition("B","C"); 19. Agen_Admin.registerDefaultTransition("C","D"); 20. Agen_Admin.registerTransition("A","B",1); 21. Agen_Admin.registerTransition("B","A",2); 22. Agen_Admin.registerTransition("A","C",3); 23. Agen_Admin.registerTransition("C","A",4); 24. Agen_Admin.registerTransition("A","D",5); 25. Agen_Admin.registerTransition("A","B",1); 26. Agen_Admin.registerTransition("B","E",6); 27. Agen_Admin.registerTransition("E","F",7); 28. Agen_Admin.registerTransition("A","B",1); 29. Agen_Admin.registerTransition("B","G",8); 30.
131
32. addBehaviour(Agen_Admin); 33. }
34. }
2. Agent d’infrastructure : le Protocole général d’exécution de l’agent infrastructure est comme suit :
1. import jade.core.Agent;
2. import jade.core.behaviours.CyclicBehaviour; 3. import jade.core.behaviours.FSMBehaviour 4. import jade.core.behaviours.TickerBehaviour; 5. public class Agent_Infra extends Agent{ 6. protectedvoidsetup(){
7. // création d’un comportement FSM pour l’agent Infrastructure 8. FSMBehaviourAgen_Infra = new FSMBehaviour();
9. //definition des etats
10. Agen_Admin.registerFirstState(new Attendre(),"A");
11. Agen_Infra.registertState (new GestionMV(),"B");
12. Agen_Infra.registerState(new DistributeurMV(),"C");
13. Agen_Infra.registerLastState(new PrédicteurBesoin(),"D"); 14. //définition des transactions
15. Agen_Infra.registerDefaultTransition("A","C"); 16. Agen_Infra.registerDefaultTransition("A","D"); 17. Agen_Infra.registerTransition("A","B",1); 18. Agen_Infra.registerTransition("B","C",2); 19. // création d’un comportement périodique
20. addBehaviour(new TickerBehaviour(this, 1000) { 21. protectedvoidonTick() {
22. Agen_Infra.registerTransition("A","D",3); 23. }
24. }
25. // appliquer les comportements 26. addBehaviour(Agen_Infra); 27. }
28. }
3. Agent de composition : le Protocole général d’exécution de l’agent de composition est comme suit :
1. import jade.core.Agent;
2. import jade.core.behaviours.CyclicBehaviour; 3. import jade.core.behaviours.FSMBehaviour; 4. import jade.core.behaviours.WakerBehaviour; 5. public class Agent_Comp extends Agent{ 6. protectedvoidsetup(){
7. // création d’un comportement FSM pour l’agent de composition 8. FSMBehaviourAgen_Comp = new FSMBehaviour();
9. //definition des etats
10. Agen_Comp.registerFirstState(new Attendre(),"A");
11. Agen_Comp.registerState (new CaaSInitiateur(),"B");
12. Agen_Comp.registerState(new VérificateurSS(),"C"); 13. Agen_Comp.registerLastState(new ClasseurSS(),"D"); 14. //définition des transactions
15. Agen_Comp.registerDefaultTransition("A","B"); 16. Agen_Comp.registerDefaultTransition("B","D"); 17. Agen_Comp.registerTransition("A","B",1); 18. Agen_Comp.registerTransition("B","A",2);
132
19. Agen_Comp.registerTransition("A","C",3);
20. // création d’un comportement à durée prédéterminée 21. addBehaviour(new WakerBehaviour(this, 1000) 22. { 23. protectedvoidhandleElapsedTimeout() { 24. Agen_Comp.registerTransition("C","C",4); 25. Agen_Comp.doDelete(); 26. } 27. } 28. Agen_Comp.registerTransition("C","A",5); 29. Agen_Comp.registerTransition("A","D",6); 30. // appliquer les comportements
31. addBehaviour(Agen_Comp); 32. }
33. }
4. Agent mobile de découverte : le Protocole général d’exécution de l’agent mobile de découverte est comme suit :
1. import jade.core.Agent;
2. import jade.core.behaviours.OneShotBehaviour; 3. importjade.core.behaviours.TickerBehaviour; 4. import jade.core.behaviours.FSMBehaviour; 5. public class Agent_Comp extends Agent{ 6. protectedvoidsetup(){
7. // création d’un comportement FSM pour l’agent de composition 8. FSMBehaviourAgen_Comp = new FSMBehaviour();
9. //definition des etats
10. Agen_Comp.registerFirstState(new Attendre(),"A");
11. Agen_Comp.registerState (new ChercheurSS(),"B");
12. Agen_Comp.registerLastState(new DistributeurAD (),"C");
13. //définition des transactions
14. Agen_Comp.registerDefaultTransition("A","A"); 15. Agen_Comp.registerTransition("A","C",1); 16. Agen_Comp.registerTransition("C","B",2); 17. //création d’un comportement périodique
18. addBehaviour(new TickerBehaviour(this, 1000) { 19. protectedvoidonTick() { 20. Agen_Comp.registerTransition("B","B",3); 21. Agen_Comp.registerTransition("B","C",4); 22. } 23. }
24. // appliquer les comportements 25. addBehaviour(Agen_Comp);
26. } 27. }
28. Agent mobile ressources : le Protocole général d’exécution de l’agent mobile de ressources est comme suit :
1. import jade.core.Agent;
2. import jade.core.behaviours.OneShotBehaviour; 3. importjade.core.behaviours.TickerBehaviour; 4. import jade.core.behaviours.FSMBehaviour; 5. public class Agent_Comp extends Agent{ 6. protectedvoidsetup(){
133
8. FSMBehaviourAgen_Comp = new FSMBehaviour(); 9. //definiton des etats
10. Agen_Comp.registerFirstState(new Attendre(),"A");
11. Agen_Comp.registerState (new ChercheurSS(),"B");
12. Agen_Comp.registerLastState(new DistributeurAD (),"C");
13. Agen_Comp.registerLastState(new DéployerComp(),"D"); 14. //définition des transactions
15. Agen_Comp.registerDefaultTransition("A","A"); 16. Agen_Comp.registerTransition("A","C",1); 17. Agen_Comp.registerTransition("C","B",2); 18. //création d’un comportement périodique
19. addBehaviour(new TickerBehaviour(this, 1000) { 20. protectedvoidonTick() { 21. Agen_Comp.registerTransition("B","B",3); 22. Agen_Comp.registerTransition("B","C",4); 23. } 24. } 25. Agen_Comp.registerTransition("B","A",5); 26. Agen_Comp.registerTransition("A","D",6); 27. // appliquer les comportements
28. addBehaviour(Agen_Comp); 29. }
30. }
Le constructeur Attendre() est définis dans une classe héritière de la classeOneShotBehaviour, qui représente un comportement simple, et qui a une signification distincte pour chaque type d’agent : l’agent administrateur attend la venue d’une nouvelle requête client, l’agent infrastructure attend une nouvelle requête pour l’obtention de nouvelles ressources. L’agent composition attend les services sélectionnés, enfin les agents mobiles attendent les directives des agents administrateurs pour les dispatchers sur Internet. Le code de cette procédure est comme suit :
1. Private class Attendre OneShotBehaviour { 2. Public voidaction() {
3. block();// l’agent est bloqué en attente d’un méssage 4. }
5. }
Les messages échangés entre agents sont basés sur la spécification FIPA-ACL. Le code suivant illustre la réception et l’envoi de locution via un message FIPA-ACL entre l’agent administrateur qui demande une machine virtuelle et l’agent infrastructure qui lui fournit une MV.
L’agent administrateur commence à envoyer un message à l’agent infrastructure comme suit : 1. import jade.core.AID; 2. import jade.core.Agent; 3. import jade.core.behaviours.FSMBehaviour; 4. import jade.core.behaviours.OneShotBehaviour; 5. import jade.lang.acl.ACLMessage;
6. public class Agent_Admin extends Agent { 7. protected void setup(){
8. FSMBehaviourAgent_Admin = new FSMBehaviour();
9. Agent_Admin.registerFirstState(new attendreAgentInfra(), "attendreAgentInfra");
134
11. Agent_Admin.registerLastState(new fin(), "fin");
12. /*****************************************************************/ 13. Agent_Admin.registerDefaultTransition("attendreAgentInfra", "envoiDemandMV"); 14. Agent_Admin.registerTransition("envoiDemandMV","attendreAgentInfra" ,1); 15. Agent_Admin.registerTransition("envoiDemandMV", "fin", 2); 16. addBehaviour(agentA_Admin); 17. } 18. /*****************************************************************/ 19. private class attendreAgentInfra extends OneShotBehaviour{
20. public voidaction() { 21. block();
22. } 23. }
24. /*****************************************************************/ 25. private class envoiDemandMV extends OneShotBehaviour{
26. public voidaction() {
27. ACLMessage message = new ACLMessage(ACLMessage.INFORM);
28. message.addReceiver(new AID("Agent_infra", AID.ISLOCALNAME)); 1. message.setContent("Demande Nouvel MV");
2. send(message); 3. }
4. /*****************************************************************/ 5. private class fin extends OneShotBehaviour{
6. public voidaction() { 7. myAgent.doDelete(); 8. }
9. } 10. }
L’agent d’infrastructure reçoit le message envoyé par l’agent administrateur comme suit: 1. import java.security.acl.Acl; 2. import jade.core.AID; 3. import jade.core.Agent; 4. import jade.core.behaviours.FSMBehaviour; 5. import jade.core.behaviours.OneShotBehaviour; 6. import jade.lang.acl.ACLMessage;
7. public class Agent_Infra extends Agent { 8. protected void setup(){
9. FSMBehaviouragent_Infra= new FSMBehaviour();
10. agent_Infra.registerFirstState(new attendreDemandMV(), "attendreDemandMV");
11. agent_Infra.registerState(new MV(), "MV");
12. agent_Infra.registerLastState(new fin(), "fin");
13. /*****************************************************************/ 14. agent_Infra.registerDefaultTransition("MV", "attendreDemandMV"); 15. agent_Infra.registerTransition("attendreDemandMV", "MV",1); 16. agent_Infra.registerTransition("attendreDemandMV", "fin",2); 17. addBehaviour(agent_Infra); 18. }
19. private class attendreDemandMV extends OneShotBehaviour{ 20. public voidaction() {
21. block(); 22.
135
24. /****************************************************************/ 25. private class VM extends OneShotBehaviour{
26. public voidaction() {
27. ACLMessagemessageRecu = receive();
28. ACLMessage message = new ACLMessage(ACLMessage.INFORM);
29. message.addReceiver(new AID("Agent_Admin", AID.ISLOCALNAME)); 30. message.setContent("MV ID:002");
31. send(message); 32. }
33. }
34. /****************************************************************/ 35. private class fin extends OneShotBehaviour{
36. public voidaction() { 37. myAgent.doDelete(); 38. }
39. } 40. }