CORBA: concetti chiave e terminologiaprofs.sci.univr.it/~merro/files/corba.pdf · 6 Server: Nella...
Transcript of CORBA: concetti chiave e terminologiaprofs.sci.univr.it/~merro/files/corba.pdf · 6 Server: Nella...
CORBA: concetti chiave e terminologia
1 Object Manager Group (OMG): e una organizazzione no-profit chepromuove l’uso di tecnologie orientate a oggetti. OMG ha definito glistandard CORBA e UML. Dell’OMG fanno parte circa 600 membrisparsi per il mondo (Universita, aziende, utenti).
2 ORB (Object Request Broker): supporta l’interazione tra client eserver in esecuzione su macchine diverse. Lato client gli stubinvocano l’ORB che si preoccupa di inoltrare le richieste al server.Lato server l’ORB usa gli skeleton per decodificare le richiesteproveniente lato client ed invocare il metodo appropriato dell’oggettoremoto (servant). Quando il metodo ritorna, lo skeleton spedisce irisultati al client attraverso l’ORB.
3 IIOP (Internet Inter-ORB Protocol) protocollo che consente aORB differenti su host differenti di comunicare.
Massimo Merro Programmazione di Rete 222 / 247
4 CORBA (Common ORB Architecture) e uno standard per laprogrammazione di ORB (Object Request Broker), una versioneobject-oriented di RPC in cui client e server remoti interagiscono,indipendentemente dalla piattaforma (SO e HW) e dal linguaggio diprogrammazione usato.
CORBA viene spesso riferito come un middleware o integration
software poiche consente di intgrare applicazioni esistenti con nuove.Altri middleware sono Java RMI, IBM MQ Series, Microsoft’s DCOM e.NET, SOAP, and TIBCO Rendezvous, etc.CORBA nasconde la complessita del sistema distribuito.Oggetti remoti sono accessibili da programma come se fossero locali(Location Transparency).
5 Interface Definition Language (IDL)IDL e un linguaggio per definire l’interfaccia fornita da un oggettoremoto in un processo server.Un’interfaccia IDL definisce il tipo di un oggetto CORBA e descrivecome client e server interagiscono.Un’interfaccia IDL e concettualmente molto simile ad un’interfacciaremota Java RMI.
Massimo Merro Programmazione di Rete 223 / 247
6 Server: Nella terminologia CORBA un server e un processo checontiene l’implementazione di una o piu interfacce IDL. Il server deveregistrare tutte le implementazioni (oggetti servant) con l’ORB.Questo perche l’ORB sappia dove spedire le invocazioni ricevute dagliskeletons.
7 Interoperable Object Reference (IOR): l’interoperabilita implicache una referenza ad un server CORBA rimane valida al variare delleimplementazioni del server (ovvero dei servanti).
8 Servizi Corba. CORBA e dotato di un insieme di librerie, funzioni,traduttori, etc:
Servizio di naming
Concurrency Control Service: fornisce primitive di lock, unlock, etcEvent Service: Supporta comunicazioni molti a molti.Transaction Service: (commit, abort, etc)Licensing Service
Security Service
Trader Service
Etc
Massimo Merro Programmazione di Rete 224 / 247
Vantaggi di CORBA
1 Standard aperto
CORBA e uno standard aperto poiche non e proprietario.Gli utenti possono scegliere una implementazione tra vari possibili“vendors” (o scegliere una implementazione freeware).La maggior parte dei middleware proprietari, per loro natura, fornisconoun supporto limitato per l’integrazione con altre tecnologie.CORBA, al contrario, affronta esplicitamente l’integrazione con TMN,SOAP, Microsoft DCOM, etc.Inoltre, molti concetti in J2EE sono stati ispirati da CORBA, rendendola loro integrazione piu facile.
2 Supporta numerose piattaforme: IBM OS/390 and FujitsuGlobalServer mainframes, numerosi varianti di UNIX (Linux incluso),Windows, AS/400, Open VMS, Apple’s OS X e parecchi sistemioperativi embedded.
Massimo Merro Programmazione di Rete 225 / 247
3 Supporta numerosi linguaggi di programmazioneIDL e utilizzata per definire l’API pubblica utilizzata da server CORBA.I server sono comunque scritti in altri linguaggi.Percio affinche l’interfaccia IDL possa essere utilizzata lo standardCORBA definisce i mapping di IDL nei seguenti linguaggi diprogrammazione: C, C++, Java, Ada, COBOL, PL/I, LISP, Pythin, eIDLScript.I compilatori sopra indicati sono ufficiali, cioe approvati dall’OMG.Esistono comunque altri compilatori per Eiffel, Tcl e Perl.
4 EfficienzaL’infrastruttura del protocollo on-the-wire di CORBA garantisce che imessaggi client/serve vengano trasmessi marshallizzando i dati inmaniera molto efficiente.Altri middleware utilizzano formati di trasmissione compatti simili aquelli usati da CORBA. Vi sono, comunque, alcune eccezioni di rilievo.SOAP utilizza XML per rappresentare i dati da trasmettere. Laprolissita di XML diminuisce l’efficienza nella trasmissione. Inoltre vi eun notevole carico di CPU nella formattazione dei tipi usati neilinguaggi di programmazione in XML, e viceversa per fare il parsing deitipi all’interno di file XML.
Massimo Merro Programmazione di Rete 226 / 247
5 Interoperabilita
L’Obiettivo di CORBA e di integrare in una singola applicazionedistribuita piu applicazioni scritte in linguaggi differenti, ed inesecuzione su macchine differenti.Per fare cio CORBA ha bisogno di un meccanismo per stabilire comecomunicano i programmi coinvolti, come vengono passati i valori traprogrammi, e che protocolli utilizzano.CORBA provvede alla creazione di interfacce scritte in un linguaggioben preciso (OMG IDL), facile da comprendere, e che possono esserefacilmente tradotte nei vari linguaggi di programmazione disponibili.L’interoperabilita di CORBA e piuttosta rara. J2EE, per esempio,supporta solo Java. In SOAP, sebbene potenzialmente si potrebberousare una varieta di linguaggi, in pratica l’unica mappatura definita equella per Java.
6 Scalabilita: consente di sviluppare server che possono facilmentescalare dalla gestione di pochi oggetti ad un numero elevato dioggetti.
Massimo Merro Programmazione di Rete 227 / 247
Sviluppo di una applicazione
Per progettare un’applicazione CORBA ci si affida al paradigmaClient-Server.
Per implementare l’applicazione occore scrivere il codice seguente:
Interfaccia IDLCodice Servant (l’implementazione del server)Codice ServerCodice Client
Deployment: fare in modo che queste componenti possano interagiretra loro.
Massimo Merro Programmazione di Rete 228 / 247
Scrivere un’applicazione CORBA in Java
Java fornisce un ORB CORBA e due modelli di programmazione
CORBA che utilizzano l’ORB CORBA e il protocollo IIOP (InternetInter-ORB Protocol):
RMI-IIOP . Per programmatori Java che usano interfacce Java RMI, eche vogliono usare il protocollo IIOP per aumentare l’interoperabilita;tali programmatori dovranno curarsi di fornire le interfacce IDL deiserver programmati in Java RMI.
Java IDL. Per programmatori CORBA, che vogliono programmare inJava basandosi sulle interfacce IDL precedentemente definite.
Massimo Merro Programmazione di Rete 229 / 247
Scrivere un’applicazione CORBA in Java IDL
Implementare interfacce IDL dei servant (Hello.idl)
Generare stub, skeleton ed altre classi di servizio a partire dalleinterfacce IDL, tramite un compilatore. Ad esempio, in Java:
> idlj -fall Hello.idl
Implementare classi servant (HelloImpl.java)
Implementare classe server (HelloServer.java)
Compilare, ad esempio in Java:
> javac Helloimpl.java HelloServer.java
Implementare il client (HelloClient.java)
Compilare il client.
Massimo Merro Programmazione di Rete 230 / 247
Esempio di applicazione: Hello Server
Progettazione: un oggetto Hello (servant) in grado di fornire la datacorrente oppure fare lo shut-down dell’ORB.
I client non conoscono com’e implementato l’oggetto Hello, maconoscono la sua interfaccia IDL Hello.idl:
//IDL interface Hello.idl
module HelloApp {
interface Hello {
string helloDate();
oneway void shutdown();
};
};
I moduli in OMG IDL corrispondono ai package in Java.
“oneway” indica che quando si invoca shutdown() non si attendealcuna risposta. Non si garantisce il buon fine dell’operazione.
Massimo Merro Programmazione di Rete 231 / 247
Output del compilatore idlj
Il compilatore idlj genera a partire dall’interfaccia IDL codici Java. Conl’opzione -fall l’output e il seguente:
HelloOperations.java. Questa interfaccia contiene i metodi diHello.idl.
Hello.java e la versione Java di Hello.idl. Estende l’interfacciaHelloOperations.java ed alcune interfacce che fornisconofunzionalita CORBA.
HelloPOA.java. Classe skeleton. Estendeorg.omg.PortableServer.Servant. ImplementaHelloOperations.java. Il Servant estendera la classe HelloPOA.
HelloStub.java. Classe stub. Implementa Hello.java.
HelloHelper.java. Fornisce una serie di funzionalita come adesempio il metodo narrow per castare referenze CORBA neicorrispondenti tipi Java.
HelloHolder.java. Altre funzionalita.
Massimo Merro Programmazione di Rete 232 / 247
Vediamo alcuni codici generati da idlj
//HelloOperations.java
//Generato da idlj a partire da Hello.idl
package HelloApp;
public interface HelloOperations {
String helloDate();
void shutdown();
};
---------------------------------------------------------
//Hello.java
//Generato da idlj a partire da Hello.idl
package HelloApp;
public interface Hello extends HelloOperations,
org.omg.CORBA.Object, org.omg.CORBA.portable.IDLEntity
{
};
Massimo Merro Programmazione di Rete 233 / 247
Programmazione lato Server
Un server CORBA (object server) non un’entita fisica precisa, maun’astrazione di uno o piu oggetti remoti concreti, chiamati Servant,che implementano un servizio remoto in un qualche linguaggio diprogrammazione “ospite”: Java, C, etc.
CORBA supporta almeno due modalita diverse per implementareinterfacce IDL. Qui vediamo il “POA Inheritance model”.
Un POA, Portable Object Adapter, e quella parte del runtime diCORBA che si occupa di rendere una referenza trasparenteall’implementazione effettiva del server.
Infatti le richieste inoltrate dai client attraverso gli stub vengonoindirizzati al POA che la smista all’oggetto che implementa il serviziorichiesto.
In particolare il POA si preoccupa di demarshallizzare le richieste emarshallizzare le risposte.
Massimo Merro Programmazione di Rete 234 / 247
Servant: HelloImpl.java
Il servant deve estendere la classa astratta HelloPOA.java.
Il nostro servant implementa i metodi di HelloPOA.java. In questoesempio, abbiamo anche un metodo per passare al servant unareferenza all’ORB.
package server;
import HelloApp.*
public class HelloImpl extends HelloPOA {
private ORB orb;
public void setORB(ORB orb_val) {
orb = orb_val; }
public String helloDate() {return (new Date()).toString();}
public void shutdown() {orb.shutdown(false);}
}
Massimo Merro Programmazione di Rete 235 / 247
Server: HelloServer.java
package server;
import HelloApp.*;
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
import org.omg.CORBA.*;
import org.omg.PortableServer.*;
import org.omg.PortableServer.POA;
import java.util.Properties;
public class HelloServer {
public static void main(String args[]) {
try {//Crea ed inizializza il local ORB
ORB orb = ORB.init(args, null);
// Ottieni una referenza al POA e attiva il POAManager
POA rootpoa = POAHelper.narrow(orb.resolve_initial_reference("RootPOA"));
rootpoa.the_POAManager().activate();
// Creiamo il servant e gli passiamo una referenza all’ORB
HelloImpl helloImpl = new HelloImpl();
helloImpl.setORB(orb);
Massimo Merro Programmazione di Rete 236 / 247
// Attraverso il POA ottieni una CORBA object reference del servant
org.omg.CORBA.Object ref = rootpoa.servant_to_reference(helloImpl);
//Il metodo narrow() casta referenze CORBA sull’interfaccia Java
Hello href = HelloHelper.narrow(ref);
//Usando l’ORB ottieni una CORBA object reference del servizio di naming
org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
//castiamo la referenza per accedere al servizio di COS naming
NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);
//Registriamo il servant nel servizio di naming con nome "Hello"
NameComponent path[] = ncRef.to_name("Hello");
ncRef.rebind(path,href);
System.out.println("CORBA Server Hello in esecuzione!");
//sospendi il thread corr. e passa al servant in attesa di invocazioni
//una volta gestita una invocazione il server si rimette in attesa
//ecco perche’ abbiamo lo shudown dell’ORB quando il client completa
orb.run();
catch (Exception e) {};
}
}
Massimo Merro Programmazione di Rete 237 / 247
Client: HelloClient.java
package client;
import HelloApp.*;
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
import org.omg.CORBA.*;
public class HelloClient {
static Hello helloImpl;
public static void main(String args[]) {
try{
// crea ed inizializza l’ORB
ORB orb = ORB.init(args, null);
//Usando l’ORB ottieni una CORBA object reference del servizio di Naming
org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
// Usa NamingContextExt invece di NamingContext. Questo e’
// parte dell’ Interoperable Naming Service.
// casta la referenza prima di usarla
NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);
Massimo Merro Programmazione di Rete 238 / 247
// ottieni la referenza al servant attraverso il COS Naming e castala
helloImpl = HelloHelper.narrow(ncRef.resolve_str("Hello"));
System.out.println("Ottenuta una referenza al server object: " + helloImpl);
System.out.println(helloImpl.helloDate());
helloImpl.shutdown();
}
catch (Exception e) {
System.out.println("ERROR : " + e) ;
e.printStackTrace(System.out);
}
System.out.println("HelloServer sta uscendo...");
}
}
Il nostro Client una volta terminato, invoca il metodo shutdown() pertirare giu l’ORB. Altrimenti resterebbe attivo.
Massimo Merro Programmazione di Rete 239 / 247
Deployment
Lato Server: Bisognera lanciare l’ORB. Indicando la porta su cui siintende lanciare il servizio di naming messo a disposizione dall’ORB.Dopo aver lanciato l’ORB bisogna lanciare il server vero e proprio:
> orbd -ORBInitialPort 1050 &
> java server.Helloserver -ORBInitialPort 1050 &
Lato Client: Bisognera lanciare il client:
> java client.HelloClient -ORBInitialPort 1050
-ORBInitialHost nameserver_host
Massimo Merro Programmazione di Rete 240 / 247
Server CORBA
Un server CORBA e caratterizzato da:
Riferimento, ovvero una CORBA object referenceInterfaccia IDLImplementazione (servant)
Una CORBA object reference (IOR)
E un handle che identifica un oggettoPermette all’ORB di localizzare l’oggettoFa riferimento ad un singolo oggettoUn oggetto puo avere piu riferimentiE analogo ad un riferimento in Java.
Massimo Merro Programmazione di Rete 241 / 247
Servant
Rappresenta l’implementazione del server ed esegue le operazioniinvocate dal client
L’implementazione e basata su
Ereditarieta (il servant eredita dalla classe POA)Delega (un server CORBA delega le operazioni ai metodi del servant)
Puo essere usato dai piu server CORBA
Fornisce un target per un oggetto CORBA
Vive solo dentro un processo server.
Massimo Merro Programmazione di Rete 242 / 247
Ancora sulle Interfacce IDL
Costituisce il contratto offerto da un oggetto al client
I client devono usare l’interfaccia IDL per specificare l’operazione dacompiere su un oggetto.Definisce
Un tipo IDL per un server CORBACio che e implementato da un oggetto remoto.
Puo contenere
Dichiarazioni di eccezioniDefinizioni di costanteAttributi (campi): possono essere usati solo per operazioni get/setOperazioni (metodi).
I parametri di un’operazione possono specificare la direzione: IN (dalclient al server); OUT (dal server al client); INOUT (entrambe).Le operazioni possono avere anche un valore di ritorno.Supporta ereditarieta multipla.
Massimo Merro Programmazione di Rete 243 / 247
Un esempio di interfaccia IDL
module Finance {
typedef sequence<string> StringSeq;
struct AccountDetails {
string name;
StringSeq address;
long account_number;
double current_balance;
};
exception insufficientFunds { };
interface Account {
void deposit(in double amount);
void withdraw(in double amount) raises(insufficientFunds);
readonly attribute AccountDetails details;
};
};
Massimo Merro Programmazione di Rete 244 / 247
Vantaggi e Limiti di IDL
IDL supporta
ModuliInterfacceOperazioniAttributiEreditarieta multiplaArray, struct, enum, unionCostantiEccezioni
IDL non supporta
PuntatoriCostruttori o distruttoriOverloading e overriding delle operazioniEreditarieta delle eccezioniCostrutti di controllo.
Massimo Merro Programmazione di Rete 245 / 247
CORBA vs RMI
CORBA e Java RMI rappresentano due framework per lo sviluppo disistemi distribuiti ad oggetti. Facciamone un breve confronto.
CORBA e progettato per garantire la massima interoperabilita perutilizzare applicazioni scritte usando linguaggi e piattaforme differenti.Esistono moltissime applicazioni sviluppate usando CORBA.Le performance delle applicazioni CORBA sono in generale moltobuone.
Se invece consideriamo Java RMI:
In Java RMI, client e server devono necessariamente essere sviluppatiin Java.Java RMI e un linguaggio piu semplice ed e quindi piu facile da usareper sviluppare grossi sistemi.Il codice per descrivere un sistema in Java RMI puo essere moltoinferiore a quello per descrivere il medesimo sistema in CORBA.Le prestazioni di Java RMI sono in generale inferiori a quelle diCORBA.Infine, Java RMI, al contrario di CORBA, supporta un meccanismo diMassimo Merro Programmazione di Rete 246 / 247
Conclusioni
CORBA
Riduce la complessita e le difficolta dello sviluppo di sistemi distribuitiPermette l’interoperabilita tra oggetti implementati su piattaforme elinguaggi diversi
CORBA non affronta
Bilanciamento del caricoMobilita di codice.
Per ulteriori dettagli guardare:http://java.sun.com/j2se/1.5.0/docs/guide/idl/index.html
oppure
http://www.ciaranmchale.com/corba-explained-simply/index.html
Massimo Merro Programmazione di Rete 247 / 247