Download to read offline
![ReSpecT
ACC
Introduzione
Ciclo di vita
Struttura
Sicurezza
ACC in Tucson
Esempio
Esempio di utilizzo dell’ACC di default
import alice.tucson.api.*;
import alice.logictuple.*;
public class Test {
public static void main(String[] args) throws Exception {
TucsonContext cn = Tucson.enterDefaultContext();
TupleCentreId tid = new TupleCentreId(‘test tc’);
cn.out(tid, new LogicTuple(‘p’,new Value(‘hello world’)));
LogicTuple t=cn.in(tid, new LogicTuple(‘p’,new Var(‘X’)));
System.out.println(t);
}
}
Stefano Ficcadenti, Roberto Mindoli ReSpecT & ACC](https://image.slidesharecdn.com/respecteacc-130524111839-phpapp02/85/Respect-and-Agent-Coordination-Context-18-320.jpg)
![ReSpecT
ACC
Introduzione
Ciclo di vita
Struttura
Sicurezza
ACC in Tucson
Esempio
Esempio di accesso a TuCSoN attraverso l’ACC di default
import logictuple.*;
import tucson.api.*;
public class Test2 {
public static void main (String args[]) throws Exception{
AgentId aid=new AgentId(‘agent 0’);
TucsonContext cn = Tucson.enterContext(new DefaultContextDescription(aid));
// put the tuple value(1,38.5) on the temperature tuple centre
TupleCentreId tid=new TupleCentreId(‘temperature’);
LogicTuple outTuple=LogicTuple.parse(‘value(1,38.5)’);
cn.out(tid,outTuple);
// retrieve the tuple using value(1,X) as a template
LogicTuple tupleTemplate=new LogicTuple(‘value’, new Value(1), new Var(‘X’));
LogicTuple inTuple=cn.in(tid,tupleTemplate);
cn.exit();
System.out.println(inTuple);
}
}
Stefano Ficcadenti, Roberto Mindoli ReSpecT & ACC](https://image.slidesharecdn.com/respecteacc-130524111839-phpapp02/85/Respect-and-Agent-Coordination-Context-19-320.jpg)
Uploaded byStefano Ficcadenti
Respect and Agent Coordination Context
Il documento descrive il linguaggio di programmazione 'respect' utilizzato nei tuple centres programmabili per la coordinazione degli agenti, evidenziando le sue componenti e funzionalità, inclusi eventi e reazioni. Viene anche trattato il concetto di Agent Coordination Context (ACC), che serve a gestire l'interazione tra agenti e ambiente, con focus sulla sicurezza e sul controllo accessi. Infine, il documento fornisce esempi pratici sull'uso dell'ACC in contesti di programmazione Java.
Respect and Agent Coordination Context
- 1. ReSpecT ACC ReSpecT & ACC AnalisiReSpecT e ruolo ACC in TuCSoN Stefano Ficcadenti, Roberto Mindoli Universit`a di Camerino, Italy 14 Gennaio 2008 Stefano Ficcadenti, Roberto Mindoli ReSpecT & ACC
- 2. ReSpecT ACC Sommario ReSpecT Introduzione Reazioni Predicati Costrutti Sintassi ACC Introduzione Ciclo di vita Struttura Sicurezza ACCin Tucson Stefano Ficcadenti, Roberto Mindoli ReSpecT & ACC
- 3. ReSpecT ACC Introduzione Reazioni Predicati Costrutti Sintassi Introduzione ReSpecT I tuplecentres sono tuple spaces programmabili: il loro comportamento pu`o essere programmato utilizzando un linguaggio logico chiamato ReSpecT, che definisce leggi di coordinazione per l’interazione degli agenti. ReSpecT: permette la computazione all’interno dei tuple centers rende possibile associare le reazioni agli eventi di comunicazione che si verificano sul tuple centres ReSpecT ha sia una parte dichiarativa e una procedurale. Stefano Ficcadenti, Roberto Mindoli ReSpecT & ACC
- 4. ReSpecT ACC Introduzione Reazioni Predicati Costrutti Sintassi Reazioni Un programma ReSpecT`e formato da una serie di reazioni della seguente forma: reaction(Event,(Body)) Event: include le primitive di base di comunicazione (out, in, rd, inp, rdp) e alcune primitive di ReSpecT (out r, in r, rd r, no r) Body: `e una sequenza di predicati. I predicati permettono di inspezionare e cambiare il contenuto di un insieme di tuple inserendo, rimuovendo o leggendo tuple. Le reazioni sono eseguite una ad una sequenzialmente con la semantica transazionale. Stefano Ficcadenti, Roberto Mindoli ReSpecT & ACC
- 5. ReSpecT ACC Introduzione Reazioni Predicati Costrutti Sintassi Predicati di ReSpecT- Parte 1 tucson versione 1.3.0 out r(T): inserimento di una tupla logica T in r(TT): rimuove una tupla logica che fa matching con il template TT rd r(TT): legge una tupla logica che fa matching con il template TT no r(TT): ha successo se non ci sono tuple che fanno matching con il template TT pre: succede nella fase preliminare di qualsiasi operazione post: succede nella fase finale di qualsiasi operazione success: succede se la reazione ha successo failure: succede se la reazione fallisce current agent(TT): succede se TT identifica l’agente che con l’evento di comunicazione ha scatenato la reazione current tuple(TT): succede se TT `e la tupla dell’evento di comunicazione che ha scatenato la reazione current tc(TT): succede se TT `e il nome del tuple centre corrente current op(TT): succede se TT `e l’identificatore dell’operazione che ha prodotto il corrente evento Stefano Ficcadenti, Roberto Mindoli ReSpecT & ACC
- 6. ReSpecT ACC Introduzione Reazioni Predicati Costrutti Sintassi Predicati di ReSpecT- Parte 2 tucson versione 1.4.5 current time(TT): succede se TT `e la tupla che denota il ‘Virtual Machine time’ del tuple centre corrente out (TC,T): succede se TC `e un nome di tuple centre valido e raggiungibile. Viene inserito T sul tuple centre TC spawn(AgentID,AgentType,AgentList): succede se AgentID `e un valido identificatore di un agente, AgentType denota un valido tipo di agente e AgentList `e una lista di tuple. La primitiva produce un nuovo agente con le caratteristiche passate come argomenti. L’AgentType pu`o essere Java(Classname) o Prolog(Filename) Stefano Ficcadenti, Roberto Mindoli ReSpecT & ACC
- 7. ReSpecT ACC Introduzione Reazioni Predicati Costrutti Sintassi Costrutti di basein ReSpecT ReSpecT `e un linguaggio Turing equivalente quindi ogni possibile funzione/algoritmo di computazione pu`o essere specificata come codifica ReSpecT. I costrutti di base che tipicamente sono utilizzati negli algoritmi possono essere realizzati in ReSpecT da opportune composizioni di reazioni. Selezione Iterazione Ricorsione Stefano Ficcadenti, Roberto Mindoli ReSpecT & ACC
- 8. ReSpecT ACC Introduzione Reazioni Predicati Costrutti Sintassi Selezione reaction( E ,( A, out r(check(T)))) reaction(out r(check(T))),( rd r(T), B )) reaction(out r(check(T))),( no r(T), C )) reaction(out(compare(X,Y)),( X > Y, out r(is greater(X,Y)) )) reaction(out(compare(X,Y)),( X < Y, out r(is less(X,Y)) )) Stefano Ficcadenti, Roberto Mindoli ReSpecT & ACC
- 9. ReSpecT ACC Introduzione Reazioni Predicati Costrutti Sintassi Iterazione e Ricorsione reaction(out(factorial(N,)),( in r(factorial(N, )), out r(fact loop(1,N,1)))) reaction(out r(fact loop(N,N,F)),( in r(fact loop(N,N,F)), out r(factorial(N,F)))) reaction(out r(fact loop(I,N,F)),( in r(fact loop(I,N,F)), N > I, I1 is I + 1, F1 is F * I1, out r(fact loop(I1,N,F1)))) Stefano Ficcadenti, Roberto Mindoli ReSpecT & ACC
- 10.
- 11. ReSpecT ACC Introduzione Ciclo di vita Struttura Sicurezza ACCin Tucson Introduzione ACC La nozione di Agent Coordination Context `e stata introdotta come una prima astrazione di modello ad agenti e interazione tra agenti Un ACC rappresenta un’interfaccia che un agente deve avere per poter invocare una primitiva di coordinazione su un tuple centre Un ACC `e un’astrazione fornita dall’infrastruttura per ogni agente che accede al MAS, con lo scopo di abilitare e controllare tutte le interazioni dell’agente con il suo ambiente L’ACC rappresenta il confine tra l’agente e l’ambiente Stefano Ficcadenti, Roberto Mindoli ReSpecT & ACC
- 12. ReSpecT ACC Introduzione Ciclo di vita Struttura Sicurezza ACCin Tucson Ciclo di vita di un ACC 2 fasi caratterizzano la vita di un ACC: Acquisizione dell’ACC: nella fase di negoziazione un agente specifica le strutture che utilizza e il suo ruolo. Se la negoziazione ha successo un ACC viene acquisito dall’agente Utilizzo dell’ACC: l’agente utilizza l’ACC per interagire con l’ambiente rispettando le regole dell sistema definite nalla configurazione dell’ACC Stefano Ficcadenti, Roberto Mindoli ReSpecT & ACC
- 13. ReSpecT ACC Introduzione Ciclo di vita Struttura Sicurezza ACCin Tucson Struttura di un ACC Un Agent Coordination Context `e definito da: Interface: definisce l’insieme di operazioni che l’agente pu`o utilizzare all’interno di TuCSoN Contract: `e la descrizione delle relazioni tra l’agente e l’infrastruttura, in particolare le politiche che regolano le azioni dell’agente e i protocolli di interazione Contract State: `e la descrizione dello stato di runtime dell’ACC (include current time(Time), current Node(Node) e current state(RoleState))) Stefano Ficcadenti, Roberto Mindoli ReSpecT & ACC
- 14. ReSpecT ACC Introduzione Ciclo di vita Struttura Sicurezza ACCin Tucson ACC & Sicurezza Il concetto di ACC `e anche utilizzato per estendere la sicurezza attraverso l’approccio RBAC (Role-based Access Control). La nozione di ruolo rende possibile stabilire un controllo degli accessi basato sul ruolo. Il ruolo determina l’insieme di azioni e i protocolli di interazione che un agente pu`o eseguire. Stefano Ficcadenti, Roberto Mindoli ReSpecT & ACC
- 15. ReSpecT ACC Introduzione Ciclo di vita Struttura Sicurezza ACCin Tucson Accesso a TuCSoN da agenti Java TuCSoN ha un’interfaccia di programmazione applicativa, che permette l’accesso all’infrastruttura da parte di applicazioni scritte in Java e in tuProlog. Per accedere a TuCSoN, deve essere acquisito e usato un Agent Coordination Context (ACC), che rappresenta una sorta di interfaccia per alcuni contesti di coordinazione nello spazio di coordinazione supportato dall’infrastruttura. Essenzialmente, un ACC definisce quali azioni sono permesse o meglio quali sono proibite. Stefano Ficcadenti, Roberto Mindoli ReSpecT & ACC
- 16. ReSpecT ACC Introduzione Ciclo di vita Struttura Sicurezza ACCin Tucson Interfaccia - Parte 1 ACC `e implementato dall’interfaccia TucsonContext. Nella versione 1.4.5 un ACC pu`o essere associato ad un solo singolo thread; cos`ı gli agenti composti da pi`u threads devono acquisire ACCS multipli. package alice.tucson.api; import alice.logictuple.*; public interface TucsonContext { void out(TupleCentreId tid, LogicTuple t) throws OperationNotAllowedException, UnreachableNodeException; LogicTuple in(TupleCentreId tid, LogicTuple t) throws OperationNotAllowedException, UnreachableNodeException; LogicTuple rd(TupleCentreId tid, LogicTuple t) throws OperationNotAllowedException, UnreachableNodeException; Stefano Ficcadenti, Roberto Mindoli ReSpecT & ACC
- 17. ReSpecT ACC Introduzione Ciclo di vita Struttura Sicurezza ACCin Tucson Interfaccia - Parte 2 LogicTuple inp(TupleCentreId tid, LogicTuple t) throws OperationNotAllowedException, UnreachableNodeException; LogicTuple rdp(TupleCentreId tid, LogicTuple t) throws OperationNotAllowedException, UnreachableNodeException; void setSpec(TupleCentreId tid, String spec) throws OperationNotAllowedException, UnreachableNodeException, InvalidSpecificationException; String getSpec(TupleCentreId tid) throws OperationNotAllowedException, UnreachableNodeException; void exit() throws OperationNotAllowedException; } Stefano Ficcadenti, Roberto Mindoli ReSpecT & ACC
- 18. ReSpecT ACC Introduzione Ciclo di vita Struttura Sicurezza ACCin Tucson Esempio Esempio di utilizzo dell’ACC di default import alice.tucson.api.*; import alice.logictuple.*; public class Test { public static void main(String[] args) throws Exception { TucsonContext cn = Tucson.enterDefaultContext(); TupleCentreId tid = new TupleCentreId(‘test tc’); cn.out(tid, new LogicTuple(‘p’,new Value(‘hello world’))); LogicTuple t=cn.in(tid, new LogicTuple(‘p’,new Var(‘X’))); System.out.println(t); } } Stefano Ficcadenti, Roberto Mindoli ReSpecT & ACC
- 19. ReSpecT ACC Introduzione Ciclo di vita Struttura Sicurezza ACCin Tucson Esempio Esempio di accesso a TuCSoN attraverso l’ACC di default import logictuple.*; import tucson.api.*; public class Test2 { public static void main (String args[]) throws Exception{ AgentId aid=new AgentId(‘agent 0’); TucsonContext cn = Tucson.enterContext(new DefaultContextDescription(aid)); // put the tuple value(1,38.5) on the temperature tuple centre TupleCentreId tid=new TupleCentreId(‘temperature’); LogicTuple outTuple=LogicTuple.parse(‘value(1,38.5)’); cn.out(tid,outTuple); // retrieve the tuple using value(1,X) as a template LogicTuple tupleTemplate=new LogicTuple(‘value’, new Value(1), new Var(‘X’)); LogicTuple inTuple=cn.in(tid,tupleTemplate); cn.exit(); System.out.println(inTuple); } } Stefano Ficcadenti, Roberto Mindoli ReSpecT & ACC