Corba Overzicht

Corba referenties Belangrijkste: CORBA: Integrating Diverse Applications Within Distributed Heterogeneous Environments (Steve Vinoski) ( papers.html) A Detailed Comparison of CORBA, DCOM and Java/RMI (Gopalan Suresh Raj) (http//wwww.execpc.com/~gopalan/misc/compare.ht ml)

Corba Sites De referentie is vooral: Een autoriteit is: Voor de linux gemeenschap: Een goede tutorial is En "off the road"

Corba Bedoeling Op een hoog niveau van abstractie de nodige voorzieningen treffen voor gedistribueerde programmering De Object Request Broker verzorgt transparantie van plaats, activatie en communicatie

OMG: Object Managing Group Opgericht in 1989, momenteel > 800 leden. Object Management Architecture (OMA) omvat als kern CORBA Object Model –encapsulatie, vaste identiteit, interfaces Reference Model interface categorieën

Corba Vijf Onderdelen Orb kern Interface Definition Language Dynamic Invocation Interface Interface Repository Object Adapters

Corba Versus RPC RPC laat toe om ingewikkelde datastructuren over het netwerk te verdelen RPC ondersteunt de distributie van C++ objecten niet expliciet Programmeurs moeten dit dus zelf implementeren

Corba Versus RPC Dit is moeilijk vanwege de verborgen pointers naar virtuele functietabellen De toepassing hoeft ook de klassen niet echt te kennen We hebben een methode nodig om de objecten over het net te distribueren Inpakken en uitpakken leidt tot problemen met encapsulatie en gebruik van bibliotheken

Corba Versus RMI RMI lost verschillende problemen van RPC op –Het object blijft aan de serverkant functioneren –Slechts een stub reist over het netwerk –De klasse blijft voor de client een abstracte entiteit waarover slechts een minimum bekend hoeft te zijn RMI is enkel Java Het hergebruiken van bestaande code is problematisch (enkel mogelijk via de native code interface van Java)

Corba Versus CGI e.a. De Common Gateway Interface laat toe om code aan de serverkant (website) uit te voeren in opdracht van een client (browser) –De programmeertaal is niet vastgelegd –De parameters worden gespecificeerd via de URL –Cfr asp –Dit is niet object georienteerd en loopt over HTTP –HTTP is toestandsloos, er is dus geen sprake van een verbinding (kan omzeild worden)

Corba Voordelen Ondersteuning van legacy code in C, C++, COBOL, SMALLTALK, … Java ondersteuning Onafhankelijkheid van een specifieke software- boer Schaalbaarheid naar het aantal gebruikers toe Ondersteuning van een groot aantal platformen Een Object Georienteerd ontwikkelingsparadigma Veiligheid

CORBA en DCOM DCOM is de Microsoft oplossing voor dit probleem Distributed Component Object Model –COM (Component Object Model) geeft toegang tot alle onderdelen van de MS applicaties –DCOM laat toe deze applicaties over het netwerk te raadplegen –Probleem: 1 vendor. DCOM-CORBA bridges zijn nodig voor andere gebruikers (vb LINUX)

Een voorbeeld TimeServer 1 struct, 1 interface time.idl $idl time.idl time.hh: –#include bij client timeC.cc –stub voor client timeS.hh, timeS.cc –#include en skeleton voor server struct TimeOfDay { short hour; short minute; short second; }; Interface Time { TimeOfDay get_gmt(); };

#include #include “timeS.hh” class Time_impl : public virtual POA_Time { }; public : virtual TimeOfDay get_gmt() throw(CORBA::SystemException); TimeOfDay Time_impl::getgmt() throw(CORBA::SystemException) { return tod; } time_t time_now = time(0); struct tm * time_p = gmtime(&time_now); TimeOfDay tod; tod.hour = time_p->tm_hour;tod.minute = time_p->tm_min; tod.second = time_p->tm_sec; Server code

int main(int argc, char * argv[]) { return 0;} try{ } catch (const CORBA::Exception &) { cerr << “?” << endl; return 1} CORBA::ORB_var orb = CORBA::ORB_init(argc, argv); CORBA::Object_var obj = orb->resolve_initial_references(“RootPOA”); PortableServer::POA_var poa = PortableServer::POA::_narrow(obj); PortableServer::POAManager_var mgr = poa->the_POAManager(); mgr->activate(); Time_impl time_servant; Time_var tm = time_servant._this(); CORBA::String_var str = orb->object_to_string(tm); cout << str << endl; orb->run(); Server code

Server compilatie e.d. $CC -c -I/opt/myORB/include timeC.cc $CC -c -I/opt/myORB/include timeS.cc $CC -c -I/opt/myORB/include myserver.cc $CC -o myserver timeC.o timeS.o myserver.o \ >-L/opt/myORB/lib -lorb IOR: d eafec902….

Client #include #inlcude “time.hh” int main(int argc, char * argv[]){ return 0;} try { } catch (const CORBA::Exception &) {cerr “CORBA” << endl;return 1;} catch (…) {return 1;} if (argc !=2) {cerr << “2!” << endl;throw 0;} CORBA::ORB_var orb = CORBA::ORB_init(argc,argv); CORBA::Object_var obj = obj->string_to_object(argv[1]); if (CORBA::is_nil(obj) {cerr << “NIL!” << endl; throw 0;} Time_var tm = Time::_narrow(obj); if (CORBA::is_nil(tm) {cerr “not a Time reference!”<< endl; throw 0;} TimeOfDay tod = tm->get_gmt(); cout << “Time is “ << tod.hour << ‘:’ << tot.minute << endl;

Client compilatie e.d. $CC -c -I/opt/myORB/include timeC.cc $CC -c -I/opt/myORB/include myclient.cc $CC -o myserver timeC.o myclient.o \ >-L/opt/myORB/lib -lorb $./myserver >/tmp/myserver.ref & [1] 1729 $./myclient `cat /tmp/myserver.ref` Time is 1:35 $kill %1 [1] + Terminated./myserver & $

OMG IDL Interface Definition Language OMG IDL is de fundamentele abstractie die interfaces van hun implementaties scheidt. Er bestaan standaard afbeeldingen voor C, C++, Smalltalk, COBOL, Ada, Java Er zijn onafhankelijke afbeeldingen voor Modula 3, Perl, Tcl, Python, Dylan, Oberon, Visual Basic, Objective-C. OMG IDL is zuiver declaratief: interfaces, exceptions, datatypes. OMG IDL->IDL

COMPILATIE IDL->source files die met de applicatiecode moeten gecombineerd worden (afhankelijk van de ORB). Client executable en Server executable kunnen overal lopen, kunnen in verschillende talen geschreven zijn. De host machines verschaffen de runtime omgeving. Twee gevallen: één ontwikkelingsomgeving en gescheiden ontwikkelingsomgevingen voor client en server.

Inhoud OMG IDL Lexicografie Basis types Gebruikerstypes –Unions Arrays Sequenties Recursieve types Interfaces User Exceptions Overerving Voorbeeld

Source Files Bestandsnamen:.idl Bestandsformaat: free-form Preprocessing: C++ preprocessor –#include –#define –#ifdef –#ifndef –#endif /* einde conditionele module */ Definitievolgorde: definitie vóór gebruik

Basis Types De grootte van de types worden bewaard door de afbeeldingen. De bereiken zijn niet noodzakelijk behouden. –Vb Java kent geen unsigned integers –Vb geen 8 bit characters Er kunnen representatie omzettingen nodig zijn of vertalingen nodig zijn –little endian, big endian –EBCDIC, ASCII Er zijn geen pointers, enkel referenties

Lexicografie Commentaar /* */ en // als in C++ Sleutelwoorden in kleine letters, behalve Object, TRUE en FALSE Namen: letter (a-z,A-Z) gevolgd door letters, cijfers en onderlijning. Geen _ vooraan, geen onengelse letters. Hoofdletter ongevoelig maar consistentie is verplicht. –short aap; Aap = 0; // fout, inconsistent –long giraffe; double Giraffe; // fout, ongevoelig –long while; // ok maar niet verstandig

Gebruiker gefinieerde Types Andere namen: typedef semantiek afhankelijk van de programmeertaal –typedef short JaarType; Opsommingen : enum –enum dag {maa,din,woe,don,vri,zat} –gegarandeerd 32 bits –geen gegarandeerde overeenkomst met int

Gebruikers Types Structuren –C++ notatie –struct Tijd {short uur;short minuut;}; –een struct vormt een eigen naamruimte Unions: altijd discriminerend: union TelDagen switch(dag) { case maa : case din : unsigned long num_serious; case woe : float discount; default : string no_sense; }

Union idiomatic union AgeOpt switch (boolean) { case TRUE : unsigned short age; }; Struct InfoKind {text, numeric, none}; union Info switch (InfoKind) { case text : string text; case numeric : long index; }; Union not advised (overloading)

Arrays typedef Color ColorVector[10]; typedef long IDTable[10][20]; Always use typedef Geen niet gedimensioneerde tabellen Indexbereik is niet gespecifieerd!

Sequences typedef sequence Colors; typedef sequence Numbers; –(hoogstens 100 getallen) typedef sequence ; –(lijst lijsten van hoogstens 100 getallen) typedef sequence >; –lijst lijsten van long, gebruikt anonieme variabele=>niet onproblematisch, te vermijden.

Sequences/Arrays Matrix als een array: Performantie! typedef long M[100][100]; interface MProc { M invert(in M m); }; Matrix als een sequentie: sparse struct NZ { unsigned short r; unsigned short c; long val;}; typedef sequence M; interface MProc { M invert(in M m); };

Recursieve types Structures: struct Node { long value; sequence children;}; Unions: enum OpType {O_AND, O_OR, O_NOT}; enum NodeSoort {BLAD,UNAIR,BINAIR}; union Node switch(NodeSoort) { case BLAD: long val;

Recursieve types case UNAIR: struct UnaireOp { OpType op; sequence kind; } u_op; case BINAIR: struct BinaireOp { OpType op; sequence kinderen; } bin_op; };

Recursieve Types In kwade en in goede tijden: –de sequence constructie maakt het systeem type veiliger, maar voorkomt niet dat een unaire knoop 0 kinderen heeft –een unaire knoop kan een binaire operator hebben –O_AND is veiliger dan AND omdat dit in veel programmeertalen een sleutelwoord is Multilevel recursie is ok, wel problemen met mutueel recursieve structuren.

Interfaces Interface ThermoStat { short get_temp(); short set_temp(in short new_temp); }; Geen publiek deel, geen lidvelden Perfecte scheiding van implementatie en interface de kleinste korrel in CORBA

Interface Semantiek Interface namen zijn typenamen Interfaces kunnen doorgegeven worden Object referenties zijn instance pointers in C++ Object referenties kunnen buiten de adresruimte wijzen Nil referenties zijn mogelijk, kunnen als een “geen resultaat” of “geen parameter” indicatie gebruikt worden IDL verzekert type overeenkomst

Operaties Verplicht return type, eventueel void return en parameters: nooit anonyme types Geen overloading Alle parameters hebben een richting –in, out, inout De richting verhoogt de efficiëntie De richting bepaalt de veantwoordelijkheid voor geheugenmanagement Constante operaties bestaan niet (CORBA Security Service is een alternatief)

Operaties, voorbeelden interface vbdn { op();// Fout void op();// OK typedef unsigned long prime; prime next_prime(in long n); prime next_prime(in long n,out prime p); //Fout void next_prime2(in long n, out prime p); //~OK sequence get_longs(); //Fout SomeType read_value() const; //Fout };

User Exceptions Syntax ~ structures, niet genest Vormen een namespace Kunnen niet als dataleden gebruikt worden Gebruik “raises” om aan te geven dat een fout gegenereerd kan worden (verplicht) interface Unrel { void can_fail() raises(Failed); void can_also_fail(in long l) raises(Failed,RangeError); } Geen overerving voor exceptions

Exceptions, Voorbeelden exception Failed {}; exception RangeError { unsigned long supplied; unsigned long min_val; unsigned long max_val; }; struct ErrorRep { Object obj; RangeError exc; // Fout }

System Exceptions: een lijst enum completion_status { COMPLETED_YES, COMPLETED_NO, COMPLETED_MAYBE }; #define SYSEX(NAME) exception NAME {\ unsigned long minor; \ completion_status completed; \ }

Attributes interface Thermostat { readonly attribute short temperature; attribute short nominal_temp; }; Semantisch equivalent met interface Thermostat { short get_temperature(); short get_nominal_temp(); void set_nominal_temp(); };

Attributes Attributen zijn dus geen variabelen, geen geheugentoekenning Problemen met attributen: –geen raises-clausule toegelaten –terugvallen op system exceptions is twijfelachtig, het minor attribuut is niet noodzakelijk bewaard door de ORB Beperk het gebruik in elk geval tot read_only, of gebruik ze niet

Interface versus Implementatie Overerving in IDL betreft enkel de interface! Implementatie kan via –C++ implementatie overerving –delegatie in dezelfde adresruimte –totaal gescheiden implementatie in dezelfde adresruimte –delegatie over adresruimtegrens –gescheiden implementatie in verschillende adresruimten

Herdefinitie en Regels Constanten, types en excepties mogen opnieuw gedefinieerd worden in de ervende interface (verwarrend, te vermijden) Attributen en operaties mogen niet opnieuw gedefinieerd worden Overloading is ook in de ervende klasse niet toegestaan Meervoudige overerving is toegelaten, (mits de namen niet dubbel voorkomen!) met minder problemen dan C++ (interface)

Meervoudige overerving, voorbeelden Interface Sensor {…}; interface Thermometer : Sensor {… }; interface Hygrometer : Sensor { … }; interface HygroTherm : Thermometer, Hygrometer {… }; Dit is in orde, op voorwaarde dat Thermometer en Hygrometer geen namen voor attributen of operaties delen (types zijn toegelaten!) De vraag of van “Sensor” één of twee exemplaren aanwezig zijn in HygroTherm is een implementatiekwestie.

Corba Voorbeeld Van Toepassing Naming Service IDLs for the CORBA Server Een reference Een IDL voorbeeld Verder Voorbeeld

Voorbeeld: climatisatiesysteem Zie bijlagen

Afbeelding IDL naar C++ Intuïtief, gemakkelijk te gebruiken Aanvoelen als normale C++ programmatuur Typeveilig Efficiënt in geheugengebruik en cycly OK voor verschillende geheugen- architecturen Reentrant, goed voor thread toepassingen Plaatsonafhankelijkheid Beste compromis, met voorrang voor efficiëntie over gebruiksgemak

Enige regels Identifiers blijven normaal behouden –if -> _cxx_if Modules worden “namespaces” De CORBA module: “namespace” in C++, bevat standaard IDL types en interfaces Basis types zijn beschikbaar voor overloading, behalve Boolean, Octet, Wchar (w)strings worden op (W)char * afgebeeld. Allocatie moet gebeuren met speciale functies

Afbeeldingstabel

Overdraagbare geheugenallocatie namespace CORBA { // do not use new[] en delete[] static char * string_alloc(Ulong len); static char * string_dup(const char *); static void string_free(char *); static WChar * wstring_alloc(Ulong len); static WChar * wstring_dup(const WChar *); static void wstring_free(WChar *); //… }

Types van variabele lengte Voor types van variabele lengte zijn er twee mogelijkheden: –raw: doe als programmeur alle geheugenbeheer zelf. Dit is de oude C-programmeerstijl, met een onderscheid tussen types van variabele en vaste lengte. –Gebruik slimme pointer types, _var, die de deallocatie van het geheugen voor u doen. Vaste en variabele lengte krijgen een uniforme behandeling.

_var types Voorbeeld –Schrijf een C-functie die een string van een I/O apparaat leest en teruggeeft als resultaat. De lengte van de string is niet beperkt, en kan niet bepaald worden op voorhand. Oplossingen –static buffer –static pointer naar dynamisch geheugen –geheugen meegegeven door de oproeper –een pointer naar dynamisch geheugen als return

_var types Van elke klasse van variabele grootte wordt een basis C++ type (raw) en een wrapper klasse gedefinieerd (automatisch):

_var types, voorbeeld class String_var { public: String_var(); // s = 0 String_var(char * p); // s = p, zal string_free uitvoeren op p String_var(const char * p); // s = string_dup(p), free op s String_var(const String_var & s);//deep copy ~String_var(); //destructor, voert string_free(s) uit String_var operator=(char * p); // s = p, String_var operator=(const char * p); // s = string_dup(p) String_var operator=(const String_var & s);//deep copy

_var types, class String_var operator char *(); // conversie tot char * operator const char *() const; // conversie tot const char * operator char * &(); // vb in void update(char * &);(realloc) char & operator[](ULong); char operator[](ULong) const; // gebruik een_string[3] /* voorbeeld CORBA::String_var s; s = get_string(); // string_alloc, s eigenaar size_t len = strlen(s); // Ok, conversie */

Valkuilen in String_var CORBA::String_var s1(“Hall”); // slecht in non ANSI C++ CORBA::String_var s2 = “Hall”; // idem! CORBA::String_var s3; s3 = “Hall”; // idem, nu met toekenningsoperator oplossingen: CORBA::String_var s1((const char *) “Hall”); CORBA::String_var s2 =(CORBA::string_dup(“Hall”)); CORBA::String_var s3; s3 = (const char *) “Hall”; een toekenning aan een pointer geeft een wijzer naar inwendig geheugen in de string, let dus op met char * p = s1;

Performantie bij lees toegang void print_string(CORBA::String_var s) { cout << “String is \”” << s << “\”” << endl; } // gaat tot 10 functie-oproepen, inclusief new en delete void print_string(const char * s) { cout << “String is \”” << s << “\”” << endl; } // gebruikt automatische conversie, met inline code

Voorbeeld: Climakontrole Thermometers en thermostaten in een eigen netwerk Uitgerust met geheugen dat kan uitgelezen worden via meegeleverde software Centrale controle via een monitor op het bedrijfsnetwerk

Thermometers Asset –uniek nummer, vast aan het toestel, is het adres binnen het eigen netwerk Model –bepaalt karakteristiek, string, read-only Location –de plaats waar de thermometer staat, wordt ingesteld

Thermostaten Hebben de eigenschappen van thermometers Worden even uniek genummerd via de asset Laten het instellen van de gewenste temperatuur binnen bepaalde grenzen toe

De monitor Lijst van de toestellen Relatief (delta) instellen van de gewenste temperaturen voor de termostaten –bij een instelling buiten de grenzen blijft de oorspronkelijke instelling behouden, de thermostaat genereert een foutboodschap

IDL Thermometer –Gebruik van typedef voor de attributen –Gebruik van (readonly) attributen Thermostaat –Gebruik van functies –Definitie van de exception “BadTemp” de struct BtData helpt omdat een exception niet als veld van een struct kan gebruikt worden

IDL Controller –Gebruik van een polymorfe lijst van thermometers –Definitie van een operatie change op een lijst van thermostaten –Specifieke foutmelding via een lijst (Echange) –een find operatie via een lijst van zoekopdrachten, overloading via een enum

Definitie van een client voor het climasysteem De mapping voor de clients is uitgebreid Voor eenvoudige clients is mits het gebruik van _var klassen veel complexiteit verborgen Geheugenbeheer gebeurt ongeveer automatisch Bekijk het voorbeeld

Globale structuur Try-catch blok in main –return van generische CORBA::Exception –return via willekeurige, niet opgevangen Exceptions Belangrijk via main terug te keren, niet via exit.

Include Files … ccs.hh –resultaat van de idl compiler –naamgeving is niet gestandaardiseerd oplossing via conditionele compilatie via parameters voor de compiler

Helper functies: toesteldetails Maak een “ostream inserter” voor CCS::Thermometer_ptr variabelen –dit laat meteen _var variabelen toe (automatische typeconversie) Controle op is_nil voor de pointer Dynamische typecontrole via _narrow –maakt een kopie indien mogelijk! –maakt een gedifferentieerde afdruk mogelijk

IDL: Error Exception informatie Wordt straks bewust gebruikt Het BtData type laat een ostream-inserter toe EChange is een lijst, wordt ook via een ostream inserter afgedrukt De functie set_temp probeert een nieuwe temperatuur op een thermostaat in te stellen

Main Initialisatie –argc en argv worden doorgegeven aan CORBA::orb_init. Deze zal de strings in argv onderzoeken naar parameters -ORB… die als parameters voor de orb geïnterpreteerd worden, en uit de lijst verdwijnen –‘orb’ is een pseudo-referentie, gespecifieerd in de CORBA module via PIDL (Pseudo-IDL)

Main Initialisatie, vervolg –de client verwacht de object referentie op de commandolijn (primitieve methode, wordt later vervangen door dynamische bootstrap) –eerst wordt de string omgezet naar een object referentie (is_nil duidt enkel op een nil- referentie op de commandolijn) –vervolgens wordt het object via _narrow dynamisch geconverteerd naar het gewenste type

Main Elke interactie met de ORB kan fouten opleveren. Deze worden door de hoofdlus opgevangen –bijvoorbeeld: een syntax fout in de object- referentie-string Interactie met de server –is transparant via de object referenties –gebruikt voortdurent _var par’s voor de variabelen van wisselende grootte

De Server Een servant voor elk CORBA object –controller –elk toestel –transient: bij het afsluiten wordt alle informatie (instellingen, assets, modellen, locaties,...) vergeten –de verzameling toestellen ligt vast, wordt niet door de clienten beïnvloed

Instrument Controle via de eigen API ICP: Intstrument Controle Protocol

#ifndef _ICP_H #define _ICP_H extern “C” { int ICP_online(unsigned long id); // voegtoe int ICP_offline(unsigned long id); // verwijder int ICP_get(unsigned long id, const char * attr, void * value, size_t len); int ICP_set(unsigned long id, const char * attr, const void * value); };} #endif

The Thermometer Servant Class Class Thermometer_impl : public virtual POA_CCS::Thermometer { //... public : virtual CCS::ModelType model() throw(CORBA::SystemEx… virtual CCS::AssetType asset_num() throw(CORBA::System… virtual CCS::TempType temperature() throw(CORBA::Syste… virtual CCS::LocType location() throw(CORBA::SystemExc… virtual void location(const char ¨loc) throw(CORBA::System… };

The Thermometer Extended Thermometer_impl(CCS::AssetType, const char * loc); virtual ~Thermometer_impl(); static Controller_impl * m_ctrl; protected: CCS::AssetType m_anum; private: CCS::ModelType get_model(); CCS::TempType get_temp(); CCS::LocType get_loc(); void set_loc(const char *); Thermometer_impl(const Thermometer_impl &); void operator=(const Thermometer_impl &);

Implementatie, voorbeelden CCS::ModelType Thermometer_impl::get_model() { char buf[32]; assert(ICP_get(m_anum,”model”,buf,sizeof(buf)) == 0); return CORBA::string_dup(buf); } CCS::TempType Thermometer_impl::get_temp() { short temp; assert(ICP_get(m_anum,”temperature”,&temp,sizeof(temp))==0); return temp; }

IDL Operaties, voorbeelden CCS::ModelType Thermometer_impl::model() throw(CORBA::SystemException) { return get_model(); } CCS::LocType Thermometer_impl::location() throw(CORBA::SystemException){ return get_loc(); }

Voorbeelden van toepassingen Hierarchisch controlesysteem voor grote structuren (bruggen, torens, …) Grid computing en apers/corba-cog.pdf apers/corba-cog.pdf …