Ontwikkelen van een Multi-Agent systeem met Jade in Eclipse

Ontwikkelen van een Multi-Agent systeem met Jade in Eclipse

Emmen, 18-‐5-‐2009 Afstudeer opdracht van ABI -‐ groep 6.

Verdiepingsverslag ABI Ontwikkelen van een Multi-Agent systeem met JADE Versie : 0.4 Datum : 18-‐5-‐2009 Status : Afstudeer opdracht van ABI -‐ groep 6.

Inhoudsopgave INLEIDING .................................................................................................................................................................3 GEHANTEERDE AFKORTINGEN .....................................................................................................................................................3 ONDERWERPEN. .....................................................................................................................................................4 VOORBEREIDING ............................................................................................................................................................................4 JADEDEMO ......................................................................................................................................................................................4 Structuur .......................................................................................................................................................................................4 Start scripts ..................................................................................................................................................................................5 ANDERE DOCUMENTATIE ..............................................................................................................................................................7 JadeServer .....................................................................................................................................................................................7 Netvisma prototype 3 ..............................................................................................................................................................7 STARTEN EN STOPPEN VAN HET JADE PLATFORM .....................................................................................8 JADE PLATFORM SOFTWARE ..........................................................................................................................................................8 STARTEN VAN HET JADE PLATFORM ...........................................................................................................................................9 STOPPEN VAN HET JADE PLATFORM ..........................................................................................................................................9 BELANGRIJKSTE PARAMETERS ..................................................................................................................................................10 STARTEN EN STOPPEN VAN JADE AGENT ....................................................................................................11 STARTEN VAN EEN JADE AGENT ...............................................................................................................................................11 Commando prompt ................................................................................................................................................................11 Van uit de RMA .........................................................................................................................................................................12 STOPPEN VAN EEN JADE AGENT ...............................................................................................................................................12 IMPLEMENTEREN VAN VERSCHILLENDE JADE AGENTS .........................................................................13 VOORBEREIDING .........................................................................................................................................................................13 MAKEN VAN EEN AGENT .............................................................................................................................................................13 Java broncode ...........................................................................................................................................................................13 Starten van de DemoAgent .................................................................................................................................................14 JADEDEMO ....................................................................................................................................................................................15 MAKEN VAN AGENT TAKEN ..............................................................................................................................16 VOORBEREIDING .........................................................................................................................................................................16 MAKEN VAN AGENT TAKEN ........................................................................................................................................................16 Implementeren van een agent taak ................................................................................................................................16 Uitvoeren van DemoTask .....................................................................................................................................................18 COMPLEXE TAKEN .......................................................................................................................................................................18 JADEDEMO ....................................................................................................................................................................................18 Sniffer 19 DE YELLOW PAGES SERVICE .............................................................................................................................20 VOORBEREIDING .........................................................................................................................................................................20 REGISTRATIE SERVICE .................................................................................................................................................................20 SERVICE ZOEKEN .........................................................................................................................................................................21 ONTOLOGIE ............................................................................................................................................................22 VOORBEREIDING .........................................................................................................................................................................22 GEBRUIK VAN ONTOLOGIE .........................................................................................................................................................22 VERSTUREN VAN EEN BERICHT MET EEN ONTOLOGIE OBJECT .............................................................................................22 HET ONTVANGEN VAN EEN BERICHT MET EEN ONTOLOGIE OBJECT ....................................................................................23 MAKEN VAN EEN ONTOLOGIE ....................................................................................................................................................23 “Costs” klasse .............................................................................................................................................................................23 “Book” klasse .............................................................................................................................................................................24 Verdiepingsverslag ABI Pagina 1 van 36


“Buy” klasse ...............................................................................................................................................................................25 “BookTradingOntology” klasse .........................................................................................................................................25 JADE BERICHT MET ONTOLOGIE OBJECT .................................................................................................................................28 PROTOCOLLEN ......................................................................................................................................................29 VOORBEREIDING .........................................................................................................................................................................29 FIPA-‐CONTRACTNET-‐PROTOCOL ............................................................................................................................................29 CONTRACTNETINITIATOR .........................................................................................................................................................30 prepareCfps ...............................................................................................................................................................................30 handlePropose ..........................................................................................................................................................................30 handleInform ............................................................................................................................................................................30 handleAllResponses ................................................................................................................................................................30 DemoInitiator ...........................................................................................................................................................................31 CONTRACTNETRESPONDER ......................................................................................................................................................33 handleCfp ...................................................................................................................................................................................33 handleAcceptProposal ..........................................................................................................................................................33 handleResultNotiSication .....................................................................................................................................................33 DemoResponder .......................................................................................................................................................................34 CONCLUSIE ..............................................................................................................................................................35 REFERENTIES / BRONDOCUMENTEN ............................................................................................................36

Verdiepingsverslag ABI Pagina 2 van 36


1.Inleiding Voor de ABI (Afstudeerproject Bachelor Informatica) hebben we gekozen om de Netvis (Netwerk visualisatie) module uit te breiden. Het prototype dat wij moesten ontwikkelen is de NETVIS module in een Multi-‐agent architectuur die de gegevens uit een Wiki (informatie samenwerking) database betrekt. Voor het ontwikkelen van het Multi-‐agent platform dienden wij het JADE Java platform te gebruiken. Om binnen ons project voldoende kennis op te doen met alle basisaspecten van het ontwikkelen van een Multi-‐agent systeem met JADE, is er een verdiepingsopdracht aan besteed. In dit document is zoveel mogelijk van de opgedane kennis van deze verdiepingsopdracht vastgelegd. Als belangrijkste handleiding voor deze verdiepingsopdracht is het studieboek “Developing Multi-‐ Agent Systems with JADE” gebruikt. De broncode die bij dit boek hoort is te vinden op http:// jade.tilab.com en http://wiley.com/go/bellifemine_jade, deze is als basis gebruikt en verder uitgewerkt. De broncode die gemaakt is tijdens deze verdiepingsopdracht is beschikbaar via SVN van de Open Universiteit Nederland. De Eclipse projecten “JadeServer”, “JadeDemo” en “JMS” zijn gemaakt tijdens deze opdracht. Verondersteld wordt dat u over enige basis kennis beschikt over het JADE platform, deze wordt niet behandeld in dit document. Er wordt wel regelmatig verwezen naar het studieboek om daarmee extra kennis op te doen. Dit document kan beschouwd worden als een soort werkboek voor het ontwikkelen van een Multi-‐agent omgeving met JADE. 1.1Gehanteerde a*kortingen Hieronder staan de belangrijkste aakortingen die in dit document gebruik worden. Term / aWkorting

Omschrijving

JADE Eclipse

Java Agent Development framework, een agent georiënteerd middleware framework Een open-‐source ontwikkelplatform voor o.a. Java projecten.

SVN/Subversion

Een open-‐source versie control systeem.

JadeServer Main-‐Container

JADE omgeving voor Eclipse voor het starten, debuggen en stoppen van JADE software agents. De hoofd container van het Jade Platform.

Studieboek

Boek “Developing multi-‐agent systems with JADE”, zie brondocumenten.

Yellow Pages ServiceEen soort gouden gids functie waaraan Agent diensten bekend gemaakt kunnen worden en kunnen worden opgevraagd. MTP Message Transport Protocol DF

Directory Facilitator

RMA

Remote Monitoring Agent

MPS

Message Transport Service



2.Onderwerpen. Gezien de omvang van de volledige JADE architectuur is binnen het project besloten dat er geen gebruik gemaakt wordt van Mobile agent en geen aandacht wordt besteed aan de beschikbaarheid van de JADE omgeving en ook geen gebruik wordt gemaakt van de webservice integratie. Alleen komen de hoofdstukken 1 t/m 5 aan bod waarbij de volgende onderwerpen aan bod komen: • • • • • • •

Starten en stopen van het JADE platform. Zowel van de Main-‐Container als een cliënt containers. Starten en stoppen van JADE agents. Zowel als zelfstandige agents als vanuit een (bestaande) Java applicatie. Implementeren van verschillende JADE agents. Bookbuyer agents en JMS agents. Maken van agent Taken. De Yellow Pages Service. Ontologie implementaties en content taal. Agent interactie protocol. Met name het Request protocol en het Contact-‐Net protocol.

2.1Voorbereiding Als voorbereiding op de komende onderwerpen is het aan te raden de hoofdstukken 1 t/m 3 van het studieboek te hebben doorgenomen. Naast dit document is er ook een archief bestand beschikbaar met de broncode van het JadeDemo project. Vanuit dit document wordt hier vaak naar verwezen. Het is dan ook aan te raden deze ergens op een computer uit te pakken. 2.2JadeDemo JadeDemo is een verzameling broncode bestanden die een groot deel van het “book-‐trading” systeem implementeerd. De broncode zoals deze gebruikt is in het studieboek is incompleet en bevat ook fouten. Deze zijn in de broncode van JadeDemo aangepast en werkend gemaakt. Daarnaast zijn ook de onderdelen “Ontologies” en Onteraction Protocols” geïmplementeerd en werkend gemaakt. 2.2.1Structuur De structuur van de JadeDemo is als volgt onderverdeeld. -‐ JadeDemo De hoofd directory met de volgende subdirectory’s -‐ bin In deze directory zijn alle gecompileerde Java bestanden te vinden, die zijn aangemaakt door Eclipse. -‐ etc Hierin staan alle verschillende start scripts voor zowel Windows, Linux als Mac OS X. Met de extentie “.cmd” zijn het scripts voor een Windows omgeving, met de extentie “.sh” zijn het scripts voor een Linux omgeving. De scripts zonder extentie zijn bedoeld voor Mac OS X. -‐ libs Hierin staan de Java JAR bestanden met daarin de benodigde gecompileerde Java code. -‐ docs Hierin staat dit document en de javadoc documentatie van de Java broncode. -‐ src Hierin staan de broncode bestanden van dit JadeDemo project.



2.2.2Start scripts Er zijn een aantal type start scritps, zowel voor een Windows, Linux als Mac OS X omgeving. De meeste scripts starten het JADE platform niet op, maar verwachten dat deze al gestart is, een uitzondering zijn de “demo1_all*” en “demo2_all*” scripts. Deze starten de complete omgeving, inclusie de Main-‐Container”. Als er al een Main-‐Container draait werken deze start scripts niet. Voor alle andere scripts moet wel de “demo_server” worden gestart alvorens de andere scritpts.



2.2.2.1Voorbeeld Windows Demo 1 alles Start een script door deze te dubbelklikken of met de rechter muis knop op “openen” te klikken. De uitvoer van het commando in windows moet er ongeveer hetzelfde uit zien als “Figuur 1, Windows Demo1 alles”. Er worden meerdere windows geopend, maar deze zijn hieronder niet weergegeven.

Figuur 1, Windows Demo1 alles

2.2.2.2Voorbeeld Linux Demo server Het starten van de demo server op een Linux omgeving gaat als volgt: start een terminal vanuit het graaische Linux scherm en geef de volgende commando’s: cd <JadeDemo directory>/etc ./demo_server.sh

In het terminal ‘Windows’ komt ongeveer het volgende te staan: zie “Figuur 2, Lunix Demo Server”.

Figuur 2, Lunix Demo Server



2.2.2.3Voorbeeld Mac OS X Demo 1 buyer Het starten van een enkele agent op een Mac OS X omgeving gaat als volgt: start de Terminal applicatie en ga vervolgens naar de JadeDemo directory zoals in het Linux voorbeeld en start het “demo1_buyer” script waarna het gebruikers Windows wordt gestart van de buyer agent, zie “Figuur 3, Mac OS X Demo 1 buyer”. Let op! hiervoor moet eerst op hetzelfde systeem de “DemoServer” worden gestart.

Figuur 3, Mac OS X Demo 1 buyer

2.3Andere documentatie Naast dit document zijn er nog twee documenten die direct met dit onderwerp te maken hebben. 2.3.1JadeServer Het eerste is het “JadeServer” document waarin beschreven wordt hoe een Mutli-‐Agent systeem kan ontwikkeld worden met JADE middelware en de ontwikkelomgeving Eclipse: zie brondocumenten. Dit document behandelt met name het gebruik van Eclipse als ontwikkelomgeving en hoe je deze kunt gebruiken om met JADE architectuur overweg te kunnen. 2.3.2Netvisma prototype 3 Het tweede document is een installatie document van een applicatie prototype dat gebruik maakt van de JADE architectuur: zie brondocumenten. Deze is met name geschikt als voorbeeld voor het ontwikkelen van een Multi-‐Agent systeem dat platform onaahankelijk moet zijn.



3.Starten en stoppen van het JADE platform Voor het starten van een JADE platform heeft u naast een Java Runtime omgeving van minimaal release 1.4 ook de JADE software nodig. De gebruikte Java Runtime omgeving die voor het maken van dit document is gebruikt is versie 1.6.0. De JADE software kan worden geïnstalleerd zoals beschreven in hoofdstuk 3.4 en maakt integraal deel uit van de verschillende JADE Eclipse projecten zoals deze gebruikt worden in dit document. 3.1Jade platform software JADE is gebaseerd op Java en bestaat uit een aantal verschillende bestanden. Standaard heb je aan de drie standaard JAR bestanden voldoende. Deze zijn: • jade.jar Deze bevat alle JADE packages behalve de add-‐on en graaische tools. • jadeTools.jar Deze bevat alle graaische tools. • http.jar Deze bevat de HTTP gebaseerde MTP wat ook de standaard is voor JADE op dit moment. • Commons-‐codec\commons-‐codec-‐1.3.jar Deze bevat de Base64 codec gebruikt door JADE. Al deze bestanden moeten ik het pad staan van Java. Ook is het handig om gebruik te maken van een JADE_HOME variabele. Het studieboek maak gebruik van C:\jade voor het Windows platform en voor de onderstaande voorbeeld wordt dat ook gebruikt. De omgeving staat ook in “Figuur 4, Omgevingsstructuur” hieronder aangegeven.

Figuur 4, Omgevingsstructuur



3.2Starten van het JADE platform Door het starten van de Main-‐Container wordt het JADE platform gestart en kunnen er daarna software agenten worden gestart die middels deze hoofd container met elkaar kunnen communiceren. Het starten kan zoals het studieboek aangeeft op blz 36, maar ook zoals in “Figuur 5, Main-‐Container starten” is aangegeven.

Figuur 5, Main-Container starten

In het geval zoals hierboven gebruikt is, wordt ook direct de RMA gestart, de graaische beheerstool die standaard is meegeleverd en handige functies heeft. Daar wordt nog op teruggekomen. 3.3Stoppen van het JADE platform Het stoppen van de Main-‐Container kan door het stoppen van commando Shell, maar ook via de RMA, door het “Kill” commando te geven aan de Main-‐Container, zoals in “Figuur 6, Stoppen via de RMA” is aangegeven. Dit is een mooiere manier van stoppen van de omgeving omdat dit vanuit het platform wordt gedaan en niet van buitenaf door het beëindigen van de Shell.

Figuur 6, Stoppen via de RMA



3.4Belangrijkste parameters Zoals al aangegeven kunnen er parameters worden meegegeven aan het JADE Boot programma. Hieronder zijn de belangrijkste van deze parameters kort beschreven: -‐ -‐ -‐ -‐ -‐ -‐ -‐

-‐container Hiermee wordt aangegeven dat niet de Main-‐Container opgestart moet worden, maar dat er een verbinding moet worden gelegd met de Main-‐Container -‐host Hiermee wordt aangegeven op welke hostnaam, IP adres de Main-‐Container draait. -‐port <poortnummer> Hiermee wordt aangegeven op welke poort de Main-‐Container te bereiken is, standaard is dit poortnummer 1099. -‐local-‐host Hiermee kan worden aangegeven op welke hostnaam de lokale container gestart moet worden, standaard is het de localhost. -‐local-‐port <poortnummer> Het poortnummer waar de container op kan worden bereikt, standaard is dit poortnummer 1099. -‐container-‐name De naam van de container, standaard container-‐. -‐gui Voor het starten van de GUI ook wel RMA (Remote Monitoring Agent) genoemd.



4.Starten en stoppen van JADE agent Voor het starten van Java programma’s via een commando prompt moet het pad naar het “java” programma wel bekent zijn. Dit gaat door deze toe te voegen aan de omgeving variabele “PATH”, zie “Figuur 7, PATH op Windows XP 64”.

Figuur 7, PATH op Windows XP 64

4.1Starten van een JADE agent Er zijn verschillende methodes om agent te starten, in de volgende paragraven worden een paar voorbeelden behandeld. 4.1.1Commando prompt Het starten van een agent is vrij simpel van de commando prompt door het de volgende algemene commando: <JAVA> jade.Boot [–container] –agents :

Een voorbeeld van de “Book Buyer Agent”: <JAVA> jade.Boot –container –agents buyer:JadeDemo1.BookBuyerAgentV1

Er kunnen meer parameters worden meegegeven zoals in paragraaf “3.4 Belangrijkste parameters” is aangegeven. Alleen voordat je een Java programma kunt starten, moet deze wel weten waar de Java klassen te vinden zijn. Dit gaat door de parameter “–classpath”. In dit voorbeeld gaan we er van uit dat we in de “etc” directory staan van de JadeDemo omgeving. De Java klassen bevinden zich in de “libs” directory. Dan zal het volledige commando er zo uit te zien: java -classpath ..\libs\*;..\bin jade.Boot -container -agents buyer:JadeDemo1.BookBuyerAgentV1



4.1.2Van uit de RMA Ook kan een agent worden gestart vanuit de RMA door de naam van de agent op te geven en de agent klasse. Deze klasse moet dat wel bekend zijn in die container. Selecteer eerst de container waarin je de agent wil starten, bijvoorbeeld “Container-‐1”. Het starten van een nieuwe agent gaat als volgt: in de “RMA” kies voor het menu “Actions” voor “Start New Agent” en geef een naam op, bijvoorbeeld “buyer”. Kies vervolgens een Agent klasse, voorbeeld “JadeDemo1.BookBuyerAgentV1” en klik vervolgens op “OK”, zie “Figuur 8, Start Agent met RMA”.

Figuur 8, Start Agent met RMA

4.2Stoppen van een JADE agent Het stoppen van een agent kan door het Windows van de commando prompt te stoppen, dan wordt zowel de JADE container gestopt en de agent. Daarnaast kan een agent gestopt worden door in de RMA de agent de stoppen, zie “Figuur 9, Stop agent met RMA”. Hierbij blijft de container draaien en wordt het commando prompt Windows niet gestopt.

Figuur 9, Stop agent met RMA



5.Implementeren van verschillende JADE agents Het implementeren van een JADE agent is relatief simpel. In dit hoofdstuk wordt kort beschreven hoe een simpele agent gemaakt kan wordt. Als voorbeeld wordt de Demo Agent van het JadeDemo project gebruikt. 5.1Voorbereiding Als voorbereiding voor dit hoofdstuk is het aan te raden de eerste paragraaf van hoofdstuk 4 van het studieboek te hebben doorgenomen. 5.2Maken van een agent Het maken van een agent gaat door het implementeren van de “setup” procedure van de “jade.core.Agent” klasse. Deze procedure wordt uitgevoerd op het moment dat de agent gestart wordt. Daarnaast is er ook nog een procedure wanneer de agent gestopt wordt, dit is de “takeDown” procedure. 5.2.1Java broncode Hieronder de Java broncode voor de DemoAgent. import jade.core.Agent; public class DemoAgent extends Agent {

private static final long serialVersionUID = 1809045870111746514L;

}

protected void setup() { System.out.println(this.getClass().getName() + " Started..."); // Wacht even en dan stoppen. try { Thread.sleep(10000); } catch (InterruptedException ignore) {} this.doDelete(); } protected void takeDown() { System.out.println(this.getClass().getName() + " Stopped."); }



5.2.2Starten van de DemoAgent Het starten van de DemoAgent kan door de broncode te compileren en vervolgens uit te voeren. In het voorbeeld hieronder is de JadeServer al gestart. Bij het compileren van de DemoAgent moet ook worden verwezen naar de JADE librarie bestanden, net als bij het starten van de agent. Zie voorbeeld “Figuur 10, DemoAgent”.

Figuur 10, DemoAgent

Hierbij moet wel een opmerking worden geplaatst, dat wel de agent gestopt word, maar niet de Container waarin de agent gestart is. Deze kan worden gestopt door het Java programma te stoppen middels de toetscombinatie “Ctrl-‐C”.



5.3JadeDemo De GUI klassen worden niet in de studieboek weergegeven, maar zijn wel verkrijgbaar op het Internet. In het JadeDemo project zijn deze toegevoegd en werkend gemaakt. Het starten van de agent kan door de start scripts “demo1_buyer*”, “demo1_seller1*” en “demo1_seller2*”. De eerste start de “Buyer” agent en de laatste twee starten een “Seller” agent, waarbij verschillende onderhandelingswaarden kan worden opgegeven. Hieronder de twee verschillende gebruikers schermen van het “Book-‐Trading” project, zie “Figuur 11, Agent gebruikers schermen” voor de “Buyer” agent links en de “Seller” agent rechts.

Figuur 11, Agent gebruikers schermen



6.Maken van agent taken Alle acties die een agent moet uitvoeren moet als taak worden geïmplementeerd. Hiervoor zijn een aantal stadaard type taken voor gedeainieerd. Taken wordt implementeerd van het type “Behaviour” zoals: • • • •

“Behaviour”, de generieke klasse om een bepaalde actie uit te voeren, “OneShotBehaviour”, om éénmalig een bepaalde actie uit te voeren, “CyclicBehaviour”, om meerdere keren een bepaalde actie uit te voeren, “TickerBehaviour”, om een bepaalde actie uit te voeren met een bepaald tijdsinterval.

6.1Voorbereiding Als voorbereiding voor dit hoofdstuk is het aan te raden de paragrafen 2 en 3 van hoofdstuk 4 van het studieboek te hebben doorgenomen. 6.2Maken van agent taken Acties die agenten moeten uitvoeren worden gecodeerd in agent taken, “Behaviour” genoemd. Door het implementeren van de procedure “” met daarin de uit te voeren acties, kan een agent taak worden geïmplementeerd. Er zijn verschillende standaard taken die de functie “done” implementeren. Deze functie wordt elke keer uitgevoerd als de procedure “” aangeroepen is. Als de functie “done”, “WAAR” teruggeeft wordt de taak gestopt, maar anders blijft deze actief. De functie “Done” kan ook worden aangepast naar eigen voorkeur door deze zelf te implementeren. 6.2.1Implementeren van een agent taak In het onderstaande voorbeeld wordt er drie verschillende taken na elkaar uitgevoerd en als deze klaar zijn wordt de agent gestopt. Deze is geimplementeerd door een “TickerBehaviour” om deze met een vastgestelde tijdsinterval uit te voeren.



Hieronder de Java broncode voor het implementeren van een agent taak. import jade.core.Agent; import jade.core.behaviours.TickerBehaviour; public class DemoTask extends Agent { // Setup methode protected void setup() { System.out.println(this.getClass().getName() + " Starten..."); // Taak van deze agent. this.addBehaviour(new MyTask(this,10000)); // 10 seconden } // Stop methode private void stop_agent() { this.doDelete(); } // takeDown methode protected void takeDown() { System.out.println(this.getClass().getName() + " Stoppen."); } // MyTask klasse public class MyTask extends TickerBehaviour { private int step = 0; // Stap waarde // MyTask contructor public MyTask(Agent agent, long period) { super(agent, period); } // Taak acties public void onTick() { switch (step) { case 0: // Eerste stap System.out.println(this.getClass().getName() " Stap 1."); break; case 1: // Tweede stap System.out.println(this.getClass().getName() " Stap 2."); break; case 2: // Derde stap System.out.println(this.getClass().getName() " Stap 3."); break; default: System.out.println(this.getClass().getName() " Stoppen!."); this.stop(); } step++; }

}

}

// onEnd methode public int onEnd() { System.out.println(this.getClass().getName() + " Einde."); stop_agent(); return 0; }


+

+

+

+


6.2.2Uitvoeren van DemoTask Het starten van de DemoTask kan door de broncode te compileren en vervolgens uit te voeren. In het voorbeeld hieronder is de JadeServer al gestart. Bij het compileren van de DemoTask moet ook worden verwezen naar de JADE library bestanden, net als bij het starten van de agent. Zie voorbeeld “Figuur 12, DemoTask”.

Figuur 12, DemoTask

Hierbij moet wel een opmerking worden geplaatst, dat wel de agent gestopt word, maar niet de Container waarin de agent gestart is. Deze kan worden gestopt door het Java programma te stoppen middels de toetscombinatie “Ctrl-‐C”. 6.3Complexe taken Zoals in het studieboek beschreven worden taken afgehandeld door “Onderhandelaars” klassen. Waarbij de ene agent “Initiator” een gesprek opzet met een “Respondeerende” agent. Deze wisselen berichten uit volgens een door de ontwikkelaar bepaald protocol. De inhoud van de berichten wordt door de ontwikkelaar bepaald en de aahandeling daarvan moet geïmplementeerd worden. Binnen JADE zijn er ook standaard communicatie protocollen aanwezig waarbij de berichtaahandeling al voorgedeainieerd is. Deze worden in hoofdstuk “9. Protocollen” behandeld. 6.4JadeDemo Binnen het project JadeDemo zijn de “BookSellerAgent” en de “BookBuyerAgent” versie 1 gemaakt zoals in het studieboek is aangegeven. De werkende broncode is toegevoegd aan het JadeDemo project en kan worden vergeleken met de broncode snippers zoals deze in het studieboek zijn aangegeven.



6.4.1Sniffer Met de “Sniffer” functie kan de communicatie tussen de verschillende agenten worden bekeken en onderzocht. Ook kan de inhoud van de verschillende berichten worden bekeken. Het onderzoeken “debuggen” van de communicatie is een complexe handeling en gaat te ver om in dit document te beschrijven. Het is wel belangrijk om een goed inzicht te krijgen in de verloop van de communicatie. De “Sniffer” is te starten vanuit de RMA middels het menu “Tools” -‐> “Start Sniffer”, waarna het gebruikersscherm van de “Sniffer” verschijnt. Door een agent regel te selecteren en vervolgens middels het menu “Actions” -‐> “Do sniff this agent(s)” is de agent communicatie te volgen. In “Figuur 13, Sniffer” is de communicatie te zien van het “Book-‐Trading” project waarbij een boek besteld wordt.

Figuur 13, Sniffer

De verschillende berichten kunnen worden bekeken door met de alternatieve muisknop op een communicatiepijl te klikken en vervolgens “View Message” te selecteren. Opmerking; de “buyer” agent is gestopt op het moment dat de “Inform” bericht is ontvangen, vandaar dat deze geel gekeurd is. Zie “Figuur 14, Inform bericht” voor de inhoud “Inform” bericht.



7.De Yellow Pages Service De “Yellow Pages Service” is een belangrijke functionaliteit van de JADE architectuur. De service wordt verleend door de DF agent. Deze heeft een “Gouden Gids” functie waarbij aanbieders (seller-‐ agent) zich aanmelden als bepaalde aanbieder en de informatiezoekers (buyer-‐agent) kunnen bij deze DF agent navraag doen welke agenten een bepaalde informatie kunnen geven, zoals ook in “Figuur 13, Sniffer” te zien is. 7.1Voorbereiding Als voorbereiding voor dit hoofdstuk is het aan te raden de laatste paragrafen van hoofdstuk 4 van het studieboek te hebben doorgenomen. 7.2Registratie service Een agent kan een service bekend maken bij de DF agent, door deze te deainiëren en kenbaar te maken. Er is een klein aanpassing ten opzichte van het studieboek, dat heeft te maken met hoofdstuk “8. Ontologie”. Hieronder de Java broncode voor het registreren van de “Book-‐selling” service. // Register the book-selling service in the yellow pages DFAgentDescription dfd = new DFAgentDescription(); dfd.setName(getAID()); ServiceDescription sd = new ServiceDescription(); sd.setType("book-selling"); sd.setName("JADE-book-trading"); sd.addOntologies(ontology.getName()); sd.addLanguages(BookTradingOntology.LANGUAGE); sd.addProtocols(FIPANames.InteractionProtocol.FIPA_REQUEST); sd.addProtocols(FIPANames.InteractionProtocol.FIPA_PROPOSE); dfd.addServices(sd); try { DFService.register(this, dfd); } catch (FIPAException fe) { fe.printStackTrace(); }



7.3Service zoeken Een agent kan bij de DF agent opvragen welke agenten een bepaalde service hebben geregistreerd. De zoekopdracht levert een lijst op met agent namen. In “Figuur 13, Sniffer” is te zien dat de “buyer” agent eerst een verzoek doet aan de DF agent en daarop een antwoord terug krijgt, deze communicatie is het gevolg van de onderstaande voorbeeld. Er is een klein aanpassing ten opzichte van het studieboek, dat heeft te maken met hoofdstuk “8. Ontologie”. Hieronder de Java broncode voor het opvragen van agent die de service “Book-‐selling” ondersteunen. DFAgentDescription template = new DFAgentDescription(); ServiceDescription sd = new ServiceDescription(); sd.setType("book-selling"); sd.setName("JADE-book-trading"); sd.addOntologies(ontology.getName()); sd.addLanguages(BookTradingOntology.LANGUAGE); template.addServices(sd); try { DFAgentDescription[] result = DFService.search(myAgent, template); sellerAgents = new AID[result.length]; for (int i = 0; i < result.length; ++i) { sellerAgents[i] = result[i].getName(); } } catch (FIPAException fe) { fe.printStackTrace(); }



8.Ontologie Dit hoofdstuk gaat over het gebuiken van ontologien binnen de communictatie tussen de verschillende agent. Over dit onderwerp zijn er op dit moment nog weinig uitgewerkte voorbeelden te vinden binnen JADE. In het JadeDemo project is deze volledig geïntergreerd zoals dit al zichtbaar was in het vorige hoofdstuk. Het gebruik van de ontologie methodiek heeft als grootste voordeel dat je Java objecten kunt gebruiken voor de communicatie tussen JADE agenten waarbij het coderen en decoderen van de objecten automatische gedaan wordt door de JADE programmatuur. Zelfs is het mogelijk om objecten van verschillende ontwikkelplatformen met elkaar uit te wisselen. Om hiervan gebruik te maken moet een ontologie wel geregistreerd worden en bekend gemaakt worden aan de JADE architectuur. Dit wordt in de volgende paragrafen behandeld. 8.1Voorbereiding Als voorbereiding voor dit hoofdstuk is het aan te raden de eerste paragraaf van hoofdstuk 5 van het studieboek te hebben doorgenomen. 8.2Gebruik van Ontologie Om gebruik te kunnen maken van een ontologie moet de agent een aantal stappen doen. De Java broncode hieronder is een samenvoeging van alle stappen die nodig zijn, maar is uit verschillende stukken van de originele broncode gehaald. Als eerste stap is een instantie van de te gebruiken Ontologie te verkrijgen en deze te registreren bij de content manager. Het maken van een ontologie wordt in paragraaf “8.5 Maken van een Ontologie” behandeld. Als er gebruik gemaakt wordt van de DF agent, kan de ontologie ook hier geregistreerd worden zodat deze service nog meer gespeciaiceerd wordt. Hieronder de Java broncode om gebruik te kunnen maken van een gecodeerde ontologie. private Ontology ontology = BookTradingOntology.getInstance(); getContentManager().registerLanguage(codec,BookTradingOntology.LANGUAGE); getContentManager().registerOntology(ontology);

Hieronder de Java broncode om de ontologie te registreren bij de DF agent. sd.addOntologies(ontology.getName()); sd.addLanguages(BookTradingOntology.LANGUAGE);

8.3Versturen van een bericht met een Ontologie object Het versturen van een ontologie object is heel simpel, namelijk door het creëren van het Java object en deze aan de content manager van JADE te geven om in het bericht te plaatsen. Hieronder de Java broncode om een Java object in een JADE bericht te plaatsen. Book book = new Book(); ... Costs costs = new Costs(); costs.setBook(book); costs.setPrice(pm.getCurrentPrice()); myAgent.getContentManager().fillContent(reply, costs);



8.4Het ontvangen van een bericht met een Ontologie object Het ontvangen van een ontologie object is niet veel moeilijker, namelijk door aan de content manager te vragen de inhoud van het bericht te vertalen naar een Java object. Hieronder de Java broncode om een Java object in een JADE bericht te plaatsen. ContentElement em = myAgent.getContentManager().extractContent(msg); if( em instanceof Buy ) { Buy buy = (Buy) em; ... }

8.5Maken van een Ontologie Het maken van een ontologie is ingewikkelder, maar er zijn een aantal basis principes. Voor een Java object dat gebruikt wordt binnen een ontologie, daarvan moeten de te gebruiken variabelen en de “getters” en “setters” worden geïmplementeerd, zoals voor “Costs”, “Book” en “Buy” klassen. Daarnaast moeten deze Java objecten toegevoegd worden aan een ontologie door deze te registreren binnen de JADE architectuur als een instantie van “Onology”. In de Java broncode snippers hieronder staan de complete Java objecten weergegeven zoals deze ook binnen het JadeDemo project zijn gebruikt. 8.5.1“Costs” klasse Hieronder de Java broncode van de “Costs” klasse. public class Costs implements Predicate { private Book book; private int price; public void setBook(Book book) { this.book = book; } public Book getBook() { return book; } public void setPrice(int price) { this.price = price; } public int getPrice() { return price; } public boolean equals(Object object) { if( object instanceof Costs ) { Costs costs = (Costs) object; if( costs != null ) { return costs.getBook().equals(book) && costs.getPrice() == price; } } return false; } }



8.5.2“Book” klasse Hieronder de Java broncode van de “Book” klasse. public }

class Book implements Concept { private String title; private List authors; private String editor; public void setAuthors(List authors) { this.authors = authors; } public List getAuthors() { return authors; } public void setEditor(String editor) { this.editor = editor; } public String getEditor() { return editor; } public void setTitle(String title) { this.title = title; } public String getTitle() { return title; } public boolean equals(Object object) { if( object instanceof Book ) { Book book = (Book) object; if( book != null ) { return book.getTitle().equals(title) && book.getEditor().equals(editor); } } return false; }



8.5.3“Buy” klasse Hieronder de Java broncode van de “Buy” klasse. public class Buy implements Predicate { private Book book;

public void setBook(Book book) { this.book = book; }

public Book getBook() { return book; }

}

8.5.4“BookTradingOntology” klasse In deze klasse worden de hierboven beschreven Java klassen geregistreerd in de JADE architectuur. Eerst worden de klassen toegevoegd, en daarna worden de verschillende content objecten geregistreerd en de variabelen bekend gemaakt. Van deze variabelen kan worden aangegeven of deze verplicht of optioneel zijn, maar ook het aantal objecten dat er minimaal en maximaal van worden meegenomen.



Hieronder de Java broncode van de “BookTradingOntology” klasse. public

class BookTradingOntology extends Ontology { public static final String ONTOLOGY_NAME = "Book-trading-ontology"; public static final String LANGUAGE = FIPANames.ContentLanguage.FIPA_SL0; // VOCABULARY /** * Book declaration */ public static final String BOOK = "Book"; public static final String BOOK_TITLE = "title"; public static final String BOOK_AUTHORS = "authors"; public static final String BOOK_EDITOR = "editor";

/** * Buy declaration */ public static final String BUY = "Buy"; public static final String BUY_BOOK = "book";

/** * Costs declaration */ public static final String COSTS public static final String COSTS_BOOK public static final String COSTS_PRICE

/** * Sell declaration */ public static final String SELL = "Sell"; public static final String SELL_BOOK = "book";

public static Ontology getInstance() { return theInstance; }

= "Costs"; = "book"; = "price";

// The singleton instance of this ontology. private static Ontology theInstance = new BookTradingOntology();



Vervolg Java broncode van de “BookTradingOntology” klasse.

// Private constructor private BookTradingOntology() { super(ONTOLOGY_NAME, BasicOntology.getInstance(), new CFReflectiveIntrospector()); try { add(new ConceptSchema(BOOK), Book.class); add(new PredicateSchema(BUY), Buy.class); add(new PredicateSchema(COSTS), Costs.class); add(new AgentActionSchema(SELL), Sell.class);

// Structure of the Book concept ConceptSchema cs = (ConceptSchema) getSchema(BOOK); cs.add(BOOK_TITLE, (PrimitiveSchema) getSchema(BasicOntology.STRING)); cs.add(BOOK_AUTHORS, (PrimitiveSchema) getSchema(BasicOntology.STRING),0, ObjectSchema.UNLIMITED); cs.add(BOOK_EDITOR, (PrimitiveSchema) getSchema(BasicOntology.STRING), ObjectSchema.OPTIONAL);

// Structure of the Buy predicate PredicateSchema ps = (PredicateSchema) getSchema(BUY); ps.add(BUY_BOOK, (ConceptSchema) getSchema(BOOK));

}

}

// Structure of the Costs predicate ps = (PredicateSchema) getSchema(COSTS); ps.add(COSTS_BOOK, (ConceptSchema) getSchema(BOOK)); ps.add(COSTS_PRICE, (PrimitiveSchema) getSchema(BasicOntology.INTEGER)); // Structure of the Sell agent action AgentActionSchema as = (AgentActionSchema) getSchema(SELL); as.add(SELL_BOOK, (ConceptSchema) getSchema(BOOK)); } catch( OntologyException oe) { oe.printStackTrace(); }



8.6JADE bericht met Ontologie object Om een beeld te krijgen van hoe een Java object wordt gecodeerd tot een ontologie JADE object is hieronder in “Figuur 14, Inform bericht” te zien dat als laatste ter bevestiging van de transactie wordt verstuurd van de “seller” agent naar de “buyer” agent. In het content gedeelde is de gecodeerde versie te zien van het “Costs” Java object. Dit frame is op te vragen door met de alternative muisknop op een berichtpijl te klikken in de “Sniffer”, zie “Figuur 13, Sniffer”.

Figuur 14, Inform bericht



9.Protocollen In JADE zijn een aantal standaart intercatie protocollen gedeainieerd en gedeeltelijk geïmplementeerd waarvan gebruik gemaakt kan worden. In het “Book-‐Trading” project is het protocol FIPA-‐Contract-‐Net interactie protocol gebruikt. Het grote voordeel is dat de interactie geïmplementeerd is, en dat alleen de verschillende berichten moeten worden afgehandeld door de bijbehorende functies te implementeren. 9.1Voorbereiding Als voorbereiding voor dit hoofdstuk is het aan te raden de vierde paragraaf van hoofdstuk 5 van het studieboek te hebben doorgenomen. 9.2FIPA-ContractNet-Protocol Het protocol FIPA-‐ContractNet ken een aantal berichten, het “CFP” bericht waarop geantwoord wordt met een “Propose”, deze kan gevolgd worden door een “Reject-‐Proposal” of een “Accept-‐Proposal” die beantwoord word met een “Inform” bericht. Zie “” voor het protocol en “Figuur 13, Sniffer” voor de berichtaahandeling.

Figuur 15, FIPA-Contract Net-Protocol



Nu is het zo dat het studieboek hierin iets te kort komt door niet alle functies te implementeren van de “ContractNetInitiator” en helemaal niet die van de “ContractNetResponder”. Om niet de gehele broncode van het “Book-‐Trading” project over de kop te gooien zijn in de volgende twee paragrafen alleen het raamwerk van de “ContractNetInitiator” en “ContractNetResponder” klassen weergegeven. 9.3ContractNetInitiator Hieronder de te implementeren functies van de “ContractNetInitiator”. 9.3.1prepareCfps Om de één of meerdere “CFP” berichten te versturen moet de functie “prepareCfps” worden geïmplementeerd. Het framewerk van dit bericht kan worden meegegeven aan de constructie functie van deze klasse. Als resultaat een lijst van berichten dit verzonden kunnen worden. 9.3.2handlePropose Als er een “Propose” bericht wordt verstuurd door de “ContractNetResponder” wordt deze procedure afgeroepen, hierop kan worden gereageerd door een “REJECT_PROPOSAL” te versturen of een “ACCEPT_PROPOSAL”. Eventueel kan eerder gemaakte berichten worden aangepast en nieuwe worden toegevoegd. 9.3.3handleInform Als er een “ACCEPT_PROPOSAL” is vertuurt moet daar met een “INFORM” op worden gereageerd door de “ContractNetResponder”. Deze procedure wordt voor elk van deze berichten afgeroepen en kan er nog iets mee gedaan worden. 9.3.4handleAllResponses Dit is een generieke procedure waarbij alle ontvangen berichten kunnen worden bekeken en eventueel afgehandeld. Binnen deze procedure kunnen ook de “NOT_UNDERSTOOD”, “REFUSE” en “FAILURE” worden afgehandeld. De binnen gekomen berichten worden eerst aan deze procedure meegegeven en daarna aan de speciaieke functie “handlePropose” en “handleInform”.



9.3.5DemoInitiator Hieronder de Java broncode van de “DemoInitiator” klasse.


Verdiepingsverslag ABI Ontwikkelen van een Multi-Agent systeem met JADE Versie : 0.4 Datum : 18-‐5-‐2009 Status : Afstudeer opdracht van ABI -‐ groep 6. import import import import

java.util.Vector; jade.core.*; jade.lang.acl.ACLMessage; jade.proto.*;

public class DemoInitiator extends ContractNetInitiator {

public DemoInitiator(Agent a, ACLMessage cfp) { super(a, cfp); }

// Agents private AID[] agents;

protected Vector prepareCfps(ACLMessage cfp) { for (int i = 0; i < agents.length; i++) { cfp.addReceiver(agents[i]); } Vector v = new Vector(); v.add(cfp); return v; }

protected void handleAllResponses( Vector responses, Vector acceptances) { boolean done = false; for (int i = 0; i < responses.size(); i++) { ACLMessage rsp = (ACLMessage) responses.get(i); switch (rsp.getPerformative()) { case ACLMessage.NOT_UNDERSTOOD: break; case ACLMessage.REFUSE: break; case ACLMessage.PROPOSE: break; case ACLMessage.FAILURE: break; case ACLMessage.INFORM: break; case ACLMessage.INFORM_REF: break; } } }

protected void handlePropose(ACLMessage propose, Vector acceptances) { ACLMessage reply = propose.createReply(); reply.setPerformative(ACLMessage.REJECT_PROPOSAL); if (true || false) { reply.setPerformative(ACLMessage.ACCEPT_PROPOSAL); } acceptances.add(reply); }

}

protected void handleInform(ACLMessage inform) { }



9.4ContractNetResponder Hieronder de te implementeren functies van de “ContractNetResponder”. 9.4.1handleCfp Als er een “CFP” bericht wordt ontvangen moet daarop een bericht worden gemaakt met “REFUSE” of “PROPOSE” als antwoord naargelang de aahandeling van het “CFP” bericht. Deze functie handelt dat af en geeft het antwoord bericht terug. 9.4.2handleAcceptProposal Als er een “ACCEPT_PROPOSAL” bericht wordt ontvangen moet daarop een bericht worden gemaakt met “FAILURE” of “INFORM” als antwoord naargelang de aahandeling van het “ACCEPT_PROPOSAL” bericht. Deze functie handelt dat af en geeft het antwoord bericht terug. 9.4.3handleResultNotiQication Deze functie handelt het resultaat bericht af en kan nog speciaieke acties worden gedaan, dan wel de status van het resultaat bericht aanpassen. Deze functie geeft het antwoord bericht terug.



9.4.4DemoResponder Hieronder de Java broncode van de “DemoResponder” klasse. import jade.core.Agent; import jade.lang.acl.*; import jade.proto.ContractNetResponder; public class DemoResponder extends ContractNetResponder {

public DemoResponder(Agent a, MessageTemplate mt) { super(a, mt); }

protected ACLMessage handleCfp(ACLMessage cfp) { ACLMessage reply = cfp.createReply(); reply.setPerformative(ACLMessage.REFUSE); if (true || false) { reply.setPerformative(ACLMessage.PROPOSE); } return reply; }

protected ACLMessage handleAcceptProposal(ACLMessage cfp, ACLMessage propose, ACLMessage accept) { ACLMessage reply = accept.createReply(); reply.setPerformative(ACLMessage.FAILURE); if (true || false) { reply.setPerformative(ACLMessage.INFORM); } return reply; }

protected ACLMessage prepareResultNotification(ACLMessage request, ACLMessage response) { ACLMessage reply = request.createReply(); if (response != null && response.getPerformative() == ACLMessage.PROPOSE) { reply.setPerformative(ACLMessage.INFORM); } else { reply.setPerformative(ACLMessage.FAILURE); } return reply; }

}



10.Conclusie Eigenlijk is er geen goede conclusie te geven, het ontwikkelen van een multi-‐agent omgeving is totaal andere dan de client-‐server wijze van het implementeren van de processen en taken van processen. Iedere proces, agent, kan zowel client als ook server zijn. Bij een client-‐server model moet de ontwikkelaar veel taken zelf implementeren, daarin tegen bij het implementeren van processen en taken in een multi-‐agent systeem kan gebruik gemaakt worden van standaard protocollen en standaard taken. Het uitwisselen van (Java) objecten is ook redelijk simpel waardoor er redelijk snel iets ontwikkeld kan worden. JADE bied voldoende mogelijkheden om een multi-‐agent omgeving te kunnen ontwikkelen.



11.Referenties / Brondocumenten Hieronder een paar van de belangrijkste referenties en brondocumenten. Nr

Titel

1

Developing multi-‐agent systems with JADE

2 3 4 5 6 7 8 9

Auteur

F. Bellifemine, G Caire, D. Greenwood Eclipse, http://www.eclipse.org open source communitie JADE, http://jade.tilab.com open source communitie SVN, http://subclipse.tigris.org open source communitie JadeDemo broncode, https://svnext.ou.nl/ Team 6 ABI Open INF_Studenten_ABI_team6/tag/JadaDemo Universiteit JadeServer broncode, https://svnext.ou.nl/ Team 6 ABI Open INF_Studenten_ABI_team6/tag/JadaServer Universiteit JadeServer documentatie, JadeServer.doc Team 6 ABI Open Universiteit Netvisma_3 broncode, Team 6 ABI Open https://svnext.ou.nl/INF_Studenten_ABI_team6/tag/netvisma_3 Universiteit Netvisma_3 installatie document, Installatie NetvisMA.doc Team 6 ABI Open Universiteit


Ontwikkelen van een Multi-Agent systeem met Jade in Eclipse

Recommend Documents