Intro duction
CORBA addresses two challenges of devel-
oping distributed systems:
Object-Oriented Network
1. Making distributed application development no more
Programming
dicult than developing centralized programs
{ Easier said than done due to:
. Partial failures
Writing CORBA Applications
. Impact of latency
. Load balancing
Dr. Douglas C. Schmidt
. Event ordering
2. Providing an infrastructure to integrate application
comp onents into a distributed system
{ i.e., CORBA is an \enabling technology"
1 2
General ORB structure
CORBA Interface De nition
op(args) IDL OBJECT Language CLIENT IMPL
IDL
OMG IDL is an object-oriented interface
SKELETON
de nition language
DYNAMIC
Used to sp ecify interfaces containing metho ds and IDL ORB OBJECT { INVOCATION
ADAPTER STUBS INTERFACE attributes INTERRFACE
OBJECT
OMG IDL supp ort interface inheritance b oth sin-
REQUEST BROKER {
gle and multiple inheritance
OMG IDL is designed to map onto multiple
programming languages
Note that an ORB is a logical set of ser-
{ e.g., C, C++, Smalltalk, COBOL, Mo dula 3, DCE,
etc.
vices, rather than just a particular pro cess
or library
4 3
OMG IDL Compiler
OMG IDL Features
A OMG IDL compiler generates client stubs
OMG IDL is a sup erset of a subset of C++
and server skeletons
{ Note, it is not a complete programming language,
it only de nes interfaces
Stubs and skeletons automate the following
activities in conjunction with the ORB :
{ Client proxy factories
OMG IDL supp orts the following features:
{ Parameter marshalling/demarshalling
* modules
* interfaces
* metho ds
{ Implementation class interface generation
* attributes
* inheritance
{ Object registration and activation
*arrays
* sequence
{ Object lo cation and binding
* struct, enum, union, typedef
* consts
* exceptions
{ Per-object/p er-pro cess lters
5 6
A Sample CORBA Application
OMG IDL vs. C++
Client DATABASE App. 1: log() SERVER LOGGER
2: send
Di erences from C++ Logger request Proxy Logger
Object
* No data memb ers
* No p ointers
* No constructors or destructors
* No overloaded metho ds
int data typ e
*No SERVER rameter passing mo des
* Contains pa CLIENT NETWORK
* Unions require a tag yp e
* String t PRINTER
* Sequence typ e
* Di erent exception interface
* No templates
* No control constructs
Distributed logging facility
7 8
Server-side OMG IDL
Sp eci cation
De nes the interface of the Logger
Behavior of the Distributed
// IDL specific at io n
Logging Facility
interface Logger
{
// Types of logging message s
enum Log_Prio ri ty {
LOG_DEBUG , // Debuggi ng message s
The logging server collects, formats, and
LOG_WARNI NG , // Warning message s
outputs logging records forwarded from ap-
LOG_ERROR , // Errors
LOG_EMERG // A panic conditi on , normally broadcas t
plications residing throughout a network or
};
internetwork
exception Disconn ec te d {};
struct Log_Reco rd {
Log_Prior it y type; // Type of logging record.
long host_add r; // IP address of the sender.
An application interacts with the server log-
long time; // Time logging record generate d.
long pid; // Process ID of app. generati ng the record.
ger via a CORBA interface
sequence< ch ar > msg_data ; // Logging record data.
};
// Transmit a Log_Rec or d to the logging server
void log in Log_Reco rd log_rec raises Disconn ec te d ;
attribute boolean verbose ; // Use verbose formatti ng
};
10 9
Creating Server-side
OMG IDL Mapping Rules
Implementation s
The CORBA sp eci cation de nes mappings
from CORBA IDL to various programming
Running the Logger interface de nition through
languages
the IDL compiler generates a client stub and
a server skeleton
{ e.g., C++, C, Smalltalk
{ The client stub acts as a proxy and handles object
binding and parameter marshalling
Mapping OMG IDL to C++
{ The server skeleton handles object registration,
activation, and parameter demarshalling
{ Each interface is mapp ed to a nested C++ class
{ Each op eration is mapp ed to a C++ metho d with
appropriate parameters
CORBA de nes two techniques for gener-
ating server skeletons:
{ Each read/write attribute is mapp ed to a pair of
get/set metho ds
1. Inheritance-based implementations e.g., Orbix BOAImpl
. A read-only attribute is only mapp ed to a single
2. Object comp osition-based implemenations e.g.,
get metho d
Orbix TIE
12 11
Inheritance-bas ed
Object Comp osition -b ased
Implementation s
Implementation s
In Orbix, inheritance-based implementations
are supp orted by the BOAImpl approach:
In Orbix, object comp osition-based imple-
mentations are supp orted by the TIE ap-
{ The drawback with this approach is that the imple-
mentation must inherit from the generated skele-
proach:
ton
// Note, there is no use of inheritance and
class Logger_i
// methods need not be virtual!
// Note the use of inheritance from automatically
class Logger_i
// generated class LoggerBOAImpl
{
: public virtual LoggerBOAImpl
public:
{
// Start with verbose mode enabled.
public:
Logger_i bool verb = true : verbose_ verb {}
Logger_i bool verb : verbose_ verb {}
void log const Log_Record &log_rec,
virtual void log const Log_Record &log_rec,
CORBA::Environment & ;
CORBA::Environment & ;
bool verbose void,
virtual bool verbose void,
CORBA::Environment & ;
CORBA::Environment & ;
void verbose bool enable,
virtual void verbose bool enable,
CORBA::Environment & ;
CORBA::Environment & ;
private:
private:
bool verbose_;
bool verbose_;
};
};
13 14
Writing the Server-side Metho d
De nitions
Object Comp osition -b ased
Implementati on s cont'd
Using either the BOAImpl or the TIE ap-
proach, a develop er then writes C++ de -
Orbix provides a set of macros that tie the
nitions for the metho ds in class Logger i:
Logger interface together with the Logger i
void Logger_i::log const Log_Record &log_rec,
implementation
CORBA::Environment &
{
// Formatting and outputting the contents
DEF_TIE Logger, Logger_i ;
// of log_rec omitted...
Logger_i *log = new Logger_i;
}
Logger *logger = new TIE Logger, Logger_i log ;
bool Logger_i::verbose void,
CORBA::Environment & ;
{
This scheme works by placing a p ointer to
return this->verbose_;
the implementation object within the TIE
}
class and then delegating metho d calls to
void Logger_i::verbose bool enabled,
the implementation object
CORBA::Environment & ;
{
this->verbose_ = enabled;
}
16 15
Exception Handling
Writing Main Server Program
The preceeding example illustrated how CORBA
The main program for the logging server
uses C++ exception handling to propagate
errors.
lo oks like:
{ However, many C++ compilers don't supp ort ex-
// Shared activation
ceptions yet
int
main void
{ Therefore, CORBA implementations provide an
{
alternative mechanism for handling errors
// BOAImpl instance.
Logger_i logger ;
// Shared activat io n
int main void {
try {
// Start with verbose mode enabled
// Will block forever waiting for incoming
Logger_ i logger true ;
// invocations and dispatching method callbacks
TRY {
CORBA::Orbix.impl_is_ready "Logger" ;
// Will block forever waiting for incoming
} catch ... {
// invocati on s and dispatc hi ng method callback s
cerr << "server failed\n";
CORBA:: Or bi x. im pl _is _r ea dy "logge r" , IT_X ;
return 1;
} CATCHAN Y {
cerr << "server failed due to " << IT_X << endl;
}
} ENDTRY;
cout << "server terminating\n";
cout << "server terminat in g\ n" ;
return 0;
return 0;
}
}
18 17
Object Activation
Generated Client-si de Stubs
If the service isn't running when a client in-
The OMG IDL compiler automatically gen-
vokes a metho d on an object it manages,
erates a client-side stub used to de ne \proxy
the ORB will automatically start the service
objects," e.g.,
typedef Logger *LoggerRef; // Generated by Orbix
Services must be registered with the ORB,
e.g.,
class Logger
// Base class for all IDL interfaces...
putit Logger /usr/svcs/Logger/logger.exe
: public virtual CORBA::Object
{
public:
Service s may b e installed on any machine
static Logger *_bind /* Many binding formats */ ;
virtual void log const Log_Record &log_rec,
CORBA::Environment & ;
virtual void verbose bool enabled,
CORBA::Environment & ;
Clients may bind to a service by using a
virtual bool verbose void,
CORBA::Environment & ;
lo cation broker or by explicitly naming the
};
server
20 19
Client-sid e Example
A client programmer writes the following:
Binding a Client to a Target
int
Object
main void
{
LoggerRef logger;
Steps for binding a client to a target object
Log_Record log_rec;
1. A CORBA client requestor obtains an \object
logger = Logger::_bind ; // Bind to any logger.
reference" from a server
// Initialize the log_record
log_rec.type = Logger::LOG_DEBUG;
{ May use a name service or lo cator service
log_rec.time = ::time 0 ;
log_rec.host_addr = // ...
2. This object reference serves as a lo cal proxy for
// ...
the remote target object
try {
{ Object references may b e passed as parameters
logger->verbose false ; // Disable verbose logging.
to other remote objects
logger->log log_rec ; // Xmit logging record.
}
catch Logger::Disconnected {
3. The client may then invoke metho ds on its proxy
cerr << "logger disconnected" << endl;
}
catch ... { /* ... */ }
return 0;
}
21 22
Summary
CORBA helps to reduce the complexity of
developing distributed applications
{ However, there are many hard issues remaining:: :
Other OMG do cuments e.g., COSS sp ec-
ify higher level
{ e.g., transactions, events, naming, security, etc. 23