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.


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


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.


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.


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.


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.


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.


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.


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.


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.


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

{

};


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.


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);}

}


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);


// 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) {};

}

}


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);


// 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.


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


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.


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.


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.


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;

};

};


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.


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


CORBA: concetti chiave e terminologiaprofs.sci.univr.it/~merro/files/corba.pdf · 6 Server: Nella...

Documents

Transcript of CORBA: concetti chiave e terminologiaprofs.sci.univr.it/~merro/files/corba.pdf · 6 Server: Nella...