Sei sulla pagina 1di 76

package JAM;

import java.rmi.*;
import java.util.*;
/**
* Interfaccia dell'Agent Directory Service Layer.
* @author Devalle Trevor
* @version 1.0;
*/
public interface ADSL extends Remote {
/**
* Restituisce una lista di riferimenti ad oggetti (remoti) di tipo
* <i>RemoteMessageBox</i> i cui proprietari sono uguali all'AgentID.
* @param agentID - Proprietario della MessageBox cercata.
* @return Lista delle caselle postali remote avente il proprietario
*
cercato.
* @throws RemoteException
*
Errore dovuto alla mancata connessione all'oggetto remoto.
*/
List<RemoteMessageBox> getRemoteMessageBox(AgentID agentID)
throws RemoteException;
/**
* Registra una MessageBox indicata nei parametri nella ADSL.
* @param remoteMessageBox
*
- Riferimento alla MessageBox che si vuole inserire.
* @throws RemoteException
*
Eccezione restituita in caso di inserimento multiplo di una
*
MessageBox o alla mancata connesione all'oggetto remoto.
*/
void insertRemoteMessageBox(RemoteMessageBox remoteMessageBox)
throws RemoteException;
/**
* Rimuove la MessageBox indicata nei parametri dall'ADSL.
* @param remoteMessageBox
*
- Riferimento alla MessageBox che si vuole rimuovere.
* @throws RemoteException
*
Eccezione restituita in caso di rimozione di una MessageBox
*
non presente o alla mancata connesione all'oggetto remoto.
*/
void removeRemoteMessageBox(RemoteMessageBox remoteMessageBox)
throws RemoteException;
}
package JAM;
import java.net.*;
import java.rmi.*;
import java.rmi.server.*;
import java.util.*;

/**
* Implementazione dell'interfaccia Agent Directory Service Layer. Al suo
* interno contiene metodi e variabili per poter essere trattata come un
* implementazione di un oggetto Observable (java.util.Observable) ma solo per
* osservatori di tipo ASDLMonitor.
*
* @author Devalle Trevor
* @version 1.0;
*/
public class ADSLImpl extends UnicastRemoteObject implements ADSL {
/**
* Il numero di versione seriale che identifica la compatibilita' di una
* classe con le sue istanze serializzate.
*/
private static final long serialVersionUID = 1L;
/**
* Lista delle MessageBox registrate nell'ADSL
*/
private List<RemoteMessageBox> messageBoxes;
/**
* Numero di porta sulla quale contattare l'RMI Registry
*/
private int port;
/**
* Nome con il quale l'oggetto ADSL e' registrato sul RMI Registry
*/
private String name;
/**
* Flag relativo allo stato dell'oggetto (modificato o no)
*/
private boolean changed = false;
/**
* Elenco degli osservatori dell'oggetto
*/
private Vector obs;
/**
* Messaggio aggiuntivo inviato durante la notifica a gli ascoltatori
*/
private String log;
/**
* Metodo costruttore di un ADSL vuoto, senza MessageBox registrate. Per
* default il valore della porta e' settato su 1099 e il nome e' 'ADSL'.
* @throws RemoteException

*
Errore dovuto alla mancata connessione all'oggetto remoto.
*/
public ADSLImpl() throws RemoteException {
super();
this.messageBoxes = new LinkedList<RemoteMessageBox>();
this.port = 1099;
this.name = "ADSL";
this.obs = new Vector();
}
/**
* Restituisce la porta sulla quale verra' contatato il registro di bootstrap
* (RMI Registry).
* @return Il numero di porta memorizzato.
*/
public int getPort() {
return port;
}
/**
* Restituisce il nome con il quale verra' registrato questo oggetto ADSL
* nell'RMI Registry.
* @return Il nome con cui verra' identificato questo oggetto ADSL.
*/
public String getName() {
return name;
}
/**
* Modifica il valore della porta sulla quale contattare l'RMI Registry.
* @param port
*
- Nuovo valore della porta da impostare.
*/
public void setPort(int port) {
this.port = port;
}
/**
* Modifica il nome con il quale questo oggetto ADSL verra' memorizzato nel
* RMI Registry.
* @param name
*
- Nuovo nome da memorizzare.
*/
public void setName(String name) {
this.name = name;
}
/**
* Avvia il servizio di RMI Registry sulla porta impostata nell'oggetto
* ADSL.

*/
public void startRMIRegistry() {
try {
java.rmi.registry.LocateRegistry.createRegistry(this.getPort());
log = "START RMI Registry on port " + this.getPort();
setChanged();
notifyObservers(log);
} catch (RemoteException e) {
System.out
.println("Errore nella creazione del RMI registry sulla porta
"
+ this.getPort());
e.printStackTrace();
}
}
/**
* Registra l'oggetto ADSL invocante il metodo nel RMI Registry.
*/
public void startADSL() {
try {
Naming.rebind(
"rmi://127.0.0.1:" + this.getPort() + "/" + this.getName(),
this);
log = "REBIND ADSL to RMI Registry";
setChanged();
notifyObservers(log);
} catch (RemoteException | MalformedURLException e) {
System.out.println("Errore nel rebind dell'ADSL sul RMI registry");
e.printStackTrace();
}
}
/**
* Rimuove l'oggetto ADSL invocante dal RMI Registry.
*/
public void stopADSL() {
try {
Naming.unbind("rmi://127.0.0.1:" + this.getPort() + "/"
+ this.getName());
log = "UNBIND ADSL from RMI Registry";
setChanged();
notifyObservers(log);
} catch (RemoteException | MalformedURLException |
NotBoundException e) {
System.out
.println("Errore nella cancellazione dell'ADSL dal RMI
registry");
}
}

/**
* Ricerca una MessageBox proprieta' dell'agente passato nei parametri.
* @param agentID - Proprietario della MessageBox cercata
* @return La posizione in cui si trova la prima MessageBox valida per la
*
ricerca, -1 altrimenti.
*/
synchronized public int isThereRemoteMessageBox(AgentID agentID) {
Iterator<RemoteMessageBox> iter = this.messageBoxes.iterator();
RemoteMessageBox temp;
int i = 0;
while (iter.hasNext()) {
temp = iter.next();
try {
if (temp.getOwner().equals(agentID)) {
return i;
}
} catch (RemoteException e) {
System.out
.println("Errore nella connessione all'oggetto
remoto");
e.printStackTrace();
}
i++;
}
return -1;
}
@Override
synchronized public List<RemoteMessageBox> getRemoteMessageBox(
AgentID agentID) throws RemoteException {
Iterator<RemoteMessageBox> iter = this.messageBoxes.iterator();
List<RemoteMessageBox> result = new
LinkedList<RemoteMessageBox>();
RemoteMessageBox temp;
while (iter.hasNext()) {
temp = iter.next();
if (temp.getOwner().equals(agentID)) {
result.add(temp);
}
}
log = "REQUEST " + agentID.toString() + " MessageBox";
setChanged();
notifyObservers(log);
return result;
}
@Override

synchronized public void insertRemoteMessageBox(


RemoteMessageBox remoteMessageBox) throws RemoteException
{
if (isThereRemoteMessageBox(remoteMessageBox.getOwner()) == -1) {
this.messageBoxes.add(remoteMessageBox);
log = "INSERT " + remoteMessageBox.getOwner().toString()
+ " MessageBox";
setChanged();
notifyObservers(log);
} else {
throw new RemoteException();
}
}
@Override
synchronized public void removeRemoteMessageBox(
RemoteMessageBox remoteMessageBox) throws RemoteException
{
int t = isThereRemoteMessageBox(remoteMessageBox.getOwner());
if (t != -1) {
this.messageBoxes.remove(t);
log = "REMOVE " + remoteMessageBox.getOwner().toString()
+ " MessageBox";
setChanged();
notifyObservers(log);
} else {
throw new RemoteException();
}
}
// code from Observable (JAVA)
/**
* Registra un oggetto ADSLMonitor alla lista degli osservatori (nel caso
* quest'ultimo non sia gia' registrato).
* @param o - Osservatore da aggiungere.
* @throws NullPointerException
*
Eccezione lanciata in caso si parametro nullo.
*/
public synchronized void addObserver(ADSLMonitor o) {
if (o == null)
throw new NullPointerException();
if (!obs.contains(o)) {
obs.addElement(o);
}
}

/**
* Rimuove l'oggeto passato come parametro dalla lista degli osservatori.
* @param o - Osservatore da rimuovere.
*/
public synchronized void deleteObserver(Observer o) {
obs.removeElement(o);
}
/**
* Metodo di notifica verso gli osservatori di un avvenuto cambiamento.
*/
public void notifyObservers() {
notifyObservers(null);
}
/**
* Metodo di notifica verso gli ascoltatori di un avvenuto cambiamento, con
* la possibilita' di inoltrare informazioni aggiuntive grazie al parametro
* <i>arg</i>.
* @param arg - Argomento extra della notifica.
*/
public void notifyObservers(Object arg) {
Object[] arrLocal;
synchronized (this) {
if (!changed)
return;
arrLocal = obs.toArray();
clearChanged();
}
for (int i = arrLocal.length - 1; i >= 0; i--)
((ADSLMonitor) arrLocal[i]).update(this, arg);
}
/**
* Rimuove tutti gli ascoltatori dalla lista delgi ascoltatori registrati.
*/
public synchronized void deleteObservers() {
obs.removeAllElements();
}
/**
* Imposta a <i>true</i> il flag <i>changed</i> che segnala se l'oggetto e'
* stato modificato. Occorre invocare questo metodo dopo ogni modifica che
* vada notifcata a gli ascoltatori.
*/
protected synchronized void setChanged() {
changed = true;
}

/**
* Imposta a <i>false</i> il flag <i>changed</i> che segnala se l'oggetto e'
* stato modificato. Occorre invocare questo metodo dopo aver notificato gli
* osservatori per evitare segnalazioni multiple di uno stesso cambiamento.
*/
protected synchronized void clearChanged() {
changed = false;
}
/**
* Restituisce lo stato del flag <i>changed</i> che segnala la presenza di
* modifiche da dover notificare a gli osservatori.
* @return <i>true</i> se l'oggetto e' stato modificato e non e' ancora
*
partita la segnalazione a gli osservatori, <i>false</i>
*
altrimenti.
*/
public synchronized boolean hasChanged() {
return changed;
}
/**
* Restituisce il numero di osservatori registrati presso questo oggetto.
* @return Il numero di osservatori registrati.
*/
public synchronized int countObservers() {
return obs.size();
}
}
package JAM;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
/**
* Interfaccia grafica per l'interazione e l'osservazione degli oggetti ADSL.
* Permette di modificarne il comportamento e di leggere a video lo storico
* delle operazioni compiute dall'oggetto.
* @author Devalle Trevor
* @version 1.0;
*/
public class ADSLMonitor extends JFrame {
/**
* Il numero di versione seriale identifica la compatibilita' di una classe
* con le sue istanze serializzate.
*/
private static final long serialVersionUID = 1L;
/**

* Oggetto ADSL monitorato dalla clsse


*/
private ADSL adsl;
/**
* TextArea usata per stampare i log delle operazioni
*/
private JTextArea textArea;
/**
* Campo di testo dove verra' specificata la porta da usare per contattare
* l'RMI Registry
*/
private JTextField portField;
public ADSLMonitor(ADSL adsl) {
this.adsl = adsl;
((ADSLImpl) this.adsl).addObserver(this);
Container cp = getContentPane();
cp.setLayout(new BorderLayout());
JPanel northPanel = new JPanel(new GridLayout(2, 1));
northPanel.setBackground(Color.BLUE);
JLabel title = new JLabel("Agent Directory Service Layer Monitor",
JLabel.CENTER);
title.setForeground(Color.WHITE);
northPanel.add(title);
JPanel subnorthPanel = new JPanel(new GridLayout(1, 5));
JLabel portLabel = new JLabel("Port :", JLabel.RIGHT);
portField = new JTextField(" Choose a number >= 1024",
JLabel.CENTER);
JLabel emptyLabel = new JLabel("", JLabel.RIGHT);
subnorthPanel.add(portLabel);
subnorthPanel.add(portField);
subnorthPanel.add(emptyLabel);
northPanel.add(subnorthPanel);
cp.add(northPanel, BorderLayout.NORTH);
textArea = new JTextArea(8, 40);
textArea.setEditable(false);
JScrollPane scrollPane = new JScrollPane(textArea);
cp.add(scrollPane, BorderLayout.CENTER);
JPanel westPanel = new JPanel();
JLabel westLabel = new JLabel("<html>Connection<br>Console</html>",
JLabel.CENTER);
westPanel.add(westLabel);
cp.add(westPanel, BorderLayout.WEST);
JPanel eastPanel = new ButtonPanel();
cp.add(eastPanel, BorderLayout.EAST);
cp.add(new ExitButton(), BorderLayout.SOUTH);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
pack();

setVisible(true);
}
/**
* Avvia il servizio di RMI Registry impostandolo sulla porta indicata nel
* TextField dell'interfaccia grafica.
* @return <i>true</i> se il numero di porta e' valido ed il servizio viene
*
attivato, <i>false</i> in caso contrario.
*/
public boolean initRMI() {
int port;
try {
port = Integer.parseInt(portField.getText());
if (port < 1024)
throw new NumberFormatException();
((ADSLImpl) this.adsl).setPort(port);
((ADSLImpl) this.adsl).startRMIRegistry();
return true;
} catch (NumberFormatException e) {
this.textArea.append("Numero di porta non valido!\n");
return false;
}
}
/**
* Richiama il metodo startADSL() dell'oggetto ADSL, registrandolo sul RMI
* Registry.
*/
public void startADSL() {
((ADSLImpl) this.adsl).startADSL();
}
/**
* Richiama il metodo stopADSL() dell'oggetto ADSL, rimuovendolo dal RMI
* Registry.
*/
public void destroyADSL() {
((ADSLImpl) this.adsl).stopADSL();
}
/**
* Scrive nella TextArea al centro della GUI un log riguardante
* l'interazione con l'oggetto ADSL. Questo metodo viene invocato da
* l'oggetto osservato da ADSLMonitor in seguito ad una sua manipolazione.
* @param arg0 - Indica l'oggetto ADSL che ha notificato un cambiamento.
* @param arg1 - Contenuto della notifica ricevuta.
*/
public void update(ADSLImpl arg0, Object arg1) {
this.textArea.append((String) arg1 + "\n");

}
/**
* Classe di bottoni che in seguito alla loro pressione fanno terminare il
* programma.
*/
class ExitButton extends JButton implements ActionListener {
/**
* Crea un bottone che in seguito alla sua pressione termina il
* programma.
*/
public ExitButton() {
super("Exit");
addActionListener(this);
}
public void actionPerformed(ActionEvent e) {
System.exit(0);
}
}
/**
* Sottoclasse di JPanel contenente 3 bottoni che manipolano il
* comportamento dell'oggetto ADSL osservato da ADSLMonitor.
* @author Devalle Trevor
*/
class ButtonPanel extends JPanel implements ActionListener {
private JButton initR = new JButton("Start reg.");
private JButton startA = new JButton("Start up");
private JButton stopA = new JButton("Shutdown");
/**
* Crea un JPanel contenente 3 tasti per manipolare i principali
* comportamenti di un oggetto ADSL: <br>
* Init -> startRMIRegistry() - avvia il servizio RMI Registry <br>
* Start -> startADSL() - Registra l'oggetto ADSL invocante il metodo nel
RMI Registry.<br>
* Destroy -> stopADSL() - rimuove l'ADSL dal RMI Registry
*/
public ButtonPanel() {
super(new GridLayout(3, 1));
initR = new JButton("Init");
initR.setSize(10, 50);
add(initR);
initR.addActionListener(this);
startA = new JButton("Start");
startA.setSize(10, 50);
startA.setEnabled(false);
add(startA);
startA.addActionListener(this);
stopA = new JButton("Destroy");

stopA.setSize(10, 50);
stopA.setEnabled(false);
add(stopA);
stopA.addActionListener(this);
}
public void actionPerformed(ActionEvent e) {
Object source = e.getSource();
if (source == initR) {
if (initRMI()) {
initR.setEnabled(false);
startA.setEnabled(true);
}
} else if (source == startA) {
startADSL();
startA.setEnabled(false);
stopA.setEnabled(true);
} else {
destroyADSL();
startA.setEnabled(true);
stopA.setEnabled(false);
}
}
}
}
package JAM;
import java.io.*;
/**Interfaccia base per l'implementazione di un agente.
* @author Devalle Trevor;
* @version 1.0;
* */
public interface AgentID extends Serializable{
/**Confronta l'agente con l'oggetto passato nei parametri.
* @param agentID - Oggetto da confrontare.
* @return <code>true</code> se gli oggetti sono uguali, <code>false</
code> altrimenti.
*/
public boolean equals(Object agentID);
/**Restituisce il nome dell'agente.
* @return nome dell'agente, stringa vuota se non definito
*/
public String getName();
/**Restituisce la categoria dell'agente.
* @return categoria dell'agente, stringa vuota se non definita

*/
public String getCategory();
/**Restituisce una descrizione dell'agente
* nel formato ( <i>name</i> , <i>category</i> ).
* @return ( <i>name</i> , <i>category</i> )
*/
public String toString();
}
package JAM;
public class AskTimeAgent extends JAMAgent {
public AskTimeAgent(String category, String name) throws JAMADSLException {
super(new PersonalAgentID(category, name));
}
public static void main(String[] args) throws JAMADSLException {
AskTimeAgent asktimeagent = new AskTimeAgent("Matteo", "Baldoni");
asktimeagent.addBehaviour(new AskTimeBehaviour(asktimeagent));
AskTimeAgent asktimeagent1 = new AskTimeAgent("Mario", "Rossi");
asktimeagent1.addBehaviour(new AskTimeBehaviourRefuse(asktimeagent1));
AskTimeAgent asktimeagent2 = new AskTimeAgent("Mercoledi", "Adams");
asktimeagent2.addBehaviour(new
AskTimeBehaviourNotUnderstood(asktimeagent2));
asktimeagent.init();
asktimeagent.start();
asktimeagent1.init();
asktimeagent1.start();
asktimeagent2.init();
asktimeagent2.start();
/*new JAMAgentMonitor(asktimeagent);
new JAMAgentMonitor(asktimeagent1);
new JAMAgentMonitor(asktimeagent2);*/
}
}
package JAM;
public class AskTimeBehaviour extends JAMWhileBehaviour {
private LogFile log;
public AskTimeBehaviour(JAMAgent myAgent) {
super(myAgent);
log = new LogFile();
}
public void setup() throws JAMBehaviourInterruptedException {
try {
log.startLog(myAgent.getMyID().toString().trim(), "Log file per " +
myAgent.getMyID());
log.log("0- Inizializzazione comportamento.");

} catch(JAMIOException err) {
System.out.println("Errore: " + err);
done();
}
}
public void dispose() throws JAMBehaviourInterruptedException {
try {
log.log("END- Esecuguita dispose.");
log.endLog();
} catch(JAMIOException err) {
System.out.println("Errore: " + err);
done();
}
}
public void action() throws JAMBehaviourInterruptedException {
try {
log.log("1- Start del comportamento, attesa messaggio iniziale.");
CategoryAgentID timeProviderCategoryID = new CategoryAgentID("Time
Provider");
log.log("2- Preparo REQUEST dell'ora.");
Message request = new Message(
myAgent.getMyID(),
timeProviderCategoryID,
Performative.REQUEST,
"Che ora e'?"
);
log.log("3- Invio REQUEST.", request);
myAgent.send(request);
log.log("4- Inviata REQUEST.", request);
log.log("5- Attendo risposta.");
Message answer = myAgent.receive(timeProviderCategoryID);
log.log("6- Trovata risposta.", answer);
if(answer.getPerformative() != Performative.AGREE) {
log.log("7- La risposta non e' una agree eseguo una done.", answer);
done();
} else {
log.log("8- La risposta e' una agree, prepara la conferma.", answer);
AgentID selectedProvider = answer.getSender();
Message confirm = new Message(
myAgent.getMyID(),
selectedProvider,
Performative.INFORM,
"Aspetto l'ora."
);
log.log("9- Invio la conferma.", confirm);
myAgent.send(confirm);
log.log("10- Inviata la conferma.", confirm);
log.log("11- Attendo il messaggio con l'ora da " + selectedProvider);
sleep(2000);
log.log("12- Controllo se arrivato il messaggio con l'ora da " +

selectedProvider);
if(myAgent.check(selectedProvider, Performative.INFORM)) {
log.log("13- Leggo il messaggio con l'ora da " + selectedProvider);
Message inform = myAgent.receive(selectedProvider,
Performative.INFORM);
log.log("14- Letto il messaggio con l'ora da " + selectedProvider, inform);
System.out.println(inform);
} else {
log.log("15- Nessun messagggio da " + selectedProvider);
System.out.println("Nessuna risposta, rinuncio.");
}
done();
}
} catch(JAMIOException err2) {
System.out.println("Errore: " + err2);
done();
}
}
}
package JAM;
public class AskTimeBehaviourNotUnderstood extends JAMWhileBehaviour {
private LogFile log;
public AskTimeBehaviourNotUnderstood(JAMAgent myAgent) {
super(myAgent);
log = new LogFile();
}
public void setup() throws JAMBehaviourInterruptedException {
try {
log.startLog(myAgent.getMyID().toString().trim(), "Log file per " +
myAgent.getMyID());
log.log("0- Inizializzazione comportamento.");
} catch(JAMIOException err) {
System.out.println("Errore: " + err);
done();
}
}
public void dispose() throws JAMBehaviourInterruptedException {
try {
log.log("END- Esecuguita dispose.");
log.endLog();
} catch(JAMIOException err) {
System.out.println("Errore: " + err);
done();
}
}
public void action() throws JAMBehaviourInterruptedException {
try {
log.log("1- Start del comportamento, attesa messaggio iniziale.");

CategoryAgentID timeProviderCategoryID = new CategoryAgentID("Time


Provider");
log.log("2- Preparo REQUEST dell'ora.");
Message request = new Message(
myAgent.getMyID(),
timeProviderCategoryID,
Performative.REQUEST,
// CONTENT ERRATO
"What time is it?"
);
log.log("3- Invio REQUEST.", request);
myAgent.send(request);
log.log("4- Invita REQUEST.", request);
log.log("5- Attendo risposta.");
Message answer = myAgent.receive(timeProviderCategoryID);
log.log("6- Trovata risposta.", answer);
if(answer.getPerformative() != Performative.AGREE) {
log.log("7- La risposta non e' una agree eseguo una done.", answer);
done();
} else {
log.log("8- La risposta e' una agree, prepara la conferma.", answer);
AgentID selectedProvider = answer.getSender();
Message confirm = new Message(
myAgent.getMyID(),
selectedProvider,
Performative.INFORM,
"Aspetto l'ora."
);
log.log("9- Invio la conferma.", confirm);
myAgent.send(confirm);
log.log("10- Inviata la conferma.", confirm);
log.log("11- Attendo il messaggio con l'ora da " + selectedProvider);
sleep(2000);
log.log("12- Controllo se arrivato il messaggio con l'ora da " +
selectedProvider);
if(myAgent.check(selectedProvider, Performative.INFORM)) {
log.log("13- Leggo il messaggio con l'ora da " + selectedProvider);
Message inform = myAgent.receive(selectedProvider,
Performative.INFORM);
log.log("14- Letto il messaggio con l'ora da " + selectedProvider, inform);
System.out.println(inform);
} else {
log.log("15- Nessun messagggio da " + selectedProvider);
System.out.println("Nessuna risposta, rinuncio.");
}
done();
}
/*} catch(JAMADSLException err1) {
System.out.println("Errore: " + err1);
done();*/

} catch(JAMIOException err2) {
System.out.println("Errore: " + err2);
done();
}
}
}
package JAM;
public class AskTimeBehaviourRefuse extends JAMWhileBehaviour {
private LogFile log;
public AskTimeBehaviourRefuse(JAMAgent myAgent) {
super(myAgent);
log = new LogFile();
}
public void setup() throws JAMBehaviourInterruptedException {
try {
log.startLog(myAgent.getMyID().toString().trim(), "Log file per " +
myAgent.getMyID());
log.log("0- Inizializzazione comportamento.");
} catch(JAMIOException err) {
System.out.println("Errore: " + err);
done();
}
}
public void dispose() throws JAMBehaviourInterruptedException {
try {
log.log("END- Esecuguita dispose.");
log.endLog();
} catch(JAMIOException err) {
System.out.println("Errore: " + err);
done();
}
}
public void action() throws JAMBehaviourInterruptedException {
try {
log.log("1- Start del comportamento, attesa messaggio iniziale.");
CategoryAgentID timeProviderCategoryID = new CategoryAgentID("Time
Provider");
log.log("2- Preparo REQUEST dell'ora.");
Message request = new Message(
myAgent.getMyID(),
timeProviderCategoryID,
// PERFORMATIVA ERRATA
Performative.INFORM,
"Che ora e'?"
);
log.log("3- Invio REQUEST.", request);
myAgent.send(request);
log.log("4- Invita REQUEST.", request);

log.log("5- Attendo risposta.");


Message answer = myAgent.receive(timeProviderCategoryID);
log.log("6- Trovata risposta.", answer);
if(answer.getPerformative() != Performative.AGREE) {
log.log("7- La risposta non e' una agree eseguo una done.", answer);
done();
} else {
log.log("8- La risposta e' una agree, prepara la conferma.", answer);
AgentID selectedProvider = answer.getSender();
Message confirm = new Message(
myAgent.getMyID(),
selectedProvider,
Performative.INFORM,
"Aspetto l'ora."
);
log.log("9- Invio la conferma.", confirm);
myAgent.send(confirm);
log.log("10- Inviata la conferma.", confirm);
log.log("11- Attendo il messaggio con l'ora da " + selectedProvider);
sleep(2000);
log.log("12- Controllo se arrivato il messaggio con l'ora da " +
selectedProvider);
if(myAgent.check(selectedProvider, Performative.INFORM)) {
log.log("13- Leggo il messaggio con l'ora da " + selectedProvider);
Message inform = myAgent.receive(selectedProvider,
Performative.INFORM);
log.log("14- Letto il messaggio con l'ora da " + selectedProvider, inform);
System.out.println(inform);
} else {
log.log("15- Nessun messagggio da " + selectedProvider);
System.out.println("Nessuna risposta, rinuncio.");
}
done();
}
/*} catch(JAMADSLException err1) {
System.out.println("Errore: " + err1);
done();*/
} catch(JAMIOException err2) {
System.out.println("Errore: " + err2);
done();
}
}
}
package JAM;
import java.util.Random;
/**
* Tipologia di agente dedicata alla gestione dell'asta (nel ruolo del
* banditore). Ogni agente di questo tipo rappresenta lui stesso l'oggetto in
* asta, infatti il nome dell'agente corrisponde al nome dell'oggetto.

* @author Devalle Trevor


* @version 1.0;
*/
public class AuctioneerAgent extends JAMAgent {
/**
* Valore attuale dell'oggetto
*/
private Integer value;
/**
* Vincitore corrente dell'asta
*/
private AgentID winner;
/**
* Flag rappresentante l'avvenuta assegnazione dell'oggetto
*/
private boolean awarded;
/**
* Generatore di valori randomici
*/
Random rnd = new Random();
/**
* Crea un nuovo agente banditore che prendera' il nome dell'oggetto di cui
* gestira' l'asta. <br>
* Durante la creazione viene creato il comportamento del banditore e
* aggiunto alla lista dei comportamenti di questo agente.
* @param s - Stringa contenente il nome dell'oggetto da mettere in asta.
* @throws JAMADSLException
*
Errore dovuto alla mancata connessione con l'oggetto remoto.
*/
public AuctioneerAgent(String s) throws JAMADSLException {
super(new PersonalAgentID(s, "Auctioneer"));
this.winner = this.getMyID();
this.awarded = false;
JAMWhileBehaviour jb = new AuctioneerServerBehaviour(this);
this.addBehaviour(jb);
}
/**
* Restituisce lo stato di assegnazione dell'asta.
* @return <i>true</i> se l'asta e' terminata per assegnazione dell'oggetto,
*
<i>false</i> se l'asta e' ancora aperta.
*/
public boolean isAwarded() {
return awarded;
}

/**
* Imposta il valore della variabile <i>awarded</i> al valore passato come
* parametro.
* @param awarded - Nuovo valore della variabile da impostare.
*/
public void setAwarded(boolean awarded) {
this.awarded = awarded;
}
/**
* Restituisce il riferimento al vincitore corrente.
* @return L'agente che si sta aggiudicando l'asta al momento.
*/
public AgentID getWinner() {
return winner;
}
/**
* Imposta il vincitore dell'asta sostituendolo con quello passato via
* parametro.
* @param winner - Nuovo vincitore corrente dell'asta.
*/
public void setWinner(AgentID winner) {
this.winner = winner;
}
/**
* Restituisce il valore corrente dell'oggetto in asta.
* @return Il valore corrente dell'oggetto in asta.
*/
public Integer getValue() {
return this.value;
}
/**
* Imposta il nuovo valore dell'oggetto in asta con quello passato come
* parametro.
* @param newValue - Nuovo valore da assegnare all'oggetto corrente.
*/
public void setValue(Integer newValue) {
this.value = newValue;
}
/**
* Inizializza il valore iniziale dell'oggetto d'asta. <br>
* Il parametro <i>i</i> rappresenta il numero di migliaia massimo che puo'
* raggiungere il valore iniziale.
* @param i - Numero di migliaia massimo che puo' raggiungere il valore
iniziale.
*/

public void setRandomValue(int i) {


this.value = rnd.nextInt(i) * 1000;
}
public static void main(String args[]) throws JAMADSLException {
AuctioneerAgent auctioneer = new AuctioneerAgent("Uovo di Faberge'");
auctioneer.init();
auctioneer.start();
}
}
package JAM;
/**
* Comportamento del banditore, estensione di un JAMWhileBehaviour, che gestisce
* l'andamento dell'asta. Si occupa di inizializzare un file di log dove
* registra i messaggi ricevuti e inviati e di valutare le proposte ricevute.
* L'asta prosegue finche' vengono ricevute richieste ma si interrompe dopo circa
* 10 secondi in caso di inattivita'. Il banditore decide di assegnare l'oggetto
* all'ultimo scommettitore se riceve 5 messaggi di fila da quest'ultimo, poiche'
* significa che tutti gli altri partecipanti si sono ritirati, avendo smesso di
* puntare.
* @author Devalle Trevor
* @version 1.0;
*/
public class AuctioneerServerBehaviour extends JAMWhileBehaviour {
/**
* File di log associato a questo comportamento dove vengono registrate le
* operazioni di questo comportamento
*/
private LogFile log;
/**
* Contatore dei messaggi ricevuti di seguito avente come mittente il
* vincitore
*/
private int counter = 0;
/**
* Metodo costruttore di un AuctioneerServerBehaviour appartenente
* all'agente passato come parametro.
* @param ja - Proprietario del comportamento.
*/
public AuctioneerServerBehaviour(JAMAgent ja) {
super(ja);
log = new LogFile();
}
@Override

protected void setup() throws JAMBehaviourInterruptedException {


try {
log.startLog(myAgent.getMyID().toString().trim(), "Log file per "
+ myAgent.getMyID());
log.log("0 - Inizializzazione comportamento.");
((AuctioneerAgent) myAgent).setRandomValue(25);
log.log("1 - Inizializzazione valore oggetto a "
+ ((AuctioneerAgent) myAgent).getValue());
this.sleep(5000);
} catch (JAMIOException err) {
System.out.println("Errore: " + err);
done();
}
}
@Override
protected void action() throws JAMBehaviourInterruptedException {
int timer = 0;
Message message = null;
try {
log.log("2 - Start del comportamento, attesa messaggio iniziale.");
if (myAgent.check()) {
message = myAgent.receive();
log.log("3 - Ricevuto messaggio iniziale, inizio sua analisi");
log.log("Mittente: " + message.getSender().toString());
log.log("Performativa: " +
message.getPerformative().toString());
log.log("Contenuto: " + message.getContent());
if (message.getPerformative() == Performative.QUERY_IF
&& message.getContent().equals("Valore
corrente?")) {
// mi stanno chiedendo il prezzo corrente, devo rispondere
// REFUSE se ho finito l'asta
// INFORM con il valore corrente altrimenti
log.log("4 - Ricevuto messaggio QUERY_IF - 'Valore
corrente?'");
if (!((AuctioneerAgent) myAgent).isAwarded()) {
log.log("5a - L'asta e' in corso, preparo la INFORM");
Message infMess = new
Message(myAgent.getMyID(),
message.getSender(),
Performative.INFORM,
((AuctioneerAgent) myAgent).getValue()
.toString(),
((AuctioneerAgent)
myAgent).getWinner());
System.out.println(((AuctioneerAgent) myAgent)

.getValue().toString());
myAgent.send(infMess);
log.log("6a - INFORM inviata");
} else {
log.log("5b - L'oggetto e' gia' stato assegnato,
preparo la REFUSE");
Message refMess = new
Message(myAgent.getMyID(),
message.getSender(),
Performative.REFUSE,
((AuctioneerAgent) myAgent).getValue()
.toString(),
((AuctioneerAgent)
myAgent).getWinner());
myAgent.send(refMess);
log.log("6b - REFUSE inviata");
}
} else if (message.getPerformative() ==
Performative.REQUEST) {
// mi stanno mandando un offerta (il cui valore e' dentro il
// messaggio)
// REFUSE se la proposta e' inferiore
// INFORM se e' la migliore offerta
log.log("4 - Ricevuto messaggio REQUEST, valuto
l'offerta");
log.log("Mittente: " + message.getSender().toString());
log.log("Puntata: " + message.getContent());
log.log("Valore attuale: "
+ ((AuctioneerAgent)
myAgent).getValue().toString());
Integer offert;
try {
offert = new Integer(message.getContent());
} catch (NumberFormatException err1) {
offert = new Integer(-1);
}
if (((AuctioneerAgent) myAgent).getValue() < offert) {
log.log("5a - L'offerta e' migliore di quella attuale,
aggiorno i dati e preparo INFORM");
log.log(offert.toString()
+">"
+ ((AuctioneerAgent) myAgent).getValue()
.toString());
((AuctioneerAgent) myAgent).setValue(offert);
((AuctioneerAgent) myAgent).setWinner(message
.getSender());
Message infMess = new
Message(myAgent.getMyID(),
message.getSender(),
Performative.INFORM,

((AuctioneerAgent) myAgent).getValue()
.toString(),
((AuctioneerAgent)
myAgent).getWinner());
myAgent.send(infMess);
log.log("6a - INFORM inviata");
} else {
log.log("5a - L'offerta non supera quella attuale,
preparo REFUSE");
Message refMess = new
Message(myAgent.getMyID(),
message.getSender(),
Performative.REFUSE,
((AuctioneerAgent) myAgent).getValue()
.toString(),
((AuctioneerAgent)
myAgent).getWinner());
myAgent.send(refMess);
log.log("6b - REFUSE inviata");
}
} else {
// qualsiasi altro caso
log.log("4 - Ricevuto un messaggio che non so
interpretare");
log.log("5 - Preparo un NOT_UNDERSTOOD");
Message notMess = new Message(myAgent.getMyID(),
message.getSender(),
Performative.NOT_UNDERSTOOD,
"Messaggio non valido");
myAgent.send(notMess);
log.log("6 - NOT_UNDERSTOOD inviata");
}
log.log("");
if (((AuctioneerAgent) myAgent).getWinner().equals(
message.getSender())) {
counter++;
} else {
counter = 0;
}
if (counter == 5) {
log.log("### - Quinto messaggio di fila da parte del
vincitore! Asta conclusa.");
((AuctioneerAgent) myAgent).setAwarded(true);
}
if (counter == 6) {
log.log("### - Ultimo REFUSE mandato, posso
spegnermi.");
done();
return;// altrimenti continua esecuzione action()
}

}
while (!myAgent.check()) {
this.sleep(1000);
timer++;
if (timer == 10) {
log.log("*** - Non ricevo messaggi da almeno 10
secondi");
done();
return;
}
}
timer = 0;
} catch (JAMIOException err2) {
System.out.println("Errore: " + err2);
done();
}
}
@Override
protected void dispose() throws JAMBehaviourInterruptedException {
try {
log.log("#- " + ((AuctioneerAgent) myAgent).getWinner().toString()
+ " si aggiudica "
+ ((AuctioneerAgent) myAgent).getMyID().getName() + "
per "
+ ((AuctioneerAgent) myAgent).getValue());
log.log("END - Eseguita dispose.");
log.endLog();
System.out.println("terminato" + myAgent.getMyID().toString());
} catch (JAMIOException err) {
System.out.println("Errore: " + err);
done();
}
}
}
package JAM;
import java.util.Random;
/**
* Tipologia di agente simulante uno scommettitore ad un asta. Questo agente e'
* in competizione con altri agenti dello stesso tipo per aggiudicarsi un
* oggetto messo all'asta da un agente di tipo banditore (AuctioneerAgent). In
* base al valore raggiunto dall'oggetto e al budget disponibile, vengono
* calcolate delle puntate atte ad aggiudicarsi l'asta.
* @author Devalle Trevor
* @version 1.0;
*/
public class BidderAgent extends JAMAgent {

/**
* Budget massimo utilizzabile per le puntate
*/
private Integer budget;
/**
* Valore corrente dell'oggetto in asta
*/
private Integer value;
/**
* Valore dell'ultima puntata eseguita
*/
private Integer currentBet;
/**
* Attuale vincitore dell'asta
*/
private AgentID winner;
/**
* Generatore di valori randomici
*/
Random rnd = new Random();
/**
* Metodo costruttore di un agente scommettitore avente nome pari al
* parametro <i>s</i> e categoria <i>Bidder</i>. Durante la creazione viene
* assegnato un comportamento di tipo <i>BidderClientBehaviour</i> che si
* occupera' di gestire la partecipazione all'asta.
* @param s - Nome dell'agente scommettitore.
* @throws JAMADSLException
*
Eccezione lanciata in caso di mancata creazione dell'oggetto.
*/
public BidderAgent(String s) throws JAMADSLException {
super(new PersonalAgentID(s, "Bidder"));
this.addBehaviour(new BidderClientBehaviour(this));
}
/**
* Restituisce il valore del budget di questo agente.
* @return Il budget a disposizione.
*/
public Integer getBudget() {
return budget;
}
/**
* Imposta il valore del budget dell'agente. <br>
* Il parametro <i>i</i> rappresenta il numero massimo di migliaia che puo'

* assumere il valore del budget.


* @param i - Numero massimo di migliaia che possono essere impostate
come
*
budget.
*/
public void setRandomBudget(int i) {
this.budget = rnd.nextInt(i) * 1000;
}
/**
* Calcola una nuova puntata tenendo presente il budget e il valore attuale
* dell'asta. Se il budget e' minore o uguale al valore attuale dell'oggetto
* viene puntato il budget, altrimenti si calcola una puntata ammissibile
* superiore al valore attuale.
*/
public Integer makeBet() {
return (this.getBudget() - 1) <= this.getValue() ? this.getBudget()
: rnd.nextInt(this.getBudget() - this.getValue())
+ this.getValue();
}
/**
* Restituisce il riferimento al vincitore corrente.
* @return L'agente che si sta aggiudicando l'asta al momento.
*/
public AgentID getWinner() {
return winner;
}
/**
* Imposta il vincitore dell'asta sostituendolo con quello passato via
* parametro.
* @param winner - Nuovo vincitore corrente dell'asta.
*/
public void setWinner(AgentID winner) {
this.winner = winner;
}
/**
* Restituisce il valore corrente dell'oggetto in asta.
* @return Il valore corrente dell'oggetto in asta.
*/
public Integer getValue() {
return value;
}
/**
* Imposta il nuovo valore dell'oggetto in asta con quello passato come
* parametro.
* @param newValue - Nuovo valore da assegnare all'oggetto corrente.

*/
public void setValue(Integer value) {
this.value = value;
}
/**
* Restituisce il valore corrente dell'ultima puntata effettuata da questo agente.
* @return Il valore dell'ultima puntata effettuata.
*/
public Integer getCurrentBet() {
return currentBet;
}
/**
* Imposta il nuovo valore dell'ultima puntata effettuata, sostituendolo
* con quello passato come parametro.
* @param currentBet - Valore dell'ultima puntata effettuata.
*/
public void setCurrentBet(Integer currentBet) {
this.currentBet = currentBet;
}
public static void main(String[] args) throws JAMADSLException {
BidderAgent b1 = new BidderAgent("b1");
BidderAgent b2 = new BidderAgent("b2");
BidderAgent b3 = new BidderAgent("b3");
BidderAgent b4 = new BidderAgent("b4");
BidderAgent b5 = new BidderAgent("b5");
BidderAgent b6 = new BidderAgent("b6");
b1.init();
b2.init();
b3.init();
b4.init();
b5.init();
b6.init();
b1.start();
b2.start();
b3.start();
b4.start();
b5.start();
b6.start();
}
}
package JAM;
/**
* Comportamento delo scommettitore, estensione di un JAMWhileBehaviour, che
* gestisce la partecipazione all'asta. Si occupa di inizializzare un file di
* log dove registra i messaggi ricevuti e inviati e di cercare di vincere

* l'asta. L'asta prosegue finche' e' possibile effettuare puntate, ovvero finche'
* il valore dell'oggetto non supera il budget a disposizione. Questo
* comportamento prosegue finche' e' possibile efettuare puntate o fino alla
* ricezione da parte del banditore di un messaggio che indichi la terminazione
* dell'asta.
* @author Devalle Trevor
* @version 1.0;
*/
public class BidderClientBehaviour extends JAMWhileBehaviour {
/**
* File di log associato a questo comportamento dove vengono registrate le
* operazioni di questo comportamento
*/
private LogFile log;
/**
* Metodo costruttore di un BidderClientBehaviour appartenente
* all'agente passato come parametro.
* @param ja - Proprietario del comportamento.
*/
public BidderClientBehaviour(JAMAgent ja) {
super(ja);
log = new LogFile();
}
@Override
protected void setup() throws JAMBehaviourInterruptedException {
try {
log.startLog(myAgent.getMyID().toString().trim(), "Log file per "
+ myAgent.getMyID());
log.log("0 - Inizializzazione comportamento.");
((BidderAgent) this.myAgent).setRandomBudget(100);
((BidderAgent) this.myAgent).setCurrentBet(0);
log.log("1 - Budget d'asta = "
+ ((BidderAgent) this.myAgent).getBudget());
} catch (JAMIOException err) {
System.out.println("Errore: " + err);
done();
}
}
@Override
protected void action() throws JAMBehaviourInterruptedException {
try {
log.log("2 - Start del comportamento, richiedo informazioni asta.");
log.log("3 - Preparo un QUERY_IF");
CategoryAgentID auctioneers = new CategoryAgentID("Auctioneer");
Message queryMess = new Message(myAgent.getMyID(),
auctioneers,
Performative.QUERY_IF, "Valore corrente?");

myAgent.send(queryMess);
log.log("4 - QUERY_IF inviata al banditore");
log.log("5 - Mi metto in attesa della risposta del banditore");
Message message = myAgent.receive(auctioneers);
log.log("6 - Ho ricevuto una risposta, la apro e aggiorno i dati sul
VALUE e WINNER");
log.log("winner: " + message.getExtraArgument().toString()
+ " puntando: " + message.getContent());
((BidderAgent) this.myAgent).setWinner((AgentID) message
.getExtraArgument());
((BidderAgent) this.myAgent).setValue(new Integer(message
.getContent()));
log.log("7 - Analizzo la risposta");
if (message.getPerformative() == Performative.INFORM) {
log.log("8a - Ho ricevuto una INFORM, l'asta e' in corso");
log.log("9 - Valuto se sono in testa all'asta");
if (((BidderAgent) this.myAgent).getWinner().equals(
myAgent.getMyID())) {
log.log("10a - Sono in testa, attendo");
sleep(2000);
} else {
log.log("10b - Non sono in testa, devo fare una puntata");
if (((BidderAgent) this.myAgent).getBudget() >
((BidderAgent) this.myAgent)
.getValue()) {
log.log("11a - Ho ancora budget per puntare");
Integer puntata = ((BidderAgent) this.myAgent)
.makeBet();
((BidderAgent)
this.myAgent).setCurrentBet(puntata);
log.log("12 - Ho valutato la mia puntata, preparo una
REQUEST");
log.log("Ho puntato : " + puntata.toString());
Message reqMess = new
Message(myAgent.getMyID(),
message.getSender(),
Performative.REQUEST,
puntata.toString());
myAgent.send(reqMess);
log.log("13 - REQUEST inviata");
log.log("14 - Aspetto la risposta alla mia offerta");
message = myAgent.receive(auctioneers);
if (message.getPerformative() ==
Performative.INFORM) {
log.log("15a - La mia offerta e' stata
accettata");
sleep(2000);
} else {
log.log("15b - La mia offerta non e' stata
accettata");

sleep(500);// per evitare istant re-bet e non far


// partecipare gli altri
}
} else {
log.log("11a - Budget insufficiente, mi ritiro...");
done();
}
}
} else if (message.getPerformative() == Performative.REFUSE) {
log.log("8b - Ho ricevuto una REFUSE, l'asta e' finita");
done();
} else {
log.log("8c - Ho ricevuto una risposta che non so
interpretare ...");
done();
}
log.log("");
} catch (JAMIOException err2) {
System.out.println("Errore: " + err2);
done();
}
}
@Override
protected void dispose() throws JAMBehaviourInterruptedException {
try {
log.log("# - Asta terminata per me");
log.log("Budget iniziale: "
+ ((BidderAgent) this.myAgent).getBudget());
log.log("Ultimo prezzo: " + ((BidderAgent) this.myAgent).getValue());
log.log("Ultima puntata: "
+ ((BidderAgent) this.myAgent).getCurrentBet());
log.log("Vincitore: "
+ ((BidderAgent) this.myAgent).getWinner().toString());
log.log("END- Eseguita dispose.");
log.endLog();
System.out.println("terminato" + myAgent.getMyID().toString());
} catch (JAMIOException err) {
System.out.println("Errore: " + err);
done();
}
}
}
package JAM;
/**
* Classe di agente caratterizzata da una categoria.
* @author Devalle Trevor;

* @version 1.0;
* */
public class CategoryAgentID extends GenericAgentID {
/**
* Il numero di versione seriale che identifica la compatibilita' di una
* classe con le sue istanze serializzate.
*/
private static final long serialVersionUID = 1L;
/**
* Crea un istanza di CategoryAgentID
* @param category - Categoria di appartenenza
*/
public CategoryAgentID(String category) {
super();
this.setCategory(category);
}
@Override
public boolean equals(Object agentID) {
try {
if (agentID != null) {
AgentID temp = (CategoryAgentID) agentID;
} else {
return false;
}
} catch (ClassCastException e) {
return super.equals(agentID); // false per asimm.
}
AgentID temp = (CategoryAgentID) agentID;
return this.getCategory().equals(temp.getCategory()) ? true : false;
}
}
package JAM;
/**
* Classe di agente generica.
* @author Devalle Trevor;
* @version 1.0;
* */
public class GenericAgentID implements AgentID {
/**
* Il numero di versione seriale identifica la compatibilita' di una classe
* con le sue istanze serializzate.
*/
private static final long serialVersionUID = 1L;
/**
* Nome dell'agente

*/
private String name;
/**
* Categoria dell'agente
*/
private String category;
/**
* Crea un instanza di GenericAgentID, gli attributi <i>name</i> e
* <i>category</i> vengono settati a stringa vuota.
*/
public GenericAgentID() {
super();
this.name = "";
this.category = "";
}
@Override
public String getName() {
return this.name;
}
@Override
public String getCategory() {
return this.category;
}
@Override
public String toString() {
return "( " + this.getName() + ", " + this.getCategory() + " )";
}
/**
* Sostituisce il valore di <code>name</code> con quello passato come
* parametro.
* @param name - Nome da impostare
*/
protected void setName(String name) {
this.name = name;
}
/**
* Sostituisce il valore di <code>category</code> con quello passato come
* parametro.
* @param category - Categoria da impostare
*/
protected void setCategory(String category) {
this.category = category;
}

@Override
public boolean equals(Object agentID) {
try {
if (agentID != null) {
AgentID temp = (GenericAgentID) agentID;
} else {
return false;
}
} catch (ClassCastException e) {
return super.equals(agentID); // false per asimm.
}
return true;
}
}
package JAM;
/**
* Classe d'errore relativa alle eccezioni sollevate<br>
* nell'interazione con le classi relative al ADSL.
* @author Devalle Trevor;
* @version 1.0;
* */
public class JAMADSLException extends Exception {
/**
* Il numero di versione seriale che identifica la compatibilita' di una
* classe con le sue istanze serializzate.
*/
private static final long serialVersionUID = 1L;
public JAMADSLException(Exception re) {
re.printStackTrace();
}
}
package JAM;
import java.net.MalformedURLException;
import java.rmi.*;
import java.util.*;
/**
* Classe astratta rappresentante un JAMAgent generico. Questa classe estende
* java.util.Observable e quindi possiede i metodi necessari per gestire i
* propri osservatori registrati.
* @author Devalle Trevor;
* @version 1.0;
* */
public abstract class JAMAgent extends Observable {
/**
* MessageBox dell'agente

*/
private MessageBox myMessageBox;
/**
* Identita' dell'agente
*/
private PersonalAgentID myID;
/**
* Stub dell'oggetto ADSL da usare per le comunicazioni
*/
private ADSL adsl;
/**
* Nome con il quale l'oggetto ADSL e' registrato sull'RMI Registry
*/
private String name;
/**
* Ip dell'RMI Registry
*/
private String ip;
/**
* Porta dell'RMI Registry
*/
private int port;
/**
* URI completo per l'ADSL sul RMI Registry
*/
private String uri;
/**
* Messaggio aggiuntivo inviato durante la notifica a gli ascoltatori
*/
private String log;
/**
* Lista dei comportamenti dell'agente
*/
private List<JAMBehaviour> myBehaviours;
/**
* Metodo costruttore di un JAMAgent con parametri per l'ADSL standard<br>
* "rmi://127.0.0.1:1099/ADSL".
*
* @param agentID
*
- AgentID corrispondente al JAMAgent che si sta creando.
*/

public JAMAgent(PersonalAgentID agentID) {


this.myID = agentID;
try {
this.myMessageBox = new MessageBox();
this.myMessageBox.setOwner(this.myID);
} catch (RemoteException e) {
System.out.println("Errore nella creazione della MessageBox");
e.printStackTrace();
}
this.ip = "127.0.0.1";
this.name = "ADSL";
this.port = 1099;
this.uri = "rmi://" + this.ip + ":" + this.port + "/" + this.name;
this.myBehaviours = new LinkedList<JAMBehaviour>();
}
/**
* Metodo costruttore di un JAMAgent con parametri per l'ADSL specificati<br>
* nei parametri.
* @param agentID - AgentID corrispondente al JAMAgent che si sta creando.
* @param ip - Ip dove contattare l'RMI.
* @param name - Nome usato per registrare l'ADSL sul RMI.
* @param port - Porta per la connessione all'RMI.
*/
public JAMAgent(PersonalAgentID agentID, String ip, String name, int port) {
this.myID = agentID;
try {
this.myMessageBox = new MessageBox();
this.myMessageBox.setOwner(this.myID);
} catch (RemoteException e) {
System.out.println("Errore nella creazione della MessageBox");
e.printStackTrace();
}
this.ip = ip;
this.name = name;
this.port = port;
this.uri = "rmi://" + this.ip + ":" + this.port + "/" + this.name;
this.myBehaviours = new LinkedList<JAMBehaviour>();
}
/**
* Restituisce l'AgentID relativo al JAMAgent.
* @return il PersonalAgentID associato.
*/
public PersonalAgentID getMyID() {
return this.myID;
}
/**
* Aggiunge il comportamento passato come parametro alla lista dei

* comportamenti dell'agente.
*
* @param behaviour - Nuovo comportamento da aggiungere.
*/
public void addBehaviour(JAMBehaviour behaviour) {
this.myBehaviours.add(behaviour);
}
/**
* Inizializza il comportamento del JAMAgent registrando <br>
* la messageBox sull'ADSL.
*/
public void init() {
try {
this.adsl = (ADSL) Naming.lookup(uri);
this.adsl.insertRemoteMessageBox(this.myMessageBox);
log = "INIT " + myID.toString() + " TO " + uri;
setChanged();
notifyObservers(log);
} catch (RemoteException | MalformedURLException |
NotBoundException e) {
System.out
.println("Errore nel lookup dell'ADSL, la MessageBox non
e' stata" +
" registrata (potrebbe gia' essere stata registrata in
precedenza).");
}
}
/**
* Avvia tutti i comportamenti del JAMAgent (JAMAgentBeaviours) facendo
* partire un thread per ogniuno di essi.
*/
public void start() {
String log = "";
Thread t;
for (JAMBehaviour be : this.myBehaviours) {
t = new Thread(be);
be.setMyThread(t);
t.start();
log = "START " + be.getClass().getSimpleName() + "\n";
setChanged();
notifyObservers(log);
}
}
/**
* Rimuove la propria MessageBox dall'ADSL ed esegue una done() su tutti i
* comportamenti, facendoli terminare.
*/

public void destroy() {


try {
this.adsl.removeRemoteMessageBox(this.myMessageBox);
String log = "DESTROY " + myID.toString() + " from " + uri;
for (JAMBehaviour be : this.myBehaviours) {
be.done();
}
setChanged();
notifyObservers(log);
} catch (RemoteException e) {
System.out
.println("La MessageBox non e' ancora registrata, non
puo' essere rimossa!");
}
}
/**
* Controlla la presenza di messaggi nella propria MessageBox aventi le
* caratteristiche passate come parametri, ovvero mittente uguale ad
* <i>agent</i> e performativa uguale a <i>performative</i>.
* @param agent - Mittente cercato.
* @param performative - Performativa cercata.
* @return <i>true</i> se e' presente almeno un messaggio che soddisfi la
*
ricerca, <i>false</i> altrimenti.
*/
public boolean check(AgentID agent, Performative performative) {
return this.myMessageBox.isThereMessage(agent, performative);
}
/**
* Controlla la presenza di messaggi nella propria MessageBox aventi le
* caratteristiche passate come parametro, ovvero mittente uguale ad
* <i>agent</i>.
* @param agent - Mittente cercato.
* @return <i>true</i> se e' presente almeno un messaggio che soddisfi la
*
ricerca, <i>false</i> altrimenti.
*/
public boolean check(AgentID agent) {
return this.myMessageBox.isThereMessage(agent);
}
/**
* Controlla la presenza di messaggi nella propria MessageBox aventi le
* caratteristiche passate come parametro, ovvero performativa uguale a
* <i>performative</i>.
* @param performative - Performativa cercata.
* @return <i>true</i> se e' presente almeno un messaggio che soddisfi la
*
ricerca, <i>false</i> altrimenti.
*/
public boolean check(Performative performative) {

return this.myMessageBox.isThereMessage(performative);
}
/**
* Controlla la presenza di messaggi nella propria MessageBox.
* @return <i>true</i> se e' presente almeno un messaggio, <i>false</i>
*
altrimenti.
*/
public boolean check() {
return this.myMessageBox.isThereMessage();
}
/**
* Recupera un messaggio dalla propria MessageBox avente le caratteristiche
* passate come parametri, ovvero mittente uguale ad <i>agent</i> e
* performativa uguale a <i>performative</i>. Se non viene trovato alcun
* messaggio valido il processo viene messo in attesa fino al ricevimento di
* un messaggio valido.
* @param agent - Mittente cercato.
* @param performative - Performativa cercata.
* @return Il primo messaggio valido per la ricerca.
* @throws JAMBehaviourInterruptedException
*
In caso di Interrupt durante l'attesa di un messaggio valido.
*/
public Message receive(AgentID agent, Performative performative)
throws JAMBehaviourInterruptedException {
try {
Message temp = this.myMessageBox.readMessage(agent,
performative);
log = "RECEIVE message " + temp.getPerformative().toString()
+ " from " + temp.getSender().toString();
setChanged();
notifyObservers(log);
return temp;
} catch (JAMMessageBoxException e) {
System.out.println("Errore durante la ricerca del messaggio");
// catch dovuto alla signature di parte_II
}
return null;
}
/**
* Recupera un messaggio dalla propria MessageBox avente le caratteristiche
* passate come parametri, ovvero mittente uguale ad <i>agent</i>. Se non
* viene trovato alcun messaggio valido il processo viene messo in attesa
* fino al ricevimento di un messaggio valido.
* @param agent - Mittente cercato.
* @return Il primo messaggio valido per la ricerca.
* @throws JAMBehaviourInterruptedException
*
In caso di Interrupt durante l'attesa di un messaggio valido.

*/
public Message receive(AgentID agent)
throws JAMBehaviourInterruptedException {
try {
Message temp = this.myMessageBox.readMessage(agent);
log = "RECEIVE message " + temp.getPerformative().toString()
+ " from " + temp.getSender().toString();
setChanged();
notifyObservers(log);
return temp;
} catch (JAMMessageBoxException e) {
System.out.println("Errore durante la ricerca del messaggio");
// catch dovuto alla signature di parte_II
}
return null;
}
/**
* Recupera un messaggio dalla propria MessageBox avente le caratteristiche
* passate come parametri, ovvero performativa uguale a <i>performative</i>.
* Se non viene trovato alcun messaggio valido il processo viene messo in
* attesa fino al ricevimento di un messaggio valido.
* @param performative - Performativa cercata.
* @return Il primo messaggio valido per la ricerca.
* @throws JAMBehaviourInterruptedException
*
In caso di Interrupt durante l'attesa di un messaggio valido.
*/
public Message receive(Performative performative)
throws JAMBehaviourInterruptedException {
try {
Message temp = this.myMessageBox.readMessage(performative);
log = "RECEIVE message " + temp.getPerformative().toString()
+ " from " + temp.getSender().toString();
setChanged();
notifyObservers(log);
return temp;
} catch (JAMMessageBoxException e) {
System.out.println("Errore durante la ricerca del messaggio");
// catch dovuto alla signature di parte_II
}
return null;
}
/**
* Recupera il primo messaggio disponibile dalla propria MessageBox. Se non
* viene trovato alcun messaggio, il processo viene messo in attesa fino al
* ricevimento di un nuovo messaggio.
* @return Il primo messaggio disponibile.
* @throws JAMBehaviourInterruptedException
*
In caso di Interrupt durante l'attesa di un messaggio valido.

*/
public Message receive() throws JAMBehaviourInterruptedException {
try {
Message temp = this.myMessageBox.readMessage();
log = "RECEIVE message " + temp.getPerformative().toString()
+ " from " + temp.getSender().toString();
setChanged();
notifyObservers(log);
return temp;
} catch (JAMMessageBoxException e) {
System.out.println("Errore durante la ricerca del messaggio");
// catch dovuto alla signature di parte_II
}
return null;
}
/**
* Invia un messaggio ai possibili destinatari (indicati nel messaggio)
* registrati nell'ADSL.
* @param msg - Messaggio da inviare.
*/
public void send(Message msg) // throws JAMADSLException
{
String log = "";
try {
List<RemoteMessageBox> temp =
this.adsl.getRemoteMessageBox(msg
.getReceiver());
for (RemoteMessageBox rmb : temp) {
rmb.writeMessage(msg);
log = "SEND message " + msg.getPerformative().toString()
+ " to " + rmb.getOwner().toString();
setChanged();
notifyObservers(log);
}
} catch (RemoteException e) {
System.out
.println("Errore nel reperimento dei destinatari," +
" i messaggi non saranno inviati.");
// throw new JAMADSLException(e);
}
}
}
package JAM;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Observable;

import java.util.Observer;
import javax.swing.*;
/**
* Interfaccia grafica per l'interazione e l'osservazione di JAM Agent. Permette
* di inizializzarne il comportamento e di leggere a video lo storico delle
* operazioni compiute dall'oggetto.
* @author Devalle Trevor
* @version 1.0;
*/
public class JAMAgentMonitor extends JFrame implements Observer {
/**
* Oggetto JAM Agent osservato da JAMAgentMonitor
*/
private JAMAgent JAMAgent;
/**
* TextArea usata per stampare i log delle operazioni
*/
private JTextArea textArea;
/**
* ScrollPanel contenente la TextArea usata per stampare i log delle
* operazioni
*/
private JScrollPane scrollPane;
public JAMAgentMonitor(JAMAgent ag) {
this.JAMAgent = ag;
this.JAMAgent.addObserver(this);
Container cp = getContentPane();
cp.setLayout(new BorderLayout());
JPanel northPanel = new JPanel();
JLabel title = new JLabel("JAM Agent Monitor - "
+ ag.getMyID().toString(), JLabel.CENTER);
northPanel.setBackground(Color.BLUE);
title.setForeground(Color.WHITE);
northPanel.add(title);
cp.add(northPanel, BorderLayout.NORTH);
textArea = new JTextArea(8, 40);
textArea.setEditable(false);
scrollPane = new JScrollPane(textArea);
cp.add(scrollPane, BorderLayout.CENTER);
JPanel westPanel = new JPanel();
JLabel westLabel = new JLabel("<html>Connection<br>Console</html>",
JLabel.CENTER);
westPanel.add(westLabel);
cp.add(westPanel, BorderLayout.WEST);
JPanel eastPanel = new ButtonPanel();
cp.add(eastPanel, BorderLayout.EAST);

cp.add(new ExitButton(), BorderLayout.SOUTH);


setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
pack();
setVisible(true);
}
/**
* L'agente aggancia l'ADSL e vi registra la propria MessageBox.
*/
public void initJAMAgent() {
this.JAMAgent.init();
}
/**
* Avvia tutti i comportamenti del JAMAgent (JAMAgentBeaviours) facendo
* partire un thread per ogniuno di essi.
*/
public void startJAMAgent() {
this.JAMAgent.start();
}
/**
* Rimuove la propria MessageBox dall'ADSL ed esegue una done() su tutti i
* comportamenti, facendoli terminare.
*/
public void destroyJAMAgent() {
this.JAMAgent.destroy();
}
@Override
public void update(Observable arg0, Object arg1) {
this.textArea.append((String) arg1 + "\n");
}
/**
* Classe di bottoni che in seguito alla loro pressione fanno terminare il
* programma.
*
* @author Devalle Trevor
*/
class ExitButton extends JButton implements ActionListener {
/**
* Crea un bottone che in seguito alla sua pressione termina il
* programma.
*/
public ExitButton() {
super("Exit");
addActionListener(this);
}

public void actionPerformed(ActionEvent e) {


System.exit(0);
}
}
/**
* Sottoclasse di JPanel contenente 3 bottoni che manipolano il
* comportamento dell'oggetto JAM Agent osservato da JAMAgentMonitor.
*
* @author Devalle Trevor
*
*/
class ButtonPanel extends JPanel implements ActionListener {
private JButton initB = new JButton("Init");
private JButton startB = new JButton("Start");
private JButton destroyB = new JButton("Destroy");
/**
* Crea un JPanel contenente 3 tasti per manipolare i principali
* comportamenti di un oggetto JAM Agent: <br>
* Init -> init() - L'agente aggancia l'ADSL e vi registra la propria
* MessageBox <br>
* Start -> start() - Avvia tutti i comportamenti del JAMAgent
* (JAMAgentBeaviours) facendo partire un thread per ogniuno di essi.
<br>
* Destroy -> destroy() - Rimuove la propria MessageBox dall'ADSL ed
* esegue una done() su tutti i comportamenti, facendoli terminare.
*/
public ButtonPanel() {
super(new GridLayout(3, 1));
initB = new JButton("Init");
initB.setSize(10, 50);
add(initB);
initB.addActionListener(this);
startB = new JButton("Start");
startB.setSize(10, 50);
add(startB);
startB.addActionListener(this);
destroyB = new JButton("Destroy");
destroyB.setSize(10, 50);
add(destroyB);
destroyB.addActionListener(this);
}
public void actionPerformed(ActionEvent e) {
Object source = e.getSource();
if (source == initB) {
initJAMAgent();

} else if (source == startB) {


startJAMAgent();
} else {
destroyJAMAgent();
}
}
}
}
package JAM;
/**
* Classe astratta rappresentante un comportamento di un agente.
*
* @author Devalle Trevor
* @version 1.0;
*/
public abstract class JAMBehaviour implements Runnable {
/**
* Flag rappresentante lo stato di completamento o meno del comportamento
*/
protected boolean done;
/**
* Riferimento al thread associato a questo comportamento
*/
protected Thread myThread;
/**
* JAM Agent proprietario del comportamento
*/
protected JAMAgent myAgent;
/**
* Crea un comportamento generico inizializzando il campo <i>myAgent</i>
con
* l'agente passato nei parametri.
* @param ja - Proprietario del comportamento.
*/
public JAMBehaviour(JAMAgent ja) {
this.myAgent = ja;
this.done = false;
}
/**
* Importa il flag <i>done</i> a <i>true</i>, segnalando la corretta
* terminazione del comportamento. Esegue inoltre un interrupt() sul thread
* che ospitava il comportamento per farlo terminare.
*/
public void done() {

this.done = true;
this.myThread.interrupt();
}
/**
* Restituisce lo stato del flag <i>done</i>.
* @return <i>true</i> se il comportamento e' terminato correttamente,
*
<i>false</i> altrimenti.
*/
public boolean isDone() {
return this.done;
}
/**
* Registra nella variabile <i>myThread</i> il riferimento al thread che
* eseguira' questo comportamento.
* @param myThread - Thread che eseguira' il comportamento.
*/
public void setMyThread(Thread myThread) {
this.myThread = myThread;
}
/**
* Mette in pausa il processo corrente per il numero di millisecondi
* indicato nei parametri.
* @param ms - Numero di millisecondi di pausa richiesti.
* @throws JAMBehaviourInterruptedException
*
Eccezione lanciata in causa di interruzione della pausa
*
dovuta ad una InterruptedException.
*/
public void sleep(long ms) throws JAMBehaviourInterruptedException {
try {
Thread.sleep(ms);
} catch (InterruptedException e) {
throw new JAMBehaviourInterruptedException(e);
}
}
/**
* Metodo astratto che definisce il codice da eseguire una o piua' volte
* durante il comportamento.
* @throws JAMBehaviourInterruptedException
*
Eccezione sollevata in caso di Interrupt interno.
*/
protected abstract void action() throws JAMBehaviourInterruptedException;
/**
* Metodo astratto che definisce il codice da eseguire durante
* l'inizializzazione del comportamento, prima che venga richiamato il
* metodo action().

* @throws JAMBehaviourInterruptedException
*
Eccezione sollevata in caso di Interrupt interno.
*/
protected abstract void setup() throws JAMBehaviourInterruptedException;
/**
* Metodo astratto che defininisce il codice da eseguire prima di terminare
* l'esecuzione del comportamento.
* @throws JAMBehaviourInterruptedException
*
Eccezione sollevata in caso di Interrupt interno.
*/
protected abstract void dispose() throws JAMBehaviourInterruptedException;
}
package JAM;
/**Classe d'errore relativa alle eccezioni sollevate<br>
* nell'interazione con le classi Behaviour dei JAM Agent,<br>
* in seguito a dei segnali di Interrupt durante l'esecuzione.
* @author Devalle Trevor;
* @version 1.0;
* */
public class JAMBehaviourInterruptedException extends Exception {
/**
* Il numero di versione seriale che identifica la compatibilita' di una
* classe con le sue istanze serializzate.
*/
private static final long serialVersionUID = 1L;
public JAMBehaviourInterruptedException(InterruptedException ie) {
ie.printStackTrace();
}
}
package JAM;
import java.io.IOException;
/**
* Classe d'errore relativa alle eccezioni sollevate<br>
* durante le operazioni di IO.
* @author Devalle Trevor;
* @version 1.0;
*/
public class JAMIOException extends Exception{
/**
* Il numero di versione seriale che identifica la compatibilita' di una
* classe con le sue istanze serializzate.
*/
private static final long serialVersionUID = 1L;

public JAMIOException(IOException io) {


io.printStackTrace();
}
}
package JAM;
/**
* Classe d'errore relativa alle eccezioni sollevate<br>
* nell'interazione con le classi MessageBoxNoSync e MessageBox.
* @author Devalle Trevor;
* @version 1.0;
* */
public class JAMMessageBoxException extends Exception {
/**
* Il numero di versione seriale che identifica la compatibilita' di una
* classe con le sue istanze serializzate.
*/
private static final long serialVersionUID = 1L;
}
package JAM;
/**
* Classe astratta estensione di JAMBehaviour rappresentante il comportamento di
* un agente con una esecuzione singola. <br>
* L'esecuzione e' composta dalla chiamata in sequenza dei metodi setup(),
* action() e dispose().
* @author Devalle Trevor
* @version 1.0;
*/
public abstract class JAMSimpleBehaviour extends JAMBehaviour {
/**
* Metodo costruttore di un comportamento lineare appartenente ad un agente.
* @param ja - Agente proprietario del comportamento.
*/
public JAMSimpleBehaviour(JAMAgent ja) {
super(ja);
}
@Override
public void run() {
try {
setup();
if (!isDone()) {
action();
}
} catch (JAMBehaviourInterruptedException e1) {
// se viene lanciata una ecc a seguito di una chiama done()
// i valori di isDone dovranno essere TRUE, in caso contrario errore

if (isDone())
return;
System.out.println(e1);
} finally {
try {
dispose();
} catch (JAMBehaviourInterruptedException e2) {
System.out.println(e2);
}
}
}
}
package JAM;
/**
* Classe astratta estensione di JAMBehaviour rappresentante il comportamento di
* un agente con una esecuzione ciclica. <br>
* L'esecuzione e' composta dalla chiamata in sequenza dei metodi setup(),
* action() finche' la condizione di terminazione (<i>done</i> uguale a
* <i>true</i>) non e' valida e dispose() come ultimo passo prima della
* terminazione.
* @author Devalle Trevor
* @version 1.0;
*/
public abstract class JAMWhileBehaviour extends JAMBehaviour {
/**
* Metodo costruttore di un comportamento ciclico appartenente ad un agente.
* @param ja - Agente proprietario del comportamento.
*/
public JAMWhileBehaviour(JAMAgent ja) {
super(ja);
}
@Override
public void run() {
try {
setup();
while (!isDone()) {
action();
}
} catch (JAMBehaviourInterruptedException e1) {
// se viene lanciata una ecc a seguito di una chiama done()
// i valori di isDone dovranno essere TRUE, in caso contrario errore
if (isDone()) {
return;
} else {
System.out.println("Interruzione forzata dell'esecuzione!");
System.out.println(e1);
}

} finally {
try {
dispose();
} catch (JAMBehaviourInterruptedException e2) {
System.out.println(e2);
}
}
}
}
package JAM;
import java.io.*;
public class LogFile {
private PrintWriter log;
private void logFile(String s) throws JAMIOException {
log.println(s);
log.flush();
}
public void startLog(String fileName, String messaggio) throws JAMIOException {
try {
File file = new File(fileName + ".log");
log = new PrintWriter(file);
logFile(messaggio);
}
catch(IOException ioexception)
{
throw new JAMIOException(ioexception);
}
}
public void endLog() {
log.close();
}
public void log(String messaggio, Object ExtraObject) throws JAMIOException {
String temp = "";
temp += "----> " + (System.nanoTime() / 1000L) + " <----\n";
temp += messaggio + "\n";
if(ExtraObject != null)
temp += "\n" + ExtraObject.toString() + "\n";
temp += "<<---------";
logFile(temp);
}
public void log(String s) throws JAMIOException {
log(s, null);
}
}
package JAM;

import java.io.*;
/**
* Classe rappresentante un messaggio. Verra' utilizzata per comunicazioni tra
* JAM Agent, i quali possiedono una MessageBox dove ricevono messaggi
* rappresentati da oggetti di questo tipo.
* @author Devalle Trevor;
* @version 1.0;
* */
public class Message implements Serializable {
/**
* Il numero di versione seriale che identifica la compatibilita' di una
* classe con le sue istanze serializzate.
*/
private static final long serialVersionUID = 1L;
/**
* AgentID mittente del messaggio (Personal, Category o Generic)
*/
AgentID sender;
/**
* AgentID destinatario del messaggio (Personal, Category o Generic)
*/
AgentID receiver;
/**
* Performativa del messaggio, indica la tipologia di messaggio inviato
*/
Performative performative;
/**
* Contenuto del messaggio
*/
String content;
/**
* Allegato del messaggio
*/
Object extraArgument;
/**
* Costruttore di un messaggio completo di ogni parametro.
* @param sender - Agente mittente
* @param receiver - Agente destinatario
* @param performative - Performativa del messagio
* @param content - Contenuto testuale
* @param extraArgument - Allegato extra
*/
public Message(AgentID sender, AgentID receiver, Performative performative,
String content, Object extraArgument) {

super();
this.sender = sender;
this.receiver = receiver;
this.performative = performative;
this.content = content;
this.extraArgument = extraArgument;
}
/**
* Costruttore di un messaggio, senza allegato.
* @param sender - Agente mittente
* @param receiver - Agente destinatario
* @param performative - Performativa del messagio
* @param content - Contenuto testuale
*/
public Message(AgentID sender, AgentID receiver, Performative performative,
String content) {
super();
this.sender = sender;
this.receiver = receiver;
this.performative = performative;
this.content = content;
}
/**
* Costruttore di un messaggio con parametri minimi.
* @param sender - Agente mittente
* @param receiver - Agente destinatario
* @param performative - Performativa del messagio
*/
public Message(AgentID sender, AgentID receiver, Performative performative) {
super();
this.sender = sender;
this.receiver = receiver;
this.performative = performative;
}
/**
* Restituisce il mittente del messaggio.
* @return l'oggetto agente mittente.
*/
public AgentID getSender() {
return sender;
}
/**
* Restituisce il destinatario del messaggio.
* @return l'oggeto agente destinatario.
*/
public AgentID getReceiver() {

return receiver;
}
/**
* Restituisce la performativa del messaggio.
* @return la performativa del messaggio.
*/
public Performative getPerformative() {
return performative;
}
/**
* Restituisce il contenuto testuale del messaggio.
* @return stringa del contenuto.
*/
public String getContent() {
return content;
}
/**
* Restituisce l'oggetto allegato al messaggio.
* @return l'oggetto allegato se presente, <code>null</code> altrimenti.
*/
public Object getExtraArgument() {
return extraArgument;
}
/**
* Sostituisce il mittente con il mittente passato come parametro.
* @param sender - Nuovo mittente.
*/
public void setSender(AgentID sender) {
this.sender = sender;
}
/**
* Sostituisce il destinatario con il destinatario passato come parametro.
* @param receiver - Nuovo destinatario.
*/
public void setReceiver(AgentID receiver) {
this.receiver = receiver;
}
/**
* Sostituisce la performativa con la performativa passata come parametro.
* @param performative - Nuova performativa.
*/
public void setPerformative(Performative performative) {
this.performative = performative;
}

/**
* Sostituisce il contenuto con il contenuto passato come parametro.
* @param content - Nuovo contenuto.
*/
public void setContent(String content) {
this.content = content;
}
/**
* Sostituisce l'allegato con l'allegato passato come parametro.
* @param extraArgument - Nuovo allegato
*/
public void setExtraArgument(Object extraArgument) {
this.extraArgument = extraArgument;
}
@Override
public String toString() {
String temp = new String();
temp += "Performativa: " + this.getPerformative() + "\n";
temp += "Sender: " + this.getSender().toString() + "\n";
temp += "Receiver: " + this.getReceiver().toString() + "\n";
temp += "Content:\n" + this.getContent() + "\n";
try {
temp += "ExtraArgument:\n" + this.getExtraArgument().toString()
+ "\n";
} catch (NullPointerException e) {
temp += "ExtraArgument:\n\n";
}
return temp;
}
/**
* Restituisce una rappresentazione testuale dell'oggetto basata<br>
* su i 3 parametri caratterizzanti un messaggio
* @return ( <i>Sender</i> , <i>Receiver</i> , <i>Performative</i> )
*/
public String toString2() {
String temp = new String();
temp += "(" + this.getSender().toString() + " , "
+ this.getReceiver().toString() + " , "
+ this.getPerformative() + " )";
return temp;
}
}
package JAM;

import java.rmi.RemoteException;
import java.util.List;
/**
* Classe rappresentante la casella di posta per i messaggi tra agenti.<br>
* In questa classe vengono inoltre implementati i meccanismi di
* sincronizzazione.
* @author Devalle Trevor;
* @version 1.0;
* */
public class MessageBox extends MessageBoxNoSync implements
RemoteMessageBox {
/**
* Il numero di versione seriale che identifica la compatibilita' di una
* classe con le sue istanze serializzate.
*/
private static final long serialVersionUID = 1L;
/**
* Metodo costruttore di una casella di posta vuota.
* @throws RemoteException In caso di problemi nella creazione dell'oggetto.
*/
public MessageBox() throws RemoteException {
super();
}
/**
* Metodo costruttore di una casella di posta caratterizzata dai parametri
* @param agent - Proprietario della casella postale.
* @param box - Lista dei messaggi.
* @throws RemoteException
*
In caso di problemi nella creazione dell'oggetto.
*/
public MessageBox(PersonalAgentID agent, List<Message> box)
throws RemoteException {
super(agent, box);
}
@Override
public PersonalAgentID getOwner() {
return super.getOwner();
}
@Override
public void setOwner(PersonalAgentID agentID) {
super.setOwner(agentID);
}
@Override
synchronized public boolean isBoxEmpty() {

return super.isBoxEmpty();
}
@Override
synchronized public Message readMessage(AgentID agent,
Performative performative) throws JAMMessageBoxException,
JAMBehaviourInterruptedException {
while (true) {
try {
return super.readMessage(agent, performative);
} catch (JAMMessageBoxException e1) {
try {
wait();
} catch (InterruptedException e2) {
throw new JAMBehaviourInterruptedException(e2);
}
}
}
}
@Override
synchronized public Message readMessage(AgentID agent)
throws JAMMessageBoxException,
JAMBehaviourInterruptedException {
while (true) {
try {
return super.readMessage(agent);
} catch (JAMMessageBoxException e1) {
try {
wait();
} catch (InterruptedException e2) {
throw new JAMBehaviourInterruptedException(e2);
}
}
}
}
@Override
synchronized public Message readMessage(Performative performative)
throws JAMMessageBoxException,
JAMBehaviourInterruptedException {
while (true) {
try {
return super.readMessage(performative);
} catch (JAMMessageBoxException e1) {
try {
wait();

} catch (InterruptedException e2) {


throw new JAMBehaviourInterruptedException(e2);
}
}
}
}
@Override
synchronized public Message readMessage() throws
JAMMessageBoxException,
JAMBehaviourInterruptedException {
while (true) {
try {
return super.readMessage();
} catch (JAMMessageBoxException e1) {
try {
wait();
} catch (InterruptedException e2) {
throw new JAMBehaviourInterruptedException(e2);
}
}
}
}
@Override
synchronized public boolean isThereMessage(AgentID agent,
Performative performative) {
return super.isThereMessage(agent, performative);
}
@Override
synchronized public boolean isThereMessage(AgentID agent) {
return super.isThereMessage(agent);
}
@Override
synchronized public boolean isThereMessage(Performative performative) {
return super.isThereMessage(performative);
}
@Override
synchronized public boolean isThereMessage() {
return super.isThereMessage();
}
@Override
synchronized public void writeMessage(Message message) {
super.writeMessage(message);

notifyAll();
}
}
package JAM;
import java.rmi.*;
import java.rmi.server.UnicastRemoteObject;
import java.util.*;
/**
* Classe rappresentante la casella di posta per i messaggi tra agenti.
* @author Devalle Trevor;
* @version 1.0;
* */
public class MessageBoxNoSync extends UnicastRemoteObject {
/**
* Il numero di versione seriale che identifica la compatibilita' di una
* classe con le sue istanze serializzate
*/
private static final long serialVersionUID = 1L;
/**
* Proprietario della casella postale
*/
private PersonalAgentID owner;
/**
* Lista dei messaggi
*/
private List<Message> box;
/**
* Metodo costruttore di una casella di posta vuota.
* @throws RemoteException
*
In caso di problemi nella creazione dell'oggetto.
*/
public MessageBoxNoSync() throws RemoteException {
this.owner = new PersonalAgentID("", "");
this.box = new LinkedList<Message>();
}
/**
* Metodo costruttore di una casella di posta caratterizzata dai parametri.
* @param agent - Proprietario della casella postale.
* @param box - Lista dei messaggi.
* @throws RemoteException
*
In caso di problemi nella creazione dell'oggetto.
*/
public MessageBoxNoSync(PersonalAgentID agent, List<Message> box)
throws RemoteException {

this.owner = agent;
this.box = box;
}
/**
* Restituisce il proprietario della casella postale.
* @return agente proprietario della casella postale.
*/
public PersonalAgentID getOwner() {
return this.owner;
}
/**
* Sostituisce il proprietario con il proprietario passato come parametro.
* @param agentID - Nuovo proprietario.
*/
public void setOwner(PersonalAgentID agentID) {
this.owner = agentID;
}
/**
* Controlla che la casella postale sia vuota.
* @return <c>true</i> se non ci sono messaggi, <i>false</i> altrimenti.
*/
public boolean isBoxEmpty() {
return this.box.isEmpty();
}
/**
* Restituisce il primo messaggio avente le caratteristiche passate come
* parametro.<br>
* Tale messaggio viene inoltre rimosso dalla casella postale.
* @param agent - Agente (o agente categoria) mittente ricercato.
* @param performative - Performativa ricercata.
* @return il primo messaggio valido per la ricerca.
* @throws JAMMessageBoxException
*
Se non e' presente un messaggio valido per la ricerca <br>
*
viene lanciata un eccezione di questo tipo.
*/
public Message readMessage(AgentID agent, Performative performative)
throws JAMMessageBoxException,
JAMBehaviourInterruptedException {
Iterator<Message> iter = this.box.iterator();
Message temp = null;
int i = 0;
while (iter.hasNext()) {
temp = iter.next();
if ((agent == null || (agent != null && agent.equals(temp
.getSender())))

&& (performative == null || (performative != null && temp


.getPerformative() == performative))) {
this.box.remove(i);
return temp;
}
i++;
}
throw new JAMMessageBoxException();
}
/**
* Viene restituito il primo messaggio nella casella di posta avente come
* mittente l'agente passato come parametro.<br>
* Tale messaggio viene inoltre rimosso dalla casella postale.
*
* @param agent - Agente (o agente categoria) mittente ricercato.
* @return il primo messaggio valido per la ricerca.
* @throws JAMMessageBoxException
*
Se non e' presente un messaggio valido per la ricerca <br>
*
viene lanciata un eccezione di questo tipo.
*/
public Message readMessage(AgentID agent) throws
JAMMessageBoxException,
JAMBehaviourInterruptedException {
return readMessage(agent, null);
}
/**
* Viene restituito il primo messaggio nella casella di posta avente come
* performativa la performativa passata come parametro.<br>
* Tale messaggio viene inoltre rimosso dalla casella postale.
*
* @param performative - Performativa ricercata
* @return il primo messaggio valido per la ricerca.
* @throws JAMMessageBoxException
*
Se non e' presente un messaggio valido per la ricerca <br>
*
viene lanciata un eccezione di questo tipo.
*/
public Message readMessage(Performative performative)
throws JAMMessageBoxException,
JAMBehaviourInterruptedException {
return readMessage(null, performative);
}
/**
* Viene restituito il messaggio in cima alla lista della casella postale
* (il pi vecchio). <br>
* Tale messaggio viene inoltre rimosso dalla casella postale.
* @return il primo messaggio valido per la ricerca.
* @throws JAMMessageBoxException

*
Se non e' presente un messaggio valido per la ricerca <br>
*
viene lanciata un eccezione di questo tipo.
*/
public Message readMessage() throws JAMMessageBoxException,
JAMBehaviourInterruptedException {
return readMessage(null, null);
}
/**
* Controlla la presenza di un messaggio caratterizzato dai parametri in
* ingresso.
* @param agent - Agente (o agente categoria) mittente cercato
* @param performative - Performativa cercata
* @return <i>true</i> se e' presente un messagio valido per la ricerca,
*
<i>false</i> altrimenti.
*/
public boolean isThereMessage(AgentID agent, Performative performative) {
Iterator<Message> iter = this.box.iterator();
Message temp = null;
while (iter.hasNext()) {
temp = iter.next();
if ((agent == null || (agent != null && agent.equals(temp
.getSender())))
&& (performative == null || (performative != null && temp
.getPerformative() == performative))) {
return true;
}
}
return false;
}
/**
* Controlla la presenza di un messaggio caratterizzato dal mittente.
* @param agent - Agente (o agente categoria) mittente ricercato.
* @return <i>true</i> se e' presente un messagio valido per la ricerca,
*
<i>false</i> altrimenti.
*/
public boolean isThereMessage(AgentID agent) {
return isThereMessage(agent, null);
}
/**
* Controlla la presenza di un messaggio caratterizzato dalla performativa.
* @param performative - Performativa ricercata
* @return <i>true</i> se e' presente un messagio valido per la ricerca,
*
<i>false</i> altrimenti.
*/
public boolean isThereMessage(Performative performative) {
return isThereMessage(null, performative);
}

/**
* Controlla la presenza di un messaggio qualsiasi nella casella postale.
* @return <i>true</i> se e' presente un messagio valido per la ricerca,
*
<i>false</i> altrimenti.
*/
public boolean isThereMessage() {
return !this.box.isEmpty();
}
/**
* Aggiunge un messaggio alla casella postale, mettendolo in coda a gli
* altri presenti.
* @param message - Messaggio da inserire.
*/
public void writeMessage(Message message) {
this.box.add(message);
}
}
package JAM;
/**Classe enumerativa delle tipologie di performative.
* Le performative vengono utilizzate per discernere la
* tipologia di richieste tra agenti.
* @author Devalle Trevor;
* @version 1.0;
* */
public enum Performative {
UNKNOWN,
ACCEPT_PROPOSAL,
AGREE,
CANCEL,
CALL_FOR_PROPOSAL,
CONFIRM,
DISCONFIRM,
FAILURE,
INFORM,
INFORM_IF,
INFORM_REF,
NOT_UNDERSTOOD,
PROPAGATE,
PROPOSE,
PROXY,
QUERY_IF,
QUERY_REF,
REFUSE,
REJECT_PROPOSAL,
REQUEST,
REQUEST_WHEN,

REQUEST_WHENEVER,
SUBSCRIBE
}
package JAM;
/**
* Classe di agente caratterizzata da una categoria ed un nome.
* @author Devalle Trevor;
* @version 1.0;
* */
public class PersonalAgentID extends CategoryAgentID {
/**
* Il numero di versione seriale che identifica la compatibilita' di una
* classe con le sue istanze serializzate
*/
private static final long serialVersionUID = 1L;
/**
* Metodo costruttore di un agente caratterizzato da nome e categoria.
* @param name - Nome dell'agente.
* @param category - Categoria dell'agente.
*/
public PersonalAgentID(String name, String category) {
super(category);
this.setName(name);
}
@Override
public boolean equals(Object agentID) {
try {
if (agentID != null) {
AgentID temp = (PersonalAgentID) agentID;
} else {
return false;
}
} catch (ClassCastException e) {
return super.equals(agentID); // false per asimm.
}
AgentID temp = (PersonalAgentID) agentID;
return (this.getCategory().equals(temp.getCategory()))
&& (this.getName().equals(temp.getName())) ? true : false;
}
}
package JAM;
import java.rmi.Naming;
import java.rmi.RemoteException;
/**

* Crea il RMI Registry sulla porta 1099 e vi registra un ADSL<br>


* "rmi://127.0.0.1:1099/ADSL".
* @author Devalle Trevor;
* @version 1.0;
*/
public class ProvaADSL {
public static void main(String[] args) {
try {
ADSLImpl adsl = new ADSLImpl();
java.rmi.registry.LocateRegistry.createRegistry(1099);
Naming.rebind("rmi://127.0.0.1:1099/ADSL", adsl);
} catch (Exception e) {
System.out
.println("Errore nella creazione dell'ADSL o nel bind con
RMI Registry");
e.printStackTrace();
}
System.out.println("RMI Registry avviato e ADSL creato.");
}
}
package JAM;
import java.rmi.RemoteException;
import java.util.*;
public class ProvaMessageBoxNoSync {
private static void test(MessageBoxNoSync box) {
PersonalAgentID uno = new PersonalAgentID("uno", "dispari");
PersonalAgentID due = new PersonalAgentID("due", "pari");
PersonalAgentID tre = new PersonalAgentID("tre", "dispari");
PersonalAgentID quattro = new PersonalAgentID("quattro", "pari");
PersonalAgentID cinque = new PersonalAgentID("cinque", "dispari");
PersonalAgentID sei = new PersonalAgentID("sei", "pari");
CategoryAgentID pari = new CategoryAgentID("pari");
CategoryAgentID unknown = new CategoryAgentID("unknown");
Message unoTOdue = new Message(uno, due,
Performative.CALL_FOR_PROPOSAL);
Message unoTOtre = new Message(uno, tre,
Performative.CALL_FOR_PROPOSAL);
Message unoTOquattro = new Message(uno, quattro,
Performative.AGREE);
Message dueTOquattro = new Message(due, quattro,
Performative.CANCEL);
Message treTOtre = new Message(tre, tre, Performative.AGREE);
Message treTOquattro = new Message(tre, quattro,
Performative.UNKNOWN);
Message treTOuno = new Message(tre, uno, Performative.UNKNOWN);
Message quattroTOcinque = new Message(quattro, cinque,

Performative.CANCEL);
Message cinqueTOdue = new Message(cinque, due,
Performative.FAILURE);
LinkedList<Message> lista = new LinkedList<Message>();
lista.add(unoTOdue);
lista.add(unoTOtre);
lista.add(unoTOquattro);
lista.add(dueTOquattro);
lista.add(treTOtre);
lista.add(treTOquattro);
lista.add(treTOuno);
lista.add(quattroTOcinque);
lista.add(cinqueTOdue);
if (box.isBoxEmpty())
System.out.println("BoxMessage isBoxEmpty() vuoto \n");
if (!box.isThereMessage())
System.out
.println("BoxMessage isThereMessage() vuoto \n\n-->
Inserisco i messaggi ... \n");
for (Message t : lista) {
box.writeMessage(t);
System.out.println(t.toString2());
}
System.out
.println("Presenza del primo messaggio in coda (il pi vecchio
in attesa):");
if (box.isThereMessage()) {
System.out.println("Trovato");
} else {
System.out.println("Nessun risultato");
}// trovato
System.out
.println("Presenza del primo messaggio in coda inviato da un
certo agente:");
System.out.println("Cerco sei");
if (box.isThereMessage(sei)) {
System.out.println("Trovato");
} else {
System.out.println("Nessun risultato");
}// non trovato
System.out
.println("lettura del primo messaggio in coda inviato da un
agente appartenente"
+ " ad una certa categoria di agenti:");

System.out.println("Cerco pari");
if (box.isThereMessage(pari)) {
System.out.println("Trovato");
} else {
System.out.println("Nessun risultato");
}// trovato
System.out
.println("lettura del primo messaggio in coda inviato da un
agente appartenente"
+ " ad una certa categoria di agenti:");
System.out.println("Cerco unknown");
if (box.isThereMessage(unknown)) {
System.out.println("Trovato");
} else {
System.out.println("Nessun risultato");
}// trovato
System.out
.println("lettura del primo messaggio in coda inviato da un certo
agente e "
+ "corrispondente ad una certa performativa:");
System.out.println("Cerco DISCONFIRM");
if (box.isThereMessage(Performative.DISCONFIRM)) {
System.out.println("Trovato");
} else {
System.out.println("Nessun risultato");
}// non trovato
System.out
.println("lettura del primo messaggio in coda inviato da un
agente "
+ "appartenente ad una certa categoria di agenti e
corrispondente ad una certa performativa:");
System.out.println("Cerco Uno AGREE");
if (box.isThereMessage(uno, Performative.AGREE)) {
System.out.println("Trovato");
} else {
System.out.println("Nessun risultato");
}// trovato
System.out
.println("lettura del primo messaggio in coda (il pi vecchio in
attesa):");
try {
System.out.println("-Risultato atteso unoTOdue-");
System.out.println(box.readMessage().toString());
} catch (JAMMessageBoxException | JAMBehaviourInterruptedException
e) {
System.out.println("Messaggio non trovato\n\n");

}// unoTOdue
System.out
.println("lettura del primo messaggio in coda inviato da un certo
agente:");
try {
System.out.println("-Risultato atteso quattroTOcinque-");
System.out.println(box.readMessage(quattro).toString());
} catch (JAMMessageBoxException | JAMBehaviourInterruptedException
e) {
System.out.println("Messaggio non trovato\n\n");
}// quattroTOcinque
System.out
.println("lettura del primo messaggio in coda inviato da un
agente appartenente"
+ " ad una certa categoria di agenti:");
try {
System.out.println("-Risultato atteso dueTOquattro-");
System.out.println(box.readMessage(pari).toString());
} catch (JAMMessageBoxException | JAMBehaviourInterruptedException
e) {
System.out.println("Messaggio non trovato\n\n");
}// dueTOquattro
System.out
.println("lettura del primo messaggio in coda corrispondente ad
una certa performativa:");
try {
System.out.println("-Risultato atteso cinqueTOdue-");
System.out
.println(box.readMessage(Performative.FAILURE).toStrin
g());
} catch (JAMMessageBoxException | JAMBehaviourInterruptedException
e) {
System.out.println("Messaggio non trovato\n\n");
}// cinqueTOdue
System.out
.println("lettura del primo messaggio in coda inviato da un certo
agente e "
+ "corrispondente ad una certa performativa:");
try {
System.out.println("-Risultato atteso treTOquattro-");
System.out.println(box.readMessage(tre, Performative.UNKNOWN)
.toString());
} catch (JAMMessageBoxException | JAMBehaviourInterruptedException
e) {
System.out.println("Messaggio non trovato\n\n");
}// treTOquattro

System.out
.println("lettura del primo messaggio in coda inviato da un
agente "
+ "appartenente ad una certa categoria di agenti e
corrispondente ad una certa performativa:");
try {
System.out
.println("-Risultato atteso dueTOquattro ma e' gia' stato
letto!-");
System.out.println(box.readMessage(pari, Performative.CANCEL)
.toString());
} catch (JAMMessageBoxException | JAMBehaviourInterruptedException
e) {
System.out.println("Messaggio non trovato\n\n");
}// dueTOquattro
}
public static void main(String[] args) {
List<Message> boxLL = new LinkedList<Message>();
List<Message> boxAL = new ArrayList<Message>();
List<Message> boxV = new Vector<Message>();
PersonalAgentID a = new PersonalAgentID("prova1", "fake");
try {
MessageBoxNoSync MBll = new MessageBoxNoSync(a, boxLL);
MessageBoxNoSync MBal = new MessageBoxNoSync(a, boxAL);
MessageBoxNoSync MBv = new MessageBoxNoSync(a, boxV);
test(MBll);
System.out.println("---");
test(MBal);
System.out.println("---");
test(MBv);
} catch (RemoteException e) {
System.out.println("Errore nella crazione delle MessageBox !");
e.printStackTrace();
}
}
}
package JAM;
import java.net.MalformedURLException;
import java.rmi.*;
import java.util.*;
public class ProvaRemoteMessageBoxDue {
public static void main(String[] args) {
System.out.println("ProvaRemoteMessageBoxDue - START -");
ADSL adsl;

PersonalAgentID myID = new PersonalAgentID("a1", "c1");


PersonalAgentID myIDremote = new PersonalAgentID("a1", "c1");
MessageBox box1;
Message msg = new Message(myID, myIDremote, null, "Messaggio di
prova");
try {
adsl = (ADSL) Naming.lookup("rmi://127.0.0.1:1099/ADSL");
box1 = new MessageBox();
box1.setOwner(myID);
System.out.println("Provo a reinserire la stessa MessageBox");
Utility.Pause();
try {
adsl.insertRemoteMessageBox(box1);
} catch(RemoteException e) {
System.out.println("MessageBox gia' presente");
}
System.out.println("Recupero la MessageBox da ADSL e provo a
scrivere");
Utility.Pause();
List<RemoteMessageBox> remoteBox2 =
adsl.getRemoteMessageBox(myIDremote);
for( RemoteMessageBox rmb : remoteBox2 ) {
rmb.writeMessage(msg);
System.out.println("Messaggio inserito con successo");
}
System.out.println("Torna a ProvaRemoteMessageBoxUno per
leggere il messaggio");
Utility.Pause();
System.out.println("Provo a eliminare la MessageBox registrata");
Utility.Pause();
try {
adsl.removeRemoteMessageBox(box1);
System.out.println("MessageBox eliminata con successo");
} catch(RemoteException e) {
System.out.println("MessageBox non presente");
}
System.out.println("ProvaRemoteMessageBoxDue terminato, torna
a ProvaRemoteMessageBoxUno");
} catch (MalformedURLException e) {
System.out.println("Errore nella URL per lookup dell'ADSL");
e.printStackTrace();
} catch (RemoteException e) {
System.out.println("Errore nel contattare il registry");
e.printStackTrace();
} catch (NotBoundException e) {
System.out.println("Errore nel nome registrato (non presente)");
e.printStackTrace();
}
System.out.println("ProvaRemoteMessageBoxDue - END -");
}

}
package JAM;
import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
public class ProvaRemoteMessageBoxUno {
public static void main(String[] args) {
System.out.println("ProvaRemoteMessageBoxUno - START -");
ADSL adsl;
PersonalAgentID myID = new PersonalAgentID("a1", "c1");
MessageBox box1;
try {
adsl = (ADSL) Naming.lookup("rmi://127.0.0.1:1099/ADSL");
box1 = new MessageBox();
box1.setOwner(myID);
System.out.println("Registro il box1 e provo a registrarlo
nuovamente...");
try {
adsl.insertRemoteMessageBox(box1);
adsl.insertRemoteMessageBox(box1);
} catch(RemoteException e) {
System.out.println("MessageBox gia' presente");
}
System.out.println("Usa ProvaRemoteMessageBoxDue per inserire
un messaggio");
Utility.Pause();
try {
System.out.println(box1.readMessage().toString());
} catch (JAMMessageBoxException |
JAMBehaviourInterruptedException e) {
System.out.println("Nessun messaggio presente");
}
System.out.println("Torna alla ProvaRemoteMessageBoxDue per
eliminare la MessageBox");
Utility.Pause();
System.out.println("Provo ad eliminare la MessageBox gia' eliminata
dal test 2");
try {
adsl.removeRemoteMessageBox(box1);
System.out.println("MessageBox eliminata con successo");
} catch(RemoteException e) {
System.out.println("MessageBox gia' eliminata");
}
} catch (MalformedURLException e) {
System.out.println("Errore nella URL per lookup dell'ADSL");
e.printStackTrace();
} catch (RemoteException e) {
System.out.println("Errore nel contattare il registry, ADSL non

trovata");
e.printStackTrace();
} catch (NotBoundException e) {
System.out.println("Errore nel nome registrato (non presente)");
e.printStackTrace();
}
System.out.println("ProvaRemoteMessageBoxUno - END -");
}
}
package JAM;
import java.rmi.*;
/**Interfaccia remota per la casella di posta per i messaggi tra agenti.<br>
* @author Devalle Trevor;
* @version 1.0;
* */
public interface RemoteMessageBox extends Remote{
/**Inserisce un messaggio all'interno della casella di posta.
* @param message - Messaggio da inserire.
* @throws RemoteException Errore nell'inserimento in remoto del messaggio.
*/
void writeMessage(Message message) throws RemoteException;
/**Restituisce il proprietario di una casella di posta.
* @return L'agente proprietario della casella.
* @throws RemoteException Errore nell'interrogazione in remoto della casella.
*/
AgentID getOwner() throws RemoteException;
}
package JAM;
import java.util.*;
public class TestParteI {
public static void main(String[] args) {
AgentID agenteCercato;
List<AgentID> listaTrovati;
List<AgentID> lista = new LinkedList<AgentID>();
lista.add(new PersonalAgentID("Matteo", "Baldoni"));
lista.add(new PersonalAgentID("Mario", "Rossi"));
lista.add(new PersonalAgentID("Andrea", "Rossi"));
lista.add(new PersonalAgentID("Alfredo", "Baldoni"));
lista.add(new PersonalAgentID("Alfredo", "Rossi"));
lista.add(new PersonalAgentID("Mercoledi", "Adams"));
// prima parte Personal - Category - Generic.equals(Personal)
agenteCercato = new PersonalAgentID("Mario", "Rossi");
listaTrovati = new LinkedList<AgentID>();
for (AgentID agent : lista)

if (agenteCercato.equals(agent))
listaTrovati.add(agent);
for (AgentID agent : listaTrovati)
System.out.println(agent);
System.out.println("---"); // finito ciclo confronti con PersonalAgentID
agenteCercato = new CategoryAgentID("Rossi");
listaTrovati = new LinkedList<AgentID>();
for (AgentID agent : lista)
if (agenteCercato.equals(agent))
listaTrovati.add(agent);
for (AgentID agent : listaTrovati)
System.out.println(agent);
System.out.println("---"); // finito ciclo confonti con CategoryAgentID
agenteCercato = new GenericAgentID();
listaTrovati = new LinkedList<AgentID>();
for (AgentID agent : lista)
if (agenteCercato.equals(agent))
listaTrovati.add(agent);
for (AgentID agent : listaTrovati)
System.out.println(agent);
// finito ciclo confronti con GenericAgentID
System.out.println("\n\n");
// seconda parte Personal.equals(Personal - Category - Generic)
agenteCercato = new PersonalAgentID("Mario", "Rossi");
listaTrovati = new LinkedList<AgentID>();
for (AgentID agent : lista)
if (agent.equals(agenteCercato))
listaTrovati.add(agent);
for (AgentID agent : listaTrovati)
System.out.println(agent);
System.out.println("---"); // finito ciclo confronti con PersonalAgentID
agenteCercato = new CategoryAgentID("Rossi");
listaTrovati = new LinkedList<AgentID>();
for (AgentID agent : lista)
if (agent.equals(agenteCercato))
listaTrovati.add(agent);
for (AgentID agent : listaTrovati)
System.out.println(agent);
System.out.println("---"); // finito ciclo confonti con CategoryAgentID
agenteCercato = new GenericAgentID();
listaTrovati = new LinkedList<AgentID>();
for (AgentID agent : lista)
if (agent.equals(agenteCercato))
listaTrovati.add(agent);
for (AgentID agent : listaTrovati)
System.out.println(agent);
// finito ciclo confronti con GenericAgentID
}
}

package JAM;
public class TimeProviderAgent extends JAMAgent {
private int orologio;
public TimeProviderAgent(String s) throws JAMADSLException {
super(new PersonalAgentID(s, "Time Provider"));
addBehaviour(new TimeProviderBehaviourCalcola(this));
addBehaviour(new TimeProviderBehaviourServiOra(this));
}
public void resetOra() {
orologio = 0;
}
public void incrementaOra() {
orologio++;
}
public int getOra() {
return orologio;
}
public static void main(String args[]) throws JAMADSLException {
TimeProviderAgent timeprovideragent = new TimeProviderAgent("Berlino");
TimeProviderAgent timeprovideragent1 = new TimeProviderAgent("Parigi");
timeprovideragent.init();
timeprovideragent.start();
timeprovideragent1.init();
timeprovideragent1.start();
/*new JAMAgentMonitor(timeprovideragent);
new JAMAgentMonitor(timeprovideragent1);*/
}
}
package JAM;
public class TimeProviderBehaviourCalcola extends JAMWhileBehaviour {
public TimeProviderBehaviourCalcola(JAMAgent myAgent) {
super(myAgent);
}
public void setup() throws JAMBehaviourInterruptedException {
((TimeProviderAgent)myAgent).resetOra();
}
public void dispose() throws JAMBehaviourInterruptedException { }
public void action() throws JAMBehaviourInterruptedException {
((TimeProviderAgent)myAgent).incrementaOra();
sleep(1000);
}
}
package JAM;
public class TimeProviderBehaviourServiOra extends JAMWhileBehaviour {
private LogFile log;

public TimeProviderBehaviourServiOra(JAMAgent myAgent) {


super(myAgent);
log = new LogFile();
}
public void setup() throws JAMBehaviourInterruptedException {
try {
log.startLog(myAgent.getMyID().toString().trim(), "Log file per " +
myAgent.getMyID());
log.log("0- Inizializzazione comportamento.");
} catch(JAMIOException err) {
System.out.println("Errore: "+ err);
done();
}
}
public void dispose() throws JAMBehaviourInterruptedException {
try {
log.log("END- Esecuguita dispose.");
log.endLog();
} catch(JAMIOException err) {
System.out.println("Errore: " + err);
done();
}
}
public void action() throws JAMBehaviourInterruptedException {
try {
log.log("1- Start del comportamento, attesa messaggio iniziale.");
Message message = myAgent.receive();
log.log("2- Ricevuto messaggio iniziale, inizio sua analisi");
if(message.getPerformative() != Performative.REQUEST) {
log.log("3- Performativa diversa da REQUEST, preparo REFUSE.",
message);
Message request = new Message(
myAgent.getMyID(),
message.getSender(),
Performative.REFUSE,
"Performativa non accettata",
message
);
log.log("4- Invio REFUSE", request);
myAgent.send(request);
log.log("5- Inviata REFUSE", request);
} else if(!message.getContent().equals("Che ora e'?")) {
log.log("6- Non capisco il content, preparo NOT_UDERSTOOD.",
message);
Message not_understood = new Message(
myAgent.getMyID(),
message.getSender(),
Performative.NOT_UNDERSTOOD,
"REQUEST non compresa",
message

);
log.log("7- Invio NOT_UNDERSTOOD.", not_understood);
myAgent.send(not_understood);
log.log("8- Invita NOT_UNDERSTOOD.", not_understood);
} else {
log.log("9- REQUEST accettabile, preparo AGREE.", message);
AgentID agentid = message.getSender();
Message agree = new Message(
myAgent.getMyID(),
agentid,
Performative.AGREE,
"REQUEST accettata",
message
);
log.log("10- Invio AGREE.", agree);
myAgent.send(agree);
log.log("11- Inviata AGREE.", agree);
log.log("12- Mi metto in attesa conferma da " + agentid + ".");
sleep(1000);
log.log("13- Mi risveglio e verifico se arrivata conferma da " + agentid +
".");
if(!myAgent.check(agentid, Performative.INFORM)) {
log.log("14- Nessuna conferma da " + agentid + ".");
} else {
Message confirm = myAgent.receive(agentid, Performative.INFORM);
log.log("15- Arrivata conferma da " + agentid + ".", confirm);
if(confirm.getContent().equals("Aspetto l'ora.")) {
log.log("16- Preparo messaggio con ora per " + agentid + ".");
Message inform = new Message(
myAgent.getMyID(),
agentid,
Performative.INFORM,
"Ora: "+ ((TimeProviderAgent)myAgent).getOra()
);
log.log("17- Invio ora a " + agentid + ".", inform);
myAgent.send(inform);
log.log("19- Inviata ora a " + agentid + ".", inform);
}
}
}
/*} catch(JAMADSLException err1) {
System.out.println("Errore: " + err1);
done();*/
} catch(JAMIOException err2) {
System.out.println("Errore: " + err2);
done();
}
}
}

package JAM;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public final class Utility {
public static void Pause() {
BufferedReader br=new BufferedReader(new
InputStreamReader(System.in));
System.out.println("Premere invio per continuare");
try {
br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
}
}