Common Object Request Broker Architecture (CORBA) Evgueni Kouris WS 03/04

Evolution der Software-Anwendungssysteme (1) Von der Monolith-Architektur zur 2-Tier-Architektur... Fat-Clients Datenbank-Server SQL Monolith

Evolution der Software-Anwendungssysteme (2) ... zur 3- oder n-Tier-Architektur ... SQL SQL Thin-Clients Server-Logik Datenbank-Server

Evolution der Software-Anwendungssysteme (3) ... zur heterogenen n-Tier-Architektur auf Middleware-Basis. Middleware

Gliederung: Basics von CORBA OMA, ORB, IDL, Stubs, Skeletons, etc. Entwicklung einer CORBA-Applikation in Java/C++ CORBA Services Einige nützliche Features von CORBA DII, IIOP, IOR, etc. Neurungen in CORBA 3.0

Object Management Architecture (1) Object Request Broker (ORB) CORBA Services Vertical CORBA Facilities Horizontal Application Objects

Object Management Architecture (2) CORBA – genauere Spezifikation von ORB Weitere vier Anwendungs-Komponenten: CORBA Services – generelle, systemnahe Erweiterung von Grundfunktionalität eines ORBs (z.B. Transactions, Security) Horizontal CORBA Facilities – komplette höhere Domain-Unabhängige Funktionen (z.B. Printing, Internalization) Vertical CORBA Facilities – Teillösungen für bestimmte Anwendungsgebiete (z.B. Finanzen oder Medizin) Application Objects – angepasste, konkrete Lösungen enstprechen den Einzelprogrammen werden nicht standardisiert Object Request Broker (ORB) CORBA Services Vertical CORBA Facilities Horizontal Application Objects

Applikationen in CORBA Applikationen als „Objekte“ Diskrete Softwarebausteine oder Module Zustand + Methoden OO Abstraktion der einzelnen Anwendungen Instantiierung Overloading, Subtyping (auch mehrfach) Kapselung (Trennung der Implementierung und der Schnittstelle) Sprachen der Applikationen in CORBA Java, C, C++, Cobol, Ada, Smalltalk, List, Python Ist eine Schnittstellensprache erforderlich? OMG – nur eine Spezifikation! Applikationen = Application objects ->>> Vertical Facilities ->>> Horizontal Facilities ->>> Corba Services

Interface Definition Language (IDL)

Interface Definition Language (IDL) Objekt IDL-Interface Stellt eine Obermenge der Sprachkonzepte dar Unterstützte Sprachen: Java, C, C++, Cobol, Ada, Smalltalk, List, Python Verwendet C++/Java-ähnliche Syntax Vorteile einer selbständigen Schnittstellen-Sprache rein deskriptiv vollkommene Trennung von der Implementierung mehrere Implementierung pro IDL-Interfaces und umgekehrt möglich automatische Generierung der Interfaces für alle Sprachen Sicherstellung der Interface-Gleichheit bei allen Clients/Objekten

Beispiel für eine IDL-Schnittstelle module MeineBank { exception BankFehler { string info; }; interface BasisKonto { readonly attribute long nummer; double einzahlen ( in double betrag ) raises ( BankFehler ); }; // GiroKonto wird von BasisKonto abgeleitet interface GiroKonto : BasisKonto { double attribute dispoKredit; }; interface SparKonto : BasisKonto { double attribute zinssatz; }; // GiroSparKonto wird von SparKonto und GiroKonto abgeleitet interface GiroSparKonto : SparKonto, GiroKonto {}; };

IDL-Datentypen Basis Datentyp Beschreibung Java-Mapping C++-Mapping short 16 bit Integer CORBA::Short long 32 bit Integer int CORBA::Long long long 64 bit Integer CORBA::LongLong unsigned short 16 bit vorzeichenlos CORBA::UShort unsigned long 32 bit vorzeichenlos CORBA::ULong unsigned long long 64 bit vorzeichenlos CORBA::ULongLong float 16 bit IEEE Gleitkomma CORBA::Float double 32 bit IEEE Gleitkomma CORBA::Double long double 64 bit IEEE Gleitkomma CORBA::LongDouble char 8 bit Zeichen CORBA::Char wchar 16 bit Zeichen (Unicode) CORBA::WChar boolean TRUE oder FALSE CORBA::Boolean octet einzelnes Byte byte CORBA::Octet string Zeichenkette java.lang.String CORBA::String wstring Zeichenkette (Unicode) CORBA::WString any Container für einen beliebigen Datentyp ? CORBA::Any

Selbst-definierte IDL-Datentypen Unterstützung für typedef enum const struct union arrays exception Auch für Precompiler-Anweisungen #include #define Quelle: „An intoducation to CORBA“ von Paul Jonusaitus

Client/Server Kommunikation CORBA - Clients kommunizieren über die IDL-Schnittstelle des Objekts senden „Requests“ oder „Invocations“ ORB - Kommunikationsbus vollkommen Transparent, d.h. unabhängig von der Residenz des Objektes unabhängig von der Programmiersprache des Objektes Idealfall: Clients wissen gar nicht, dass CORBA verwendet wird! CORBA - Server stellen Applikation- bzw Objekt-Implementierungen dar müssen nicht „heavyweight“ sein (z.B. Java-Applet) Die Transparenz wird realisiert durch die Proxy-Patterns

Was steckt hinter einem Methodenaufruf? Proxy-Patterns: werden aus IDL-Schnittstelle automatisch generiert Stub: Server-Proxy Skeleton: Client-Proxy Objekt Client return value operation() + args Language mapping operations signature Language mapping entry points Stub Skeleton Portable Object Adapter Laufzeitumgebung, (re)aktiviert Objekte Object Request Broker ORB Operations Quelle: „An intoducation to CORBA“ von Paul Jonusaitus

Entwicklung einer Client/Server Anwendung mit CORBA

Entwicklungs-Schema IDL-Definition IDL-Compiler Skeleton Source Stub Source Client Programm Source Objekt Implementierung Source Java/C++ Compiler Client-Programm Java/C++ Compiler Objekt-Implementierung Quelle: „An intoducation to CORBA“ von Paul Jonusaitus

IDL-Schnittstelle Zuerst wird die Schnittstelle in OMG-IDL definiert: //Hello.idl interface Hello{ void say_hello(); }; Man bekommt die Übersetzung der Schnittstelle in C++ und Java durch die Aufrufe von: IDL-to-C++ translator Hello.h, Hello.cpp, Hello_skel.h, Hello_skel.cpp IDL-to-Java translator Hello.java, HelloHelper.java, HelloHolder.java, HelloOperations.java, HelloPOA.java, _HelloStub.java

Hello-Objekt in C++ Die Header-Datei des Objektes in C++: (Hello_impl.h) #include “Hello_skel.h” class Hello_impl : public POA_Hello { public: virtual void say_hello() throw(CORBA::SystemException); }; Die Implementierung der Header-Datei: (Hello_impl.cpp) #include <iostream.h> #include <OB/CORBA.h> #include “Hello_impl.h” void Hello_impl::say_hello() throw(CORBA::SystemException){ cout << "Hello World!" << endl; }

Server-Programm in C++ #include <OB/CORBA.h> #include <Hello_impl.h> #include <fstream.h> int main ( int argc, char* argv[] ){ try { CORBA::ORB_var orb = CORBA::ORB_init ( argc, argv ); CORBA::Object_var poaObj = orb -> resolve_initial_references("RootPOA"); PortableServer::POA_var rootPoa = PortableServer::POA::_narrow(poaObj); PortableServer::POAManager_var manager = rootPoa -> the_POAManager(); Hello_impl* helloImpl = new Hello_impl(); Hello_var hello = helloImpl -> _this(); CORBA::String_var s = orb -> object_to_string(hello); const char* refFile = "Hello.ref"; ofstream out(refFile); out << s << endl; out.close(); manager -> activate(); orb -> run(); orb -> destroy(); } catch ( const CORBA::Exception& e ) { cerr << e << endl; } } POA öffnen Referenz einer Instanz erzeugen POA aktivieren, ORB starten (warten auf Clients) IOR des Objektes speichern

Client-Programm in Java public class Client{ public static void main ( String args[] ) { java.util.Properties props = System.getProperties(); try { org.omg.CORBA.ORB orb = org.omg.CORBA.ORB.init(args, props); org.omg.CORBA.Object obj = null; String refFile = "Hello.ref"; java.io.BufferedReader in = new java.io.BufferedReader( new java.io.FileReader(refFile)); String ref = in.readLine(); obj = orb.string_to_object(ref); Hello hello = HelloHelper.narrow(obj); hello.say_hello(); orb.destroy(); } catch ( Exception e ) { e.printStackTrace(); } } IOR der Instanz auslesen Den Proxy anhand der IOR ermitteln

Hello-Objekt in Java Man kann natürlich den Client auch in C++ und den Server auch in Java implementieren Hier z.B. die Implementierung des Hello-Objektes in Java: //Hello_impl.java public class Hello_impl extends HelloPOA { public void say_hello() { System.out.println("Hello World!"); } Nachteil dieser Implementierungen: Referenz des Objektes erforderlich Übergabe in der Datei sehr “unschön” => Man sieht: ohne zusätzliche Services ist eine Richtige Client/Server-Transparenz ist nicht zu erreichen!!! >

CORBA Services Verteilung von Objektreferenzen Name Service – Auffinden von Objekten anhand deren Namen Trader Service – Objekte registrieren sich als Dienste Benachrichtigung über Ereignisse Event Service – übernimmt Übermittlung von Ereignissen Notification Service – Filtern von E. nach Inhalt oder Priorität Transaktionen Object Transation Service – Zuverlässigkeit bei Fehlern, sicheres Beenden von Prozessen, Wiederherstellung des Zustands Kontrolle/Sicherheit Security Service – Identität, Privilegien, Rechte, Verschlüsselung

Server in C++ mit „Name Service“ #include <OB/CORBA.h> #include <Hello_impl.h> #include <fstream.h> int main ( int argc, char* argv[] ){ try { CORBA::ORB_var orb = CORBA::ORB_init ( argc, argv ); CORBA::Object_var poaObj = orb -> resolve_initial_references("RootPOA"); PortableServer::POA_var rootPoa = PortableServer::POA::_narrow(poaObj); PortableServer::POAManager_var manager = rootPoa -> the_POAManager(); Hello_impl* helloImpl = new Hello_impl(); Hello_var hello = helloImpl -> _this(); CORBA::String_var s = orb -> object_to_string(hello); const char* refFile = "Hello.ref"; ofstream out(refFile); out << s << endl; out.close(); manager -> activate(); orb -> run(); orb -> destroy(); } catch ( const CORBA::Exception& e ) { cerr << e << endl; } } CORBA::Object_var ns = orb -> resolve_initial_references( "NameService“ ); CosNaming::NamingContext_var nc = CosNaming::NamingContext::_narrow ( ns.in() ); CosNaming::Name aName; aName.length(1); aName[0].id = CORBA::string_dup("hello"); aName[0].kind = CORBA::string_dup(""); nc -> bind( aName, hello.in() );

Client in Java mit Name Service public class Client{ public static void main ( String args[] ) { java.util.Properties props = System.getProperties(); try { org.omg.CORBA.ORB orb = org.omg.CORBA.ORB.init(args, props); org.omg.CORBA.Object obj = null; String refFile = "Hello.ref"; java.io.BufferedReader in = new java.io.BufferedReader( new java.io.FileReader(refFile)); String ref = in.readLine(); obj = orb.string_to_object(ref); Hello hello = HelloHelper.narrow(obj); hello.say_hello(); orb.destroy(); } catch ( Exception e ) { e.printStackTrace(); } } org.omg.CORBA.Object ns = orb.resolve_initial_references ( "NameService" ); NamingContext nc = NamingContextHelper.narrow ( ns ); NameComponent[] aName = new NameComponent[1]; aName[0] = new NameComponent(); aName[0].id = "hello"; aName[0].kind = ""; org.omg.CORBA.Object obj = nc.resolve ( aName ); Hello hello = HelloHelper.narrow ( obj );

CORBA „Schnick-Schnack“

Ein „Dynamischer Methodenaufruf“ DII – Dynamic Invocation Interface Interface Repository: Laufzeit-Datenbank beinhaltet maschinenlesbare IDL-Interfaces Objekt Client Dynamic Interface Query Interface Repository Skeleton Object Request Broker ORB Operations DII Portable Object Adapter Quelle: „An intoducation to CORBA“ von Paul Jonusaitus

Inter-ORB Kommunikation Erst mit CORBA 2.0 standardisiert „General Inter-ORB Protocol” (GIOP) spezifiziert ein einheitliches Kommunikationsprotokoll eine Transfersyntax (Common Data Representation, CDR) für die Übertragung von Daten über das Netz Objektreferenzenformat (Interoperable Object Reference, IOR) „Internet Inter-ORB Protocol” (IIOP) Spezifikation von GIOP für die TCP/IP-Protokoll-Familie ORB 1 C1 O1 ORB 2 C2 O2 GIOP Protocol

Interoperable Object Reference (IOR) Jedes Objekt besitzt eine weltweit eindeutige Referenz Eine IOR besteht aus: einem Objekt-Schlüssel (fixed object key) Typidentifizierung Referenz der Schnittstelle (Repository ID) einigen Profilen ( Interoperability Profiles, IOPs ) Name des Hosts TCP/IP-Port-Nummer Eine IOR kann in einen String (und zurück) umgewandelt werden persistent gemacht werden (sogar für mehrer Instanzen eines O.) Object Adapter(OA) oder Portable OA (POA) - Laufzeitumgebung für die Objekte

Und zuletzt die Vorgeschichte...

Object Management Group(OMG) OMG – ein internationales Konsortium 1989 gegründet von acht Firmen (mittlerweile mehr als 800) 3COM, American Airlines, Canon, Data General, Hewlett Packard, Philips Telecommunications, Sun Microsystems und Unisys Ziel: Verbreitung von verteilten, modularen OO-Software Weg: Erarbeitung von offenen Standards die Realisierung und Umsetzung übernehmen die Mitglieder Entwickelte Spezifikationen „Unified Model Language“ (UML) „Model Driven Architecture“ (MDA) „Object Management Architecture“ (OMA) „Common Object Request Brocker Architecture“ (CORBA) UML wird bei MDA benutzt und spezifiziert. MDA ist noch globaler als OMA, da nicht fixiert auf Object Management, sondern MDA beschreibt die Logik der Software-Architektur, unabhängig von der benutzten Plattform.

Geschichte von CORBA 1989 – Gründung der OMG 1990 – Die Vorstellung des OMA-Referenzmodells 1991 – CORBA 1.0 (nur für C), 1992 – OMA 2.0 (und weitere Releases von CORBA) 1996 – CORBA 2.0 Erweiterungen für C++, Smalltalk Interoperabilität zwischen ORBs verschiedener Hersteller Es folgen in CORBA 2.1/2.2 Erweiterungen für Java/Cobol/Ada

CORBA 3.0 Interoperabilität mit Enterprise JavaBeans, RMI-Objekten „call by value“ möglich Spezifikationen der Anforderungen für minimumCORBA: z.B Verzicht auf„Dynamic Invocation“ etc. realtimeCORBA: Erweiterung mit Threads, Verbindungsmanagment fault-tolerant-CORBA: kontrolliertes Verhalten im Fehlerfall „Asynchronous Messaging“ und „Quality of Service Control“ Ausführung nach Priorität, Lebensdauer Festlegung von Start- und End-Zeitpunkten der Ausführung Polling- bzw. Callback-Funktionen Firewall-Spezifikation, Kommunikation über Firewall-Systeme Interoperable Name Service im URL-Format z.B: iioploc://www.myserver.de/nameService

¿Fragen?