CORBA a IIOP

1. Úvod

2. Prostředí CORBA

Plná implementace prostředí CORBA se skládá z prostředí klientského, z prostředí na straně serveru a objektově orientovaných služeb. Hlavní komponenty architektury jsou znázorněny na obrázku. Jednotlivé komponenty mají tyto funkce:

• Implementace objektu: Kód objektu, který implementuje zveřejněné služby objektu. Implementace může být napsána v libovolném podporovaném jazyce (obvykle C, C++ nebo Java). Rozhraní služeb objektu je definováno v jazyce IDL (Interface Definition Language).
• Klient: Program využívající vzdálené objekty. Pro použití objektu musí mít dostupnou definici rozhraní objektu v jazyce IDL buď vv době překladu nebo při dynamickém volání za chodu programu a jednoznačnou adresu objektu (IOR).
• IDL stubs (spojky): Kód vygenerovaný kompilátorem jazyka IDL, který propojuje uživatelský kód s agentem ORB. V jazyce C++ má spojka formu zástupné třídy, jejíž metody může klientský kód přímo volat.
• DII (Dynamic Invocation Interface): Klient může používat také objekty, ke kterým získá definici rozhraní za běhu programu. Rozhraní pro dynamické volání metod dovoluje generovat dynamické požadavky.
• ORB (Object Request Broker): Zprostředkovatel objektových služeb zahrnuje veškeré vnitřní mechanismy pro vyhledání požadovaného objektu, generování a přenos požadavků, parametrů a výsledků na úrovni komunikace mezi systémy. ORB může používat různé metody komunikace, včetně přímé aktivace objektů v rámci jednoho adresového prostoru.
• Objektový adaptér: Objektový adaptér propojuje implementaci objektu se agentem ORB, demultiplexuje přicházející požadavky, aktivuje objekty a předává jim požadavky prostřednictvím volání metod kostry objektu.
• Kostra objektu: Je vygenerována kompilátorem jazyka IDL, slouží jako bázová třída odpovídající definici objektu v jazyce IDL.
• DSI (Dynamic Skeleton Interface): Dynamicky vytvořená kostra objektu, obdoba DII na straně klienta. Typickým použitím je most pro transformaci požadavků z jednoho komunikačního protokolu do jiného nebo firewall.
• GIOP (General Inter ORB Protocol): Protokol komunikace mezi různými ORB. Je definován nad běžným spojovaným transportním protokolem. Konkrétní implementace nad protokolem TCP/IP je definována jako IIOP (Internet Inter-ORB Protocol).

2.1 Tvorba aplikací v prostředí CORBA

1. Zápis rozhraní objektu v jazyce IDL
2. Vygenerování spojek a kostry kompilátorem jazyka IDL
3. Návrh klienta v implementačním jazyce
4. Implementace objektu a hlavního programu serveru

2.2 Jazyk IDL

Odvozené typy enum, struct, union, exception a typedef jsou definovány podobně jako v jazyce C, pouze typ union má doplněnu deklaraci rozlišující složky. Navíc jsou zavedeny typy array a sequence, které reprezentují pole o pevné velikosti a dynamické pole. Specializovaný typ string je definován jako sequence<char>. Nejdůležitější součástí jazyka je ovšem deklarace rozhraní (interface), která má formálně stejný tvar jako deklarace třídy v jazyce C++. Rozhraní objektu naší ukázkové aplikace může být definováno v jazyce IDL takto:

module WWW {				// deklarace modulu
   typedef string URL;			// adresa stránky
   typedef sequence<URL> URL_list;	// seznam odkazů na stránku
   exception not_found {};		// deklarace výjimky

   interface Server {			// definice rozhraní objektu
	boolean reference(in URL url, in string host) raises(not_found);
	boolean release(in URL url, in string host) raises(not_found);
	URL_list get_references(in URL url) raises(not_found);
   };
};

Doposud naznačené vlastnosti jazyka IDL nepřináší vcelku nic zásadně nového oproti jiným architekturám volání vzdálených podprogramů (RPC, DCE). Výrazným rozdílem je však princip dědičnosti při definici rozhraní. Podobně jako v jazyce C++ lze definovat nové rozhraní odvozením z existujícího a to i s využitím vícenásobné dědičnosti. Strom dědičnosti definovaný v rozhraní objektu je navíc nezávislý na stromu dědičnosti implementace objektu, takže rozhraní objektu s vícenásobnou dědičností může být implementováno bázovou třídou a naopak.

2.3 Mapování do jazyka C++

Definice rozhraní objektu vystupuje v jazyce C++ jako třída. Metody definované v rozhraní jsou pak virtuálními metodami této třídy. Práce s jednoduchými datovými typy je celkem bezproblémová. Jsou mapovány přímo na datové typy jazyka C++ definované jako typedef v modulu CORBA. Například typ boolean jazyka IDL je reprezentován typem CORBA::Boolean. Typ string je přímo mapován na řetězec jazyka C.

Složitější je ovšem mapování složených datových typů. Primární příčinou komplikací je předávání parametrů typu inout a out v metodách objektu. Pokud je parametr výstupní, musí implementační kód alokovat paměť pro uložení hodnoty parametru a tuto paměť pak musí agent ORB bezpečně uvolnit. Všechny složené typy musí proto být mapovány tak, aby bylo zajištěno správné kopírování složek při přiřazování a byla zaručeno uvolnění paměti při vyvolání destruktoru. Pro reprezentaci složených typů union a sequence vygeneruje kompilátor IDL definici třídy, která obsahuje implementaci konstruktoru, přiřazovacího operátoru a destruktoru, resp. další metody pro přístup k prvkům sequence. Mapování struktur a polí závisí na typu prvků a jeho popis se vymyká rozsahu tohoto příspěvku.

Pro bezpečnou manipulaci s ukazateli na složené typy generuje překladač IDL pro každý typ T třídu T_var a T_ptr. Třída T_var zabaluje ukazatel T * a zajišťuje správné chování při přiřazování (zrušení staré hodnoty) a opuštění rozsahu platnosti (uvolnění hodnoty na kterou ukazuje). Přímé použití T * (T_ptr) není omezeno, ale programátor musí sám zajistit explicitně rušení instancí.

Pokud použitý překladač C++ nepodporuje prostory jmen (namespace), je jméno modulu z definice rozhraní v jazyce IDL použito jako předpona mapovaných jmen. Pokud jsou prostory jmen podporovány, odpovídá jméno modulu deklaraci namespace. Pro uvedený příklad by překlad rozhraní do jazyka C++ bez namespace mohl mít tvar:

class WWW_Server: public virtual CORBA_Object {
public:
   virtual CORBA_Boolean reference(const char *url, const char *host,
			CORBA_Environment& env = _environment) const;
   virtual CORBA_Boolean release(const char* url, const char *host,
			CORBA_Environment& env = _environment) const;
   virtual WWW_URL_list *get_references(const char* url,
		 	CORBA_Environment& env = _environment) const;
  
   static WWW_Server_ptr _nil() { return &coNilObject; }
   static WWW_Server_ptr _duplicate(const WWW_Server_ptr obj);
   static WWW_Server_ptr _narrow(const CORBA_Object_ptr obj);
};

Rozhraní objektu CORBA::Object není ve skutečnosti rozhraním vzdáleného objektu, protože objekt je součástí implementace ORB. Podobná jsou rozhraní standardních objektů ORB, BOA, Request, NVList, apod. Tyto objekty jsou proto nazývány ve standardu CORBA pseudo-objekty a jejich rozhraní je definováno v jazyce pseudo-IDL (PIDL). Mapování pseudo-objektů je samozřejmě silně závislé na implementačním jazyku. Nejpřirozenější je pro jazyk C++, kde vystupují pseudo-objekty jako třídy a lze s nimi pracovat podobně jako se vzdálenými objekty.

Na operace s typy mapovanými z jazyka IDL a PIDL jsou vztažena některá omezení. Nejvíce omezení je kladeno na třídy, které reprezentují rozhraní objektu. V programu nesmí být vytvářeny instance, odkazy, ani reference těchto objektů a nesmí být z nich odvozovány nové třídy. Použití rozhraní objektu v jazyce IDL reprezentuje odkaz na objekt (object reference). Odkazy na objekty mohou být předávány v parametrech metod a mohou být také výsledkem. Mezi klientem a serverem je předávána pouze identifikace objektu, vlastní objekt se nepřenáší. Pro práci s odkazy na objekt s rozhraním A v jazyce C++ jsou vygenerovány třídy A_var a A_ptr (obvykle odpovídá A *). Tyto typy jsou podobné typům T_var a T_ptr pro práci s ukazateli na složené typy, liší se ale způsobem vytváření a kopírování objektů:

typedef WWW_Server *WWW_Server_ptr;			// A *
class WWW_Server_var {					// A_var
	WWW_Server_ptr ptr_;				// zabalený ukazatel
public:
	WWW_Server_var(): WWW_Server::_nil()) { }	// prázný odkaz
	WWW_Server_var(WWW_Server *ptr): ptr_(ptr) { }
	WWW_Server_var(const WWW_Server_var &var):	// kopie odkazu
 				ptr_(WWW_Server::_duplicate(var.ptr_)) { }
	~WWW_Server_var() { CORBA_release(ptr_); }	// uvolnění odkazu
	WWW_Server_var &operator =(WWW_Server_var &var) {	
		if (ptr_ != var.ptr_) { 			// identita?
			CORBA_release(ptr_);		// uvolnění odkazu
			ptr_ = WWW_Server::_duplicate(var.ptr_); // kopie
		}
		return *this;
	}
	...
	operator WWW_Server_ptr() const { return ptr_; }
	WWW_Server_ptr operator-> const { return ptr_; }
};

2.4 GIOP a IIOP

Pro reprezentaci složených typů jazyka IDL jsou stanovena přesná pravidla, například posloupnost začíná vždy délkou typu long a pak následují prvky posloupnosti. Při odesílání parametrů požadavku na straně klienta a dekódování parametrů na straně serveru je využito znalosti typů přenášených dat z definice rozhraní objektu v jazyce IDL. Vlastní vkládání a dekódování řeší vygenerované metody v zástupné třídě u klienta nebo kostře na straně serveru. Například vygenerovaná metoda reference() by mohla mít tvar:

CORBA_Boolean WWW_Server::reference(const char* url, const char *host,
						 CORBA_Environment& _env)
{
	CORBA_Boolean _returnValue = 0;
	Request _req(this, operations, 1); 	// inicializace zprávy
	size_t _inSize = _req.size_string(url); // délka hodnoty 1. par.
	_inSize += _req.size_string(host); 	// délka 2. parametru
	_req.initialize(_inSize, 0, _env) != C_OK) {
		return _returnValue;		// není místo pro parametry
	}
	_req.put_string(url);			// uložení 1. parametru
	_req.put_string(host);			// uložení 2. parametru
	if (_req.invoke(_env) != C_OK) return _returnValue; // aktivace
	return _req.get_boolean();		// dekódování výsledku
}

2.5 IOR

typedef unsigned long ProfileId;
const ProfileId TAG_INTERNET_IOP = 0;
struct TaggedProfile {				// profil
	ProfileId tag;				// typ profilu
	sequence <octet> profile_data;		// vlastní adresa
};
struct IOR {
	string type_id;				// typ rozhraní objektu
	sequence <TaggedProfile> profiles;	// seznam profilů (adres)
};

struct Version {
	char major;			// '1'
	char minor;			// '0'
};
struct ProfileBody {
	Version iiop_version;
	string host;			// doménové jméno nebo IP adresa
	unsigned short port;		// číslo portu
	sequence <octet>object_key;	// závisí na OA a ORB
};

IOR:010000002800000049444C3A6F6D672E6F72672F436F734E616D696E672F4E616D
696E67436F6E746578743A312E30000100000000000000540000000101000012000000
626F636F2E6665652E76757462722E637A008913340000004F422F49442B4E554D0049
444C3A6F6D672E6F72672F436F734E616D696E672F4E616D696E67436F6E746578743A
312E30003000

2.6 Klient

#include "WWW.h"		// vložení vygenerovaného hlavičkového souboru
int main(int argc, char **argv)
{
	CORBA_Environment env;

	CORBA_ORB_ptr orb = CORBA_ORB_init(argc, argv, 0, env);
	if (env.exception()) {
		cerr << "Cannot initialize ORB\n"; 
		return 1;
	}

Dalším krokem je získání odkazu na objekt, který chce klient využívat. Nejjednodušší možný postup je získání reference ze standardního vstupu programu:

	cin.getline(sior, sizeof(sior));	// přečíst řádek ze vstupu
	CORBA_Object_var obj = orb->string_to_object(sior);
	if (CORBA_is_nil(obj)) { 		// je adresa platná?
		cerr << "Bad IOR\n"; 
		return 1;
	}
	WWW_Server_var server = WWW_Server::_narrow(obj);// přetypování
	if (CORBA_is_nil(server)) {			 // je typ objektu OK?
		cerr << "bad interface imported\n"; 
		return 1;
	}
// použití vzdáleného objektu
	server->reference("/index.html", hostname, &env);
	if (env.exception()) { 
		...			// chyba při volání
	}

2.7 Služba pojmenování objektů

	CORBA_Object_ptr ns_obj;
 	try {						// získání objektu NS
		ns_obj = orb->resolve_initial_references("NameService");
	} catch(...) {
		cerr << "cannot resolve NameService" << endl;return 1;
	}
	CosNaming_NamingContext_var nc;	// přetypování na kontext
	nc = CosNaming_NamingContext::_narrow(ns_obj)

	CosNaming_Name name;			// jméno hledaného objektu
	name.length(1);				// nastavení délky posloupnosti
	name[0].id = CORBA_string_dup("WWW_Server");
	name[0].kind = CORBA_string_dup("");
	CORBA_Object_var obj;
	try {
		obj = nc->resolve(name);	// vyhledání objektu a 
	} catch(...) {				// získání reference
		cerr << "cannot resolve WWW_Server" << endl; return 1;
	}

2.8 Implementace objektu

Druhá metoda spočívá v delegování metod z kostry objektu do implementačního objektu. V tomto případě je závislost opačná, kostra objektu částečně závisí na implementační třídě (ve skutečnosti pouze na jejím jménu). Implementační třída pak nemá žádné omezení z hlediska dědičnosti. Příkladem může být implementace COOL ORB firmy Chorus. Implementační třída našeho příkladu je v obou případech podobná, u druhé metody by pouze nebyla odvozena od vygenerované třídy WWW_Server_skel (název kostry se samozřejmě u každé implementace liší):

class ServerImpl: WWW_Server_impl {
	struct sless {				// operátor less<const char *>
		bool operator() (const char *s1, const char *s2) const {
			return strcmp(s1, s2) < 0;
		}
	};
	typedef list<const char *> ref_list;	// seznam STL
	typedef map<const char *, ref_list, sless> ref_map; // asociativní pole
	ref_map references;			// seznam odkazů
public:
	virtual CORBA_Boolean reference(const char *url, 
				const char *host, CORBA_Environment &env);
	virtual CORBA_Boolean release(const char *url, const char *host,
						CORBA_Environment &env);
	virtual WWW_URL_list *get_references(const char *url, 
						CORBA_Environment &env);
};

CORBA_Boolean ServerImpl::reference(const char *url, const char *host,
							 CORBA_Environment&)
{
	host = CORBA_string_dup(host);		// kopie hodnoty 
	if (references.find(url) == references.end()) {	// není zde
		references[CORBA_string_dup(url)].push_back(host);
		return CORBA_TRUE;
	}
	references[url].push_back(host);	// přidat další odkaz
	return CORBA_FALSE;
}

Kostra objektu dekóduje přicházející požadavky inverzním postupem oproti zástupné třídě u klienta a volá metody implementační třídy:

case id_reference: 			// příklad zpracování volání metody reference
	WWW_URL url = 0;
	char *host = 0;
	_req.get_string(url);		// dekódování 1. parametru
	_req.get_string(host);		// dekódování 2. parametru
	CORBA_Boolean _rValue;		
	_rValue = reference(url, host, _env); // vyvolání implementace
// inicializace odpovědi
	if (_req.initialize(1, _env) != C_OK) return C_ENOMEM;
	_req.put_Boolean(_returnValue);	// uložení výsledku
	CORBA_string_free(url);		// uvolnění alokované hodnoty
	CORBA_string_free(host);
	return C_OK;			// návrat a odeslání odpovědi

2.9 Hlavní program serveru

int main(int argc, char **argv)	
{
	CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
	CORBA::BOA_var boa = orb->BOA_init(argc, argv);

	ServerImpl serverImpl;		// vytvoření instance objektu
	cout << orb->object_to_string(server) << endl; // výpis IOR
	boa->impl_is_ready(CORBA_ImplementationDef::_nil());
} 

Po inicializaci objektového adaptéru následuje vytvoření instance implementačního objektu a výpis jeho IOR na standardní výstup. Poslední volaná metoda signalizuje objektovému adaptéru, že implementace je připravena přijímat a zpracovávat požadavky. V daném případě se předpokládá, že program bude spuštěn před příchodem prvního požadavku. Základní objektový adaptér (BOA) by měl dle standardu CORBA podporovat tyto čtyři režimy aktivace objektů:

Sdílený server	Sdílený server je spuštěn mechanismem ORB pouze jednou. Po své inicializaci signalizuje připravenost metodou impl_is_ready() a sekvenčně zpracovává všechny požadavky na objekty implementující dané rozhraní. Je typický pro složité služby a persistentní objekty.
Trvalý server	Trvalý server je spuštěn mimo prostředí ORB, jinak je jeho funkce stejná jako u sdíleného serveru.
Nesdílený server	Nesdílený server obsluhuje pouze jeden objekt implementující dané rozhraní. Je aktivován při požadavku klienta na objekt.
Server na požadavek	Server je spuštěn při každém novém požadavku na objekt. Po zpracování požadavku běh serveru končí.

Automatické spouštění serveru při příchodu požadavku vyžaduje registraci programu implementujícího daný objekt ve skladu implementací. Při této registraci se zaznamená jméno programu, parametry pro spuštění programu, rozhraní, které implementuje, a pro nesdílený server také jméno objektu. Konkrétní postup, jak ORB vyhledá odpovídající implementační program, spustí jej a doručí mu požadavek klienta, není definován a závisí na implementaci. Základní objektový adaptér je jediný, který je definován ve standardu CORBA. Řada firem poskytuje ke svým prostředím specializované objektové adaptéry, například pro persistentní objekty v databázích, objekty s automatickou registrací, vestavěné objekty, apod. Teoreticky je možné doplnit dokonce svůj vlastní objektový adaptér, ale jeho návrh je komplikován tím, že rozhraní mezi objektovým adaptérem a ORB není standardizováno.

3. Objektově orientované služby

4. Dostupnost

Závěr

Literatura:

CORBAservices: Common Object Service Specification, OMG, 1996

ORB Portability Joint Submission, OMG, May 1997

COOL-ORB Tutorial, Chorus Systems, 1997

The Orbix Architecture, IONA Technologies, November 1996

VISIGENIC VisiBroker for C++ Programmer s Guide Version 2.0, Visigenic, 1997