Corba

1. Corba Overzicht

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

3. Corba Sites De referentie is http://www.corba.org/ vooral: http://www.omg.org/technology/corba/corba3releaseinfo.htm Een autoriteit is: http://www.cs.wustl.edu/~schmidt/corba.html Voor de linux gemeenschap: http://linas.org/linux/corba.html Een goede tutorial is http://www.dcl.hpi.uni-potsdam.de/LV/ccm04/ En "off the road" http://www.corbamtb.com/

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

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

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

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

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

11. 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)

12. 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)

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

14. 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)

15. Een voorbeeldTimeServer struct TimeOfDay { short hour; short minute; short second; }; • 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 Interface Time { TimeOfDay get_gmt(); };

16. Server code #include <time.h> #include <iostream.h> #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;

17. Server code int main(int argc, char * argv[]) { try{ 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(); } catch (const CORBA::Exception &) { cerr << “?” << endl; return 1} return 0;}

18. Server compilatie e.d. • CC -c -I/opt/myORB/include timeS.cc • CC -c -I/opt/myORB/include timeC.cc • CC -c -I/opt/myORB/include myserver.cc • CC -o myserver timeC.o timeS.o myserver.o \ • -L/opt/myORB/lib -lorb • IOR:0000000000000000d4944443eafec902….

19. Client int main(int argc, char * argv[]){ return 0;} #include <iostream.h> #include <iomanip.h> #inlcude “time.hh” 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;

20. Client compilatie e.d. • CC -c -I/opt/myORB/include myclient.cc • CC -c -I/opt/myORB/include timeC.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 &

21. OMG IDLInterface 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

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

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

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

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

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

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

31. 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; • }

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

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

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

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

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

37. Recursieve types case UNAIR: struct UnaireOp { OpType op; sequence<Node,1> kind; } u_op; case BINAIR: struct BinaireOp { OpType op; sequence<Node,2> kinderen; } bin_op; };

38. Recursieve Types • In kwade en in goede tijden: • de sequence<Node, 1> 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.

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

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

41. 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)

42. 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<long> get_longs(); //Fout SomeType read_value() const; //Fout };

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

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

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

47. 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(); };

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

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

50. 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)