universität bonn, seminar component and aspect engineering im ws 2003, evgueni kouris 1 common...

Universität Bonn, Seminar „Component and Aspect Engineering“ im WS 2003, Evgueni Kouris 1

Common Object Request Broker Architecture (CORBA)

Evgueni Kouris WS 03/04


Evolution der Software-Anwendungssysteme (1) Von der Monolith-Architektur zur 2-Tier-Architektur...

Monolith Fat-Clients Datenbank-Server

SQL


Evolution der Software-Anwendungssysteme (2) ... zur 3- oder n-Tier-Architektur ...

Thin-Clients Server-Logik Datenbank-Server

SQL

SQL


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

VerticalCORBA Facilities

HorizontalCORBA Facilities

ApplicationObjects


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

VerticalCORBA Facilities

HorizontalCORBA Facilities

ApplicationObjects


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?


Interface Definition Language (IDL)


Interface Definition Language (IDL)

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

Objekt


Beispiel für eine IDL-Schnittstellemodule MeineBank {

exception BankFehler {string info;

};

interface BasisKonto {readonly attribute long nummer; double einzahlen ( in double betrag ) raises ( BankFehler );

};

// GiroKonto wird von BasisKonto abgeleitetinterface GiroKonto : BasisKonto {

double attribute dispoKredit;};

interface SparKonto : BasisKonto { double attribute zinssatz;

};

// GiroSparKonto wird von SparKonto und GiroKonto abgeleitetinterface GiroSparKonto : SparKonto, GiroKonto {};

};

module MeineBank {exception BankFehler {

string info;};

interface BasisKonto {readonly attribute long nummer; double einzahlen ( in double betrag ) raises ( BankFehler );

};

// GiroKonto wird von BasisKonto abgeleitetinterface GiroKonto : BasisKonto {

double attribute dispoKredit;};

interface SparKonto : BasisKonto { double attribute zinssatz;

};

// GiroSparKonto wird von SparKonto und GiroKonto abgeleitetinterface GiroSparKonto : SparKonto, GiroKonto {};

};


IDL-Datentypen

Basis Datentyp Beschreibung Java-Mapping C++-Mapping

short 16 bit Integer short CORBA::Short

long 32 bit Integer int CORBA::Long

long long 64 bit Integer long CORBA::LongLong

unsigned short 16 bit vorzeichenlos short CORBA::UShort

unsigned long 32 bit vorzeichenlos int CORBA::ULong

unsigned long long 64 bit vorzeichenlos long CORBA::ULongLong

float 16 bit IEEE Gleitkomma float CORBA::Float

double 32 bit IEEE Gleitkomma double CORBA::Double

long double 64 bit IEEE Gleitkomma double CORBA::LongDouble

char 8 bit Zeichen char CORBA::Char

wchar 16 bit Zeichen (Unicode) char CORBA::WChar

boolean TRUE oder FALSE boolean CORBA::Boolean

octet einzelnes Byte byte CORBA::Octet

string Zeichenkette java.lang.String CORBA::String

wstring Zeichenkette (Unicode) java.lang.String 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)


Object Request Broker

ORB Operations

operation() + args

Was steckt hinter einem Methodenaufruf? Proxy-Patterns: werden aus IDL-Schnittstelle automatisch generiert

Stub: Server-Proxy Skeleton: Client-Proxy

Skeleton


Stub

Language mappingoperations signature

Language mappingentry points

return valueClient Objekt

Portable Object Adapter

Laufzeitumgebung, (re)aktiviert Objekte


Entwicklung einer Client/Server Anwendung mit CORBA


Entwicklungs-Schema


IDL-Definition

ClientProgramm

Source

ObjektImplementierung

Source

IDL-Compiler

SkeletonSource

Stub Source

Java/C++ Compiler

Client-Programm

Java/C++ Compiler

Objekt-Implementierung


IDL-Schnittstelle

Zuerst wird die Schnittstelle in OMG-IDL definiert:

//Hello.idl

interface Hello{ void say_hello();};

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

#include “Hello_skel.h”

class Hello_impl : public POA_Hello { public: virtual void say_hello() throw(CORBA::SystemException);};

#include “Hello_skel.h”

class Hello_impl : public POA_Hello { public: virtual void say_hello() throw(CORBA::SystemException);};

#include <iostream.h>#include <OB/CORBA.h>#include “Hello_impl.h”

void Hello_impl::say_hello() throw(CORBA::SystemException){ cout << "Hello World!" << endl;}

#include <iostream.h>#include <OB/CORBA.h>#include “Hello_impl.h”

void Hello_impl::say_hello() throw(CORBA::SystemException){ cout << "Hello World!" << endl;}

Die Header-Datei des Objektes in C++: (Hello_impl.h)

Die Implementierung der Header-Datei: (Hello_impl.cpp)


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

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




POA öffnen

Referenz einerInstanz erzeugen

IOR des Objektesspeichern

POA aktivieren,ORB starten(warten auf Clients)


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 Instanzauslesen

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.javapublic class Hello_impl extends HelloPOA{ public void say_hello() { System.out.println("Hello World!"); }}

//Hello_impl.javapublic 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”


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




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




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

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





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

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

Object Request Broker

ORB Operations Portable Object Adapter

Skeleton


Client Objekt

DII

InterfaceRepository

Dynamic InterfaceQuery


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

GIOPProtocol


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


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)


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?

universität bonn, seminar component and aspect engineering im ws 2003, evgueni kouris 1 common...

Documents

aspect engineering im

seminar component

universitt bonn

corba java

corba dii

corba oma

corba services generelle

middleware folie