Post on 16-Aug-2020
Vittorio Scarano
Corso di Programmazione Distribuita (2003-2004)
Laurea di I livello in Informatica
Università degli Studi di Salerno
Lezione 13Lezione 13Remote Remote MethodMethod InvocationInvocation
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
2
Organizzazione della lezioneOrganizzazione della lezione
• Remote Method Invocation
• Le classi ed interfacce di RMI
• La architettura a strati di RMI
• Una suddivisione funzionale di RMI
• Il processo di creazione
• Un esempio di uso: ����������
• La sicurezza in Java
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
3
Remote Remote MethodMethod InvocationInvocation (RMI)(RMI)
• RMI è un modello ad oggetti distribuito offerto da Java
• Il modello mantiene le caratteristiche di Java...– …e si integra all'interno della semantica di Java.
• Il principio: "Write once, Run anywhere"
• Estensione "ad oggetti" di Remote Procedure Call– fornisce la visione astratta di una chiamata di procedura
remota verso altri processi
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
4
Applicazioni ad oggetti distribuiteApplicazioni ad oggetti distribuite
• Applicazioni composte da server e client– Il server:
• crea un certo numero di oggetti • li rende accessibili da remoto• attende le invocazioni dei client sugli oggetti
– Il client:• preleva la reference ad uno o più oggetti remoti• invoca i loro metodi
• Ruolo tra client e server spesso “confuso”– “servent” in una architettura peer-to-peer
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
5
Ed RMI?Ed RMI?
• RMI fornisce il meccanismo attraverso il quale server e client comunicano
• Una applicazione distribuita deve, quindi, poter:– Localizzare oggetti remoti
• attraverso un registro
– Comunicare con oggetti remoti• nascondere per quanto possibile i dettagli della invocazione remota
– Poter caricare dinamicamente classi dalla rete• tra i parametri passati possono esserci anche oggetti
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
6
Uno schema di funzionamento per RMIUno schema di funzionamento per RMI
Client
Server
Registry
Web ServerWeb Server
1. Registrazione oggetto con un nome sul registry da parte del server
2. Il client ricerca il nome sul registry ed ottiene un riferimento remoto
3. Il client invoca il metodo remoto sull’oggetto
• Caricamento dinamico delle classi da Web server
4. per i parametri del metodo passati al server
5. per oggetti come valori restituiti dal metodo
12
3
4 5
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
7
Organizzazione della lezioneOrganizzazione della lezione
• Remote Method Invocation
• Le classi ed interfacce di RMI
• La architettura a strati di RMI
• Una suddivisione funzionale di RMI
• Il processo di creazione
• Un esempio di uso: ����������
• La sicurezza in Java
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
8
Le classi ed interfacce di RMILe classi ed interfacce di RMI
RemoteObject
<<interface>>Remote
RemoteServer
Activatable UnicastRemoteObject
IOException
RemoteException
Object
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
9
Le interfacce remoteLe interfacce remote
• Una interfaccia remota dichiara metodi che possono essere invocati da una JVM remota
• Requisiti di una interfaccia remota– deve derivare (direttamente o indirettamente) da
java.rmi.Remote• una interfaccia marker (definita vuota)
– tutti i metodi dichiarati devono essere remoti• devono indicare che lanciano java.rmi.RemoteException o una delle
superclassi java.io.IOException o java.lang.Exception)
• parametri remoti devono essere dichiarati tramite la corrispondente interface P
rogr
amm
azio
ne D
istr
ibui
ta (
2003
-200
4).
Vi.t
tori
oSc
aran
o
10
Le classi ed interfacce di RMILe classi ed interfacce di RMI
RemoteObject
<<interface>>Remote
RemoteServer
Activatable UnicastRemoteObject
IOException
RemoteException
Object
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
11
Le eccezioni remoteLe eccezioni remote
• La classe java.rmi.RemoteException rappresenta le eccezioni che possono essere generate a runtime
• Alcuni possibili motivi:– malfunzionamento della comunicazione
• server non raggiungibile
• server rifiuta connessioni
• connessione chiusa dal server
– errore durante il trasferimento dei parametri o dei valori di ritorno
– errori del protocollo RMI Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
12
Le classi ed interfacce di RMILe classi ed interfacce di RMI
RemoteObject
<<interface>>Remote
RemoteServer
Activatable UnicastRemoteObject
IOException
RemoteException
Object
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
13
Gli oggetti remoti (server)Gli oggetti remoti (server)
• Le classi sono:– java.rmi.server.RemoteObject
• superclasse (astratta): implementa hashCode(), equals() e toString()
– java.rmi.server.RemoteServer• superclasse (astratta) per server (gestione log, etc.)
– java.rmi.server.UnicastRemoteObject• superclasse (astratta) per un oggetto remoto il cui riferimento è
valido solo se è attivo il server
– java.rmi.activation.Activatable• superclasse (astratta) per oggetti attivabili: cominciano la loro
esecuzione all’atto della chiamata e possono “chiudersi” se necessario (run on-demand)
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
14
Organizzazione della lezioneOrganizzazione della lezione
• Remote Method Invocation
• Le classi ed interfacce di RMI
• La architettura a strati di RMI
• Una suddivisione funzionale di RMI
• Il processo di creazione
• Un esempio di uso: ����������
• La sicurezza in Java
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
15
La architettura a strati di RMILa architettura a strati di RMI
Transport Layer
Remote Reference Layer
Stub&Skeleton Layer
Remote Reference Layer
Stub&Skeleton Layer
Client Program Server Program
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
16
Il Il layerlayer Stub&SkeletonStub&Skeleton
• Usa un Design Pattern chiamato Proxy– un oggetto in un contesto viene rappresentato da un altro
oggetto (detto proxy) in un altro contesto
– il proxy sa come fare il forward delle chiamate di metodi tra gli oggetti
Proxy
+request()
RealObj
+request()
<<interface>>Obj
+request()Stub
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
17
Il Il LayerLayer Remote Remote ReferenceReference
• Definisce il comportamento delle chiamate RMI
• Fino a JDK 1.2 esistevano stub (proxy lato client) e skeleton (lato server)
• Da JDK 1.3 in poi, basta solo lo stub:– Lo stub usa il metodo invoke() (reflection) per chiamare il
metodo remoto
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
18
Il Il LayerLayer di Trasportodi Trasporto
• Connessioni basate su stream TCP/IP
• RMI usa un protocollo wire-level chiamato Java Remote Method Protocol (JRMP)
• Possibile usare (con RMI-IIOP) il protocollo Internet Inter-ORB Protocol (IIOP) di Corba– integrazione di RMI con Corba
– alcune modifiche necessarie alla semantica di RMI
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
19
Organizzazione della lezioneOrganizzazione della lezione
• Remote Method Invocation
• Le classi ed interfacce di RMI
• La architettura a strati di RMI
• Una suddivisione funzionale di RMI
• Il processo di creazione
• Un esempio di uso: ����������
• La sicurezza in Java
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
20
I livelli visti ortogonalmenteI livelli visti ortogonalmente
• Tre strati (layers):– stub/skeleton layer
• interfaccia tra oggetti cliente server per interagire
– remote reference layer• gestisce i riferimenti remoti
ad oggetti
– transport protocol layer• protocollo dati binario per
trasmettere richieste/risposte
Oggetto
Client
Oggetto
Server
Stub
Skeleton
Remote ReferenceManager
Remote ReferenceManager
RMI TransportLayer
Stub/S
keletonL
ayer
Rem
ote
Ref
eren
ceL
ayer
Server
Client
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
21
Passaggio di parametri (1)Passaggio di parametri (1)
• Parametro – argomento o valore restituito da un metodo
• Attraverso RMI, i parametri possono essere qualsiasi oggetto serializzabile– serializzabile = trasformabile in un flusso di byte
• tipi primitivi,
• oggetti remoti
• oggetti non-remoti che implementino la interface Serializable P
rogr
amm
azio
ne D
istr
ibui
ta (
2003
-200
4).
Vi.t
tori
oSc
aran
o
22
Passaggio di parametri (2)Passaggio di parametri (2)
• Passaggio di parametri non remoti per copia– cioè l'oggetto è serializzato e trasmesso
• Passaggio di parametri remoti: si trasmette lo stub
JVM1 JVM2
A A
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
23
Passaggio di parametri (3)Passaggio di parametri (3)
• Integrità referenziale: – due riferimenti allo stesso oggetto, passati nella stessa
invocazione, si riferiranno ad una stessa copia dell'oggetto sulla destinazione
JVM1 JVM2A
B
A
B
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
24
Passaggio di parametri (4)Passaggio di parametri (4)
• Annotazione di classi: – insieme all'oggetto, il sistema annota il descrittore di classe
con il nome ed altre informazioni (URL) che ne permetta il caricamento dinamico
JVM1 JVM2
AA
Class C
istanceof
Nome ed URL della Classe C
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
25
Localizzazione di oggetti remotiLocalizzazione di oggetti remoti
• Necessario un servizio di naming (directory service)
• Diverse possibilità– Java Naming and Directory Interface (JNDI)
– Registry di RMI (semplice servizio fornito con RMI)
• Il registry di RMI viene acceduto con i metodi offerti dalla classe statica java.rmi.Naming
• Fornisce 5 metodi:public static String[ ] list(String name) public static Remote lookup(String name) public static void bind(String name, Remote obj) public static void rebind(String name, Remote obj) public static void unbind(String name)
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
26
Uso di Uso di ��������������������������
• Gli argomenti ai metodi di Naming accettano una String che è una URL con il seguente formato:
rmi://host:port/name
• Default: host vale localhost, port vale 1099
• Name è il nome (human-readible) dell’oggetto
Metodi usati:• public static Remote lookup(String name)
– restituisce un riferimento ad un oggetto remoto con quella identificazione presso il registry
• public static void bind(String name, Remote obj) – effettua il bind dell’oggetto obj con la identificazione name
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
27
Architettura di RMI: funzionamento (1)Architettura di RMI: funzionamento (1)
• Client fa la richiesta chiamando un metodo sullo stub
• Lo stub ha un riferimento all’oggetto remoto ed invia la richiesta al layer del riferimento remoto facendo il marshalling degli argomenti:– convertire oggetti locali in forma portabile a remoto
• oggetti locali vengono serializzati (interface Serializable)
• oggetti remoti (interface Remote): riferimento remoto
• .....
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
28
Architettura di RMI: funzionamento (2)Architettura di RMI: funzionamento (2)
• Il remote reference layer del server riceve la richiesta e la trasforma in una richiesta allo skeleton
• Lo skeleton converte la richiesta nel metodo chiamato facendo l’unmarshalling i parametri e passandoli all’oggetto
• Eccezioni e valori restituiti dal metodo vengono passate al client attraverso skeleton e stub
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
29
Organizzazione della lezioneOrganizzazione della lezione
• Remote Method Invocation
• Le classi ed interfacce di RMI
• La architettura a strati di RMI
• Una suddivisione funzionale di RMI
• Il processo di creazione
• Un esempio di uso: ����������
• La sicurezza in Java
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
30
RMI: Il processo di creazioneRMI: Il processo di creazione1 1 -- Definizione della interface remotaDefinizione della interface remota
• Il server dichiara i servizi offerti attraverso un interface remota
• La interface deve estendere �������������
• Ogni metodo deve lanciare la eccezione��������������� ����
Definire la interface remota
Implementare la interface
javac
rmic
Serverclass
ServerskeletonClient
StubImplementare
il client
javac
Lanciareil client
Lanciare rmiregistry
Lanciare oggetti server
Registrare oggetti server
1
ServerClient
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
31
RMI: Il processo di creazione RMI: Il processo di creazione 2 2 -- Implementazione della interface remotaImplementazione della interface remota
• Il server implementa la interface remota
• Gli oggetti remoti devono derivare da������������ ����������
Definire la interface remota
Implementare la interface
javac
rmic
Serverclass
ServerskeletonClient
StubImplementare
il client
javac
Lanciareil client
Lanciare rmiregistry
Lanciare oggetti server
Registrare oggetti server
1
2
ServerClient
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
32
RMI: Il processo di creazioneRMI: Il processo di creazione3 3 -- Compilazione con Compilazione con javacjavac
• La classe server viene compilata con javac
• La compilazione genera la classe Server
Definire la interface remota
Implementare la interface
javac
rmic
Serverclass
ServerskeletonClient
StubImplementare
il client
javac
Lanciareil client
Lanciare rmiregistry
Lanciare oggetti server
Registrare oggetti server
1
2
3
ServerClient
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
33
RMI: Il processo di creazioneRMI: Il processo di creazione4 4 -- Compilazione con lo Compilazione con lo stubstub compilercompiler rmicrmic
• rmic viene eseguito sulla classe server
• Genera – un client stub– un server skeleton
• Lo stub (client proxy)– invia le chiamate remote verso
il server– effettua il marshalling dei
parametri
• Lo skeleton (server proxy)– riceve le chiamate remote– unmarshal parametri– chiama i metodi dell'oggetto
Definire la interface remota
Implementare la interface
javac
rmic
Serverclass
ServerskeletonClient
StubImplementare
il client
javac
Lanciareil client
Lanciare rmiregistry
Lanciare oggetti server
Registrare oggetti server
1
2
3
4
ServerClient
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
34
RMI: Il processo di creazioneRMI: Il processo di creazione5 5 -- Lanciare Lanciare rmiregistryrmiregistry
• Servizio di Naming non persistente
• Permette la registrazione e il retrieve di oggetti per nome
• Un server può anche implementare il proprio registry
• Deve essere localizzato sulla macchina del server
Definire la interface remota
Implementare la interface
javac
rmic
Serverclass
ServerskeletonClient
StubImplementare
il client
javac
Lanciareil client
Lanciare rmiregistry
Lanciare oggetti server
Registrare oggetti server
1
2
3
5
4
ServerClient
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
35
RMI: Il processo di creazioneRMI: Il processo di creazione6 6 -- Lanciare oggetti del serverLanciare oggetti del server
• Il server viene lanciato
• Crea gli oggetti che devono essere acceduti da remoto
Definire la interface remota
Implementare la interface
javac
rmic
Serverclass
ServerskeletonClient
StubImplementare
il client
javac
Lanciareil client
Lanciare rmiregistry
Lanciare oggetti server
Registrare oggetti server
1
2
3
5
4
6
ServerClient
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
36
RMI: Il processo di creazioneRMI: Il processo di creazione7 7 -- Registrazione degli oggetti del serverRegistrazione degli oggetti del server
• Ogni oggetto da accedere da remoto deve essere registrato sul registry
• Si usano i metodi di ��������������� per effettuare il binding di nomi ad oggetti
Definire la interface remota
Implementare la interface
javac
rmic
Serverclass
ServerskeletonClient
StubImplementare
il client
javac
Lanciareil client
Lanciare rmiregistry
Lanciare oggetti server
Registrare oggetti server
1
2
3
5
4
6
7
ServerClient
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
37
RMI: Il processo di creazioneRMI: Il processo di creazione8 8 -- Implementazione del Implementazione del ClientClient
• Il client viene implementato
• Di norma, non richiede molte modifiche
• Usa i metodi di ��������������� per localizzare un oggetto remoto
• L'invocazione dei metodi usa lo stub come intermediario
Definire la interface remota
Implementare la interface
javac
rmic
Serverclass
ServerskeletonClient
StubImplementare
il client
javac
Lanciareil client
Lanciare rmiregistry
Lanciare oggetti server
Registrare oggetti server
1
2
3
5
4
6
7
8
ServerClient
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
38
RMI: Il processo di creazioneRMI: Il processo di creazione9/10 9/10 -- Compilazione ed esecuzione del Compilazione ed esecuzione del ClientClient
• Il Client viene compilato ed eseguito.
• L'accesso agli oggetti remoti viene effettuato attraverso gli stub
• Gli stub possono anche essere caricati a run-time
Definire la interface remota
Implementare la interface
javac
rmic
Serverclass
ServerskeletonClient
StubImplementare
il client
javac
Lanciareil client
Lanciare rmiregistry
Lanciare oggetti server
Registrare oggetti server
1
2
3
5
4
6
7
8
9
10
ServerClient
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
39
Le classi generateLe classi generate
Remote Interface
Implementazione dellaRemote Interface
ClientObjects
ClientObjects
ClientObjects
Implementazioni delRemote Obj
Implementazioni delRemote Obj
Implementazioni delRemote Obj
Stub Class Skeleton Class
Stub Object Skeleton Object
Generate da rmic
Scrittodal
programmatore
Implementazione del Client
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
40
Organizzazione della lezioneOrganizzazione della lezione
• Remote Method Invocation
• Le classi ed interfacce di RMI
• La architettura a strati di RMI
• Una suddivisione funzionale di RMI
• Il processo di creazione
• Un esempio di uso: ����������
• La sicurezza in Java
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
41
Un esempio di uso: l'oggetto remoto Un esempio di uso: l'oggetto remoto HelloHello
• Definizione della Interface Remota • definizione derivata da java.rmi.Remote• ogni metodo deve lanciare java.rmi.RemoteException
• Scrivere la implementazione della Classe Server• specificare la interface remota• specificare il/i costruttore/i dell'oggetto remoto• implementare i metodi remoti• creare ed installare un security manager• creare una o più istanze di oggetti remoti• registrare gli oggetti al registry.
• Scrivere la Classe Client• ottenere un riferimento remoto all'oggetto remoto dal registro
• invocare il/i metodo remoto
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
42
Il diagramma di Il diagramma di RemoteHelloRemoteHello
+ dimmiQualcosa(in daChi: String): String
«interface»Hello
+ HelloImpl(): void
+ dimmiQualcosa(in daChi: String): String
+ main(in args: String[]): void
HelloImpl
+ main(in args: String[]): void
HelloClient
«interface»Remote
UnicastRemoteObject
+ dimmiQualcosa(in daChi: String): String
«interface»Hello
+ HelloImpl(): void
+ dimmiQualcosa(in daChi: String): String
+ main(in args: String[]): void
HelloImpl
+ main(in args: String[]): void
HelloClient
«interface»Remote
UnicastRemoteObject
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
43
RMI: Il processo di creazioneRMI: Il processo di creazione1 1 -- Definizione della interface remotaDefinizione della interface remota
Definire la interface remota
Implementare la interface
javac
rmic
Serverclass
ServerskeletonClient
StubImplementare
il client
javac
Lanciareil client
Lanciare rmiregistry
Lanciare oggetti server
Registrare oggetti server
1
ServerClient
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
44
La interface remota dell'oggetto: il file La interface remota dell'oggetto: il file Hello.javaHello.java
public interface Helloextends java.rmi.Remote {
String dimmiQualcosa(String daChi) throws java.rmi.RemoteException;
}
• Interface– eredita da
java.rmi.Remote
• Metodo dimmiQualcosadichiarato
• Lancia RemoteException
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
45
RMI: Il processo di creazione RMI: Il processo di creazione 2 2 -- Implementazione della interface remotaImplementazione della interface remota
Definire la interface remota
Implementare la interface
javac
rmic
Serverclass
ServerskeletonClient
StubImplementare
il client
javac
Lanciareil client
Lanciare rmiregistry
Lanciare oggetti server
Registrare oggetti server
1
2
ServerClient
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
46
La implementazione dell'oggetto remoto: La implementazione dell'oggetto remoto: il file il file HelloImpl.javaHelloImpl.java (1)(1)
import java.rmi.*;import java.rmi.server.UnicastRemoteObject;
public class HelloImplextends UnicastRemoteObjectimplements Hello {
public HelloImpl() throws java.rmi.RemoteException {}
public String dimmiQualcosa(String daChi) throws RemoteException {
System.out.println("Saluto "+daChi);return "Ciao "+daChi+"!";
}// continua……
• Derivato da … • … e implementa la
interface remota• Il costruttore (vuoto)
dell'oggetto remoto – con chiamata
implicita al costruttore della superclasse
• Implementazione del metodo remoto
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
47
La implementazione dell'oggetto remoto: La implementazione dell'oggetto remoto: il file il file HelloImpl.javaHelloImpl.java (2)(2)
// continua … … public static void main(String args[]) {System.setSecurityManager(new
RMISecurityManager());try {
HelloImpl obj = new HelloImpl();Naming.rebind("HelloServer", obj);System.out.println("Pronto!");
} catch (Exception e) {e.printStackTrace();
}} // end main} // end classe HelloImpl
• Crea ed installa un security manager– utile per poter caricare
classi dinamicamente se non sono presenti sul CLASSPATH
• crea una istanza di oggetto remoto obj
• registra l'oggetto sul registry
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
48
RMI: Il processo di creazioneRMI: Il processo di creazione3/4 3/4 -- Compilazione con Compilazione con javacjavac
Definire la interface remota
Implementare la interface
javac
rmic
Serverclass
ServerskeletonClient
StubImplementare
il client
javac
Lanciareil client
Lanciare rmiregistry
Lanciare oggetti server
Registrare oggetti server
1
2
3
ServerClient
4
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
49
La compilazione del server La compilazione del server HelloImplHelloImpl
• Compilazione della interface:– javac Hello.java
• Compilazione del server:– javac HelloImpl.java
• Generazione stub e skeleton:– rmic HelloImpl
che genera i file:– HelloImpl_Stub.class– HelloImpl_Skel.class
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
50
RMI: Il processo di creazioneRMI: Il processo di creazione5/6/7 5/6/7 -- Lanciare Lanciare rmiregistryrmiregistry e server e server
Definire la interface remota
Implementare la interface
javac
rmic
Serverclass
ServerskeletonClient
StubImplementare
il client
javac
Lanciareil client
Lanciare rmiregistry
Lanciare oggetti server
Registrare oggetti server
1
2
3
5
4
6
7
8
9
10
ServerClient
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
51
RMI: Il processo di creazioneRMI: Il processo di creazione8 8 -- Implementazione del Implementazione del ClientClient
Definire la interface remota
Implementare la interface
javac
rmic
Serverclass
ServerskeletonClient
StubImplementare
il client
javac
Lanciareil client
Lanciare rmiregistry
Lanciare oggetti server
Registrare oggetti server
1
2
3
5
4
6
7
8
ServerClient
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
52
Il Il ClientClient: il file : il file HelloClient.javaHelloClient.java
import java.rmi.*;public class HelloClient {public static void main(String args[]) {String host = “localhost”;String nome = “Pippo”;if (args.length > 0 ) host = args[0];if (args.length > 1 ) nome = args[1];try {Hello obj = (Hello)
Naming.lookup(”rmi://”+host+”/HelloServer");
System.out.println("Ricevuto:"+ obj.dimmiQualcosa(nome));
} catch (Exception e) {e.printStackTrace();
}}// fine main}// fine classe HelloClient
• Prende (se c’è) il primo parametro come host e il secondo come nome
• Ottiene un riferimento remoto all'oggetto remoto dal registro
• Hostname
• Invocare il metodo remoto
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
53
Le classi generate nell’esempioLe classi generate nell’esempio
Hello
HelloImpl
ClientObjects
ClientObjectsHelloClient
HelloImplHelloImplHelloImpl
HelloImpl_Stub.class HelloImpl_Skel.class
Stub Object Skeleton Object
Generate da rmic
Scrittodal
programmatoreHelloClient
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
54
RMI: Il processo di creazioneRMI: Il processo di creazione99-- Compilazione del Compilazione del ClientClient
Definire la interface remota
Implementare la interface
javac
rmic
Serverclass
ServerskeletonClient
StubImplementare
il client
javac
Lanciareil client
Lanciare rmiregistry
Lanciare oggetti server
Registrare oggetti server
1
2
3
5
4
6
7
8
9
10
ServerClient
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
55
La compilazione del La compilazione del clientclient HelloClientHelloClient
• Avendo a disposizione lo stub
– HelloImpl_Stub.class
• Compilazione del client:
– javac HelloClient.javaP
rogr
amm
azio
ne D
istr
ibui
ta (
2003
-200
4).
Vi.t
tori
oSc
aran
o
56
RMI: Il processo di creazioneRMI: Il processo di creazione10 10 -- Lanciare il Lanciare il clientclient
Definire la interface remota
Implementare la interface
javac
rmic
Serverclass
ServerskeletonClient
StubImplementare
il client
javac
Lanciareil client
Lanciare rmiregistry
Lanciare oggetti server
Registrare oggetti server
1
2
3
5
4
6
7
8
9
10
ServerClient
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
57
Un ultimo passo: la Un ultimo passo: la securitysecurity policypolicy
• Necessario settare la security policy della JVM– scrivendo un file che caratterizza i permessi dati a ciascuna
operazione
• Possibile scegliere politiche – per tutte le macchine virtuali– per singolo utente– per applicazione
• Esempio: scrivere la policy più “liberale” (!) in un file (chiamiamolo �������) nella directory corrente
grant {permission java.security.AllPermission;
};
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
58
Esecuzione di Esecuzione di HelloHello
• Sulla macchina del server (serverhost):– lanciare il registry sulla porta di default 1099
• rmiregistry & (Unix)
• start rmiregistry (Windows)
– lanciare il programma server con la policy:• java -Djava.security.policy=policyall HelloImpl
• Sulla macchina del client:– lanciare il programma client:
• java HelloClient serverhost Topolino
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
59
Organizzazione della lezioneOrganizzazione della lezione
• Remote Method Invocation
• Le classi ed interfacce di RMI
• La architettura a strati di RMI
• Una suddivisione funzionale di RMI
• Il processo di creazione
• Un esempio di uso: ����������
• La sicurezza in Java
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
60
La sicurezza in JavaLa sicurezza in Java
• Il problema nasce dalla caratteristica di Java di essere “distribuito”– potendo eseguire classi scaricate dalla rete, non si può essere
sicuri della loro inoffensività
• La soluzione di Java– i programmi vengono eseguiti in una “sandbox”
• Il SecurityManager viene usato per controllare i permessi forniti dall’utente al programma
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
61
La evoluzione delle politiche di La evoluzione delle politiche di securitysecurity: : JDK 1.0JDK 1.0• In JDK 1.0 la unica differenza era tra codice locale e
remoto
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
62
La evoluzione delle politiche di La evoluzione delle politiche di securitysecurity: : JDK 1.1JDK 1.1• In JDK 1.1 vengono introdotti gli applet firmati
remoto
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
63
La evoluzione delle politiche di La evoluzione delle politiche di securitysecurity: : JDK 1.2 e successiveJDK 1.2 e successive• In JDK 1.2 viene introdotta la policy per dominio
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
64
Le politiche di sicurezzaLe politiche di sicurezza
• Vengono enumerate da Sun i modi in cui è possibile “uscire” dalla sandbox
• I permessi vengono memorizzati in file di policy– definiscono le restrizioni imposte dalla sandbox
• A livello sistema (nella home di Java RuntimeEnvironment)– .../jre/lib/security/java.policy
• A livello utente– .../userhome/.java.policy
• A livello programma– java -Djava.security.policy=policyfile appName
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
65
Il Il SecuritySecurity ManagerManager
• Implementa una politica di sicurezza permettendo la esecuzione in una “sandbox”
• Esempio: la delete di un file può essere illegale
• Il Security Manager viene interpellato dall’interprete per ogni azione potenzialmente pericolosa.
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
66
Istallare un Istallare un SecurityManagerSecurityManager
• Necessario istallare un Security Manager– dal codice
– dalla linea di comando• java -Djava.security.manager
• rmiregistry (e rmid per la activation) istallano dei RMISecurityManager con policy di default
• Formato dei permessi nei file di policy:
grant [signedBy Name] [codeBase URL] {// lista dei permessi
} ;
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
67
La La politicapolitica di defaultdi default
• All’interno di jre/lib/security il file java.policygrant codeBase "file:${java.home}/lib/ext/*" {
permission java.security.AllPermission;};
grant { // Thread possono fermare se stessi con java.lang.Thread.stop()permission java.lang.RuntimePermission "stopThread";// listen su porte non di rootpermission java.net.SocketPermission "localhost:1024-", "listen";
// proprieta’ di sistema leggibilipermission java.util.PropertyPermission "java.version", "read";permission java.util.PropertyPermission "java.vendor", "read";permission java.util.PropertyPermission "java.vendor.url", "read";permission java.util.PropertyPermission "java.class.version", "read";permission java.util.PropertyPermission "os.name", "read";permission java.util.PropertyPermission "os.version", "read";permission java.util.PropertyPermission "os.arch", "read";permission java.util.PropertyPermission "file.separator", "read";permission java.util.PropertyPermission "path.separator", "read";permission java.util.PropertyPermission "line.separator", "read";// continua
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
68
La La politicapolitica di defaultdi default
• All’interno di jre/lib/security il file java.policy
// continuapermission java.util.PropertyPermission "java.specification.version", "read";permission java.util.PropertyPermission "java.specification.vendor", "read";permission java.util.PropertyPermission "java.specification.name", "read";permission java.util.PropertyPermission "java.vm.specification.version", "read";permission java.util.PropertyPermission "java.vm.specification.vendor", "read";permission java.util.PropertyPermission "java.vm.specification.name", "read";permission java.util.PropertyPermission "java.vm.version", "read";permission java.util.PropertyPermission "java.vm.vendor", "read";permission java.util.PropertyPermission "java.vm.name", "read";
};
Pro
gram
maz
ione
Dis
trib
uita
(20
03-2
004)
. V
i.tto
rio
Scar
ano
69
Un Un tooltool: : policytoolpolicytool
• Permette di gestire con facilità i file di permessi