Objektorienteret Netværkskommunikation

1. Objektorienteret Netværkskommunikation CORBA Introduction

2. Outline • CORBA Introduction & Background • Architecture • Session & Presentation layer • GIOP / IIOP / CDR • CORBA Interface Definition Language – IDL • Language mappings • CORBA development steps • Code Examples in Java / C++ • Alignment

3. Who is the OMG? • OMG: Object Management Group • http://www.omg.org • Non-profit organization in the US • Founded April 1989 • More than 800 members • Dedicated to creating and popularizing object-oriented industry standards for application integration, e.g. • CORBA 1.0 (1995) –> CORBA 3.0.3 (2006) • UML 1.1 nov. 97. -> 2.1 (2006)

4. Goal of CORBA • CORBA: Common Object Request Broker Architecture • Support distributed and heterogeneousobject request in a way transparent to users and application programmers • Facilitate the integration of new components with legacy components • Open standard that can be used free of charge • Based on wide industry consensus • But not much Microsoft support • Problem with CORBA • Considered too complex by many

5. The Specifications • CORBA is a collection of specifications • http://www.omg.org/technology/documents/corba_spec_catalog.htm • Common Object Request Broker Architecture (CORBA/IIOP) (3.0.3) • CORBA Component Model (CCM) (3.0) • Light Weight CCM • CORBA/e (replaces Minimum CORBA) • Minimum CORBA (1.0) • Real-Time CORBA (Dynamic Scheduling) (2.0) • Real-Time CORBA (Static Scheduling) (1.1) • Others

6. Families of specifications: • CORBAservices Specifications • CORBAfacilities Specifications • OMG Domain Specifications • IDL / Language Mapping Specifications • Many others • Realted to UML • UML Profile for CORBA (1.0)

7. Object Management Architecture (OMA) CORBAFacilities DomainInterfaces ApplicationObjects Object Request Broker CORBA Services(mandatory)

8. CORBA Architecture1 • Many different vendors and ORB types • Many of which do not interoperate • Must check specification • OrbBacus from IONA produces both C++ and Java • Sun J2SE SDK has only Java-based ORB • C++ ORB from IONA will work with SUN ORB as specified • Many others • MicoORB, Middcor, TAO, openORB, VisiBroker

9. Object Implementation Client Implementation Skeletons Object Adapter Dynamic Invocation ORB Interface Client Stubs ORB Core One standardised interface One interface per object operation One interface per object adapter ORB-dependent interface CORBA Architecture 2

10. Interoperability Protocols Applications EnvironmentSpecific .. CORBA 2.0 ESIOP GIOP ........ ........ IIOP DOETalk DCE-CIOP Mandatory: provides "out of the box" interoperability IIOP: Internet Inter-ORB Protocol is the primary CORBA transport protocol

11. General Inter-ORB Protocol • GIOP: Handles the session & presentation layer • Defines seven message primitives: • Request, Reply, Locate Request, Locate Reply, Cancel request, Close Connection, Message Error • Binary formatted • More simple than JRMP for Java RMI • Internet Inter-ORB Protocol (IIOP) • Maps GIOP to TCP/IP • Provides operations to open and close TCP/IP connections • Is required from ORBs for CORBA compliance • But intra vendor ORB com is not restricted to this More on the IIOP in TIOOMI if wanted

12. Common Data Representation (CDR) • Defined as part of GIOP • Presentation layer implementation to support heterogeneity • Mapping of IDL data types to transport byte stream • Encodings of • primitive types • constructed types • interoperable object references

13. Recap - motivation for an IDL • IDL: Interface Definition Language • Components of distributed systems are written in different programming languages • Programming languages may or may not have their own object model • Object models largely vary • Differences need to be overcome in order to facilitate integration

14. “Object Wrappingof nonOO application” CORBA C++ Client App.3 CORBAC# Client App.2 CORBA Java Client App.1 Heterogeneous OO Network CORBA CobolDatabase Server TCP/IPNetwork DB Different ORB’s from different vendors, on different operating systems – and written in different languages = Heterogenity

15. PL PL 1 2 PL IDL PL 6 3 PL PL 5 4 CORBA IDL & Mappings PL PL 1 2 Avoid multiple mappings PL PL 6 3 PL PL 5 4

16. Smalltalk C++ Ada-95 Java C .NET Cobol CORBA Programming Language Bindings IDL Common Object Model Janeva / Middcor (C#) / .NET REMoting

17. Interface Definition Language • Akronym: IDL • Language for expressing all concepts of the middleware’s object model • Should be • programming-language independent • not computationally complete • Bindings to different programming languages are needed • language bindings are specified by CORBA

18. Organization #name:string uses Trainer 1 1..* Club -name:string works for -noOfMembers:int -location:Address +train() +transfer(p:Player) 1 1..* has coaches 1..* * Team plays in -name:string 1 11..16 +bookGoalies() Example UML to IDL mapping Player -name:string -Number:int +book()

19. Constructed types Atomic types Object type CORBA Object Model: Types typedef struct Address { string street; string postcode; string city; }; typedef sequence<Address> AddressList; interface Team { ... };

20. CORBA Object Model: Modules Soccer::Address module Soccer { typedef struct Address { string street; string postcode; string city; }; }; module People { typedef struct Address { string flat_number; string street; string postcode; string city; string country; }; }; Modules = namespaces People::Address

21. Clients cannot change value changeable Attribute type Attribute name CORBA Object Model: Attributes interface Player; typedef sequence<Player> PlayerList; interface Trainer; typedef sequence<Trainer> TrainerList; interface Team { readonly attribute string name; attribute TrainerList coached_by; attribute Club belongs_to; attribute PlayerList players; ... };

22. Parameter list Parameter kind Return types Parameter type Parameter name Operation name used in requests CORBA Object Model: Operations interface Team { ... void bookGoalies(in Date d); string print(); };

23. Exception data Exception name Operations declare exceptions they raise CORBA Object Model: Exceptions • Generic Exceptions (e.g. network down, invalid object reference, out of memory) • Type-specific Exceptions exceptionPlayerBooked{sequence<Date> free;}; interface Team { void bookGoalies(in Date d) raises(PlayerBooked); };

24. Implicit supertype: Object Inherited by Club Supertype CORBA Object Model: Subtypes interface Organization { readonly attribute string name; }; interface Club : Organization { exceptionNotInClub{}; readonly attribute short noOfMembers; readonly attribute Address location; attribute TeamList teams; attribute TrainerList trainers; void transfer(in Player p) raisesNotInClub; }; This has only been a minimal presentation of the IDL

25. Legal Values in CORBA (Types)

26. Server Stub Generation Client Stub Generation Server Coding Client Coding Development Steps – CORBA vs RMI & SOAP CORBA AXISSOAP Design J2SE JDK CORBA: IDL Java2WSDL Interface Definition SOAP: WSDL Start with Server Interface Coding: JAVA RMI: JAVA interface WSDL2JAVA CORBA: IDL RMI: rmic RMI: JAVA C++, Java … C++, Java … ORB rmiregistry Server Registration

27. Team.idl Client.cc Server.cc IDL-Compiler Teamcl.hh Teamsv.hh Teamcl.cc Teamsv.cc C++ Compiler, Linker C++ Compiler, Linker included in generates reads Client Server CORBA Client and Server Implementation Next we will look into a simple CORBA programming example

28. Who’s doing what? • Some code will get generated by the IDL compiler • Some code we will need to implement ourselves • Staring with the IDL file

29. IDL Interface of Hello Servant module HelloApp interface Hello{string sayHello();};

30. Java IDLCompiler -IDLJ IDL Compiler Example Java Hello.java (Both Client & Server) contains the Java version of the IDL interface. HelloOperations.java contains the methods – here only sayHello(). All the operations in the IDL interface are placed in the operations file. _HelloStub.java is the client stub. HelloPOA.java is the skeleton class you should extend from. It implements dynamic invocation functions. HelloHelper.java (Both Client & Server) provides auxiliary functionality, notably the narrow() method required to cast CORBA object references to their proper types. HelloHolder.java Whenever the IDL type is an out or an inout parameter, the Holder class is used. Hello.idlfile Generates Input What gets generated by the IDL Compiler

31. Extract from _HelloStub.java What are we looking at?

32. Extract from HelloHelper.java

33. Extract from HelloPOA

34. // HelloServer.java, stringified object reference version // Stefan Wagner, 2003 import org.omg.CosNaming.*; import org.omg.CosNaming.NamingContextPackage.*; import org.omg.CORBA.*; import org.omg.PortableServer.*; import org.omg.PortableServer.POA; import HelloApp.*; //This is the servant - implementing the methods from the IDL class HelloServant extends HelloPOA { private ORB orb; public HelloServant(ORB orb) { this.orb = orb; } public String sayHello() { return "\nHello world !!\n"; } } HelloServant The server object (Part 1) By extending from HelloPOA we may communicate with ORB Constructor taking ORB as a parameter (from HelloPOA) The CORBA operation implemented Implemented manually

35. //This is the HelloServer - the server running the HelloServant - Servant public class HelloServer { public static void main(String args[]) { try{ // create and initialize the ORB org.omg.CORBA.ORB orb = org.omg.CORBA.ORB.init(args, null); // create servant and register it with the ORB HelloServant helloRef = new HelloServant(orb); // get reference to rootpoa and activate the POAManager POA rootpoa = POAHelper.narrow(orb.resolve_initial_references("RootPOA")); rootpoa.the_POAManager().activate(); // get object reference from the servant org.omg.CORBA.Object ref = rootpoa.servant_to_reference(helloRef); Hello href = HelloHelper.narrow(ref); // stringify the helloRef and dump it in a file String oir = orb.object_to_string(href); java.io.PrintWriter out = new java.io.PrintWriter(new java.io.FileOutputStream("object.ref")); out.println(oir); out.close(); // wait for invocations from clients orb.run(); } catch (Exception e) { System.err.println("ERROR: " + e); e.printStackTrace(System.out); } } } HelloServant The server object (Part 2) Init ORB and register servant with ORB Activate rootPOA The POA produces the reference Narrow the call (CORBA type cast + IDL type check) Object reference ”stringified” and Sent to file object.ref Start the orb server process

36. // HelloClientSOR.java, stringified object reference version import java.io.*; import org.omg.CORBA.*; import HelloApp.HelloHelper; import HelloApp.*; public class HelloClientSOR { public static void main(String args[]) { try { // create and initialize the ORB org.omg.CORBA.ORB orb = org.omg.CORBA.ORB.init(args, null); // Get the stringified object reference and destringify it. java.io.BufferedReader in = new java.io.BufferedReader(new java.io.FileReader("object.ref")); String ref = in.readLine(); org.omg.CORBA.Object obj = orb.string_to_object(ref) ; Hello helloRef = HelloHelper.narrow(obj); // call the Hello server object and print results String Hello = helloRef.sayHello(); System.out.println(Hello); } catch (Exception e) { System.out.println("ERROR : " + e) ; e.printStackTrace(System.out); } } } HelloClientSOR The Client program Init ORB Object reference Read from file Narrow the call (CORBA type cast + IDL type check) Call via Proxy Implemented manually

37. What is this object.ref file? IOR:000000000000001749444c3a48656c6c6f4170702f48656c6c6f3a312e30000000000001000000000000006c000102000000000e3139322e3136382e312e3130300011b600000021afabcb0000000020a80a250300000001000000000000000000000004000000000a0000000000000100000001000000200000000000010001000000020501000100010020000101090000000100010100 • IOR: Interoperable Object Reference • Includes info on: Repository ID (standard), Endpoint Info (standard) - including IP and port number, Object Key (proprietary) • Can be written into a file • Not really nice with a file-based reference – or what? • May employ a naming service instead • This we shall look at later • File-based may be necessary due to firewall problems • Possible to use a HTTP or FTP server for distributing the references

38. #include <OB/CORBA.h> #include <Hello.h> #include <fstream.h> int run(CORBA::ORB_ptr); int main(int argc, char* argv[]) { int status = EXIT_SUCCESS; CORBA::ORB_var orb; try { orb = CORBA::ORB_init(argc, argv); status = run(orb); } catch (const CORBA::Exception&) { status = EXIT_FAILURE; } if(!CORBA::is_nil(orb)) { try { orb -> destroy(); } catch(const CORBA::Exception&) { status = EXIT_FAILURE; } } return status; } HelloCorba C++ Client Part 1 Init ORB Call run method (see next slide) Destroy ORB Implemented manually

39. … int run(CORBA::ORB_ptr orb) { const char* refFile = "object.ref"; ifstream in(refFile); char s[2048]; in >> s; CORBA::Object_var obj = orb -> string_to_object(s); HelloApp::Hello_var hello = HelloApp::Hello::_narrow(obj); cout << hello->sayHello() << endl; return 0; } HelloCorba C++ Client Part 2 Object reference Read from file HelloApp::Hello_var smartpointer type Generated by IDL compiler + Hello Narrow the call (CORBA type cast) to the Hello_var smartpointer (helper + memory management) Call method via Proxy and print result

40. Alignment med læringsmål Når kurset er færdigt forventes den studerende at kunne: • redegøre for de grundlæggende principper og teknikker omkring interproceskommunikation over såvel lokalnetværk som Internettet • redegøre for teknikker for distribuerede objektorienterede løsninger, herunder serialisering, marshalling, stub/skeleton, proxy, brug af forskellige Interface Definition Language sprog som udviklingskontrakt • redegøre for principperne omkring transparens og heterogenitet (platforms og programmeringssprogs uafhængighed) • redegøre for anvendelsen af Java RMI, XML/SOAP (Webservices), herunder forskelle/ligheder, fordele/ulemper teknologierne imellem. Samt på overordnet niveau have kendskab til forskelle og ligheder med CORBA og .NET Remoting teknologierne • anvende socket programmering til at lave et mindre distribueret system baseret på objektorienterede principper • anvende objektorienterede teknikker og arkitekturer til at designe og programmere netværksforbindelser ved brug af middleware, og bevise dette ved at konstruere og dokumentere to distribuerede systemer der gør brug af ovenstående teknologier Hvornår vælge hvilken teknolog, der skal vælges Forstå at CORBA er binært, bruger IDL, IIOP, er heterogent har en ”pæn” objekt struktur. Også bruger stubs. Kunne genkende på koden at det er CORBA. Men ikke forstå koden i detaljer