The document discusses CORBA (Common Object Request Broker Architecture), which is a standard that allows software components written in different languages and running on different operating systems to communicate. CORBA uses IDL (Interface Definition Language) to define interfaces, and an ORB (Object Request Broker) to handle requests and responses between clients and servers. Key components of CORBA include IDL, GIOP/IIOP protocols, stubs/skeletons, the object adapter, and core services like the naming service.

1. CORBA concepts & CORBA
architecture

3. • CORBA is an abbreviation for Common
Object Request Broker Architecture
• Object Management Group, (OMG) formed
in 1989
• The Common Object Request Broker
Architecture (CORBA) is a standard
defined by the Object Management
Group (OMG) that enables software
components written in multiple
computer languages and running on
multiple computers to work together
(i.e., it supports multiple platforms).

4.  Focus on integration of systems
and applications across
heterogeneous platforms
 Thus CORBA allows applications
and their objects to communicate
with each other no matter where
they are and or who designed
them!!

5. • CORBA is just a specification for
creating and using distributed
objects
• CORBA is not a programming
language.
• CORBA is a standard (not a
product!)
• Allows objects to transparently
make requests and receive
responses

6. 6
Components Of CORBA
The main components of CORBA’s RMI
framework are:
1.An interface definition language known
as IDL.
2.An architecture.
3.The General Inter-ORB protocol (GIOP)
defines
• specifies formats for the messages
in a request-reply protocol.
• including messages for enquiring
about the location of an object, for
cancelling requests and for reporting
errors. •

7. 4.The Internet Inter-ORB protocol
(IIOP) defines a standard form for
remote object references.
• IIOP is GIOP implemented in
TCP/IP
• CORBA services - generic services
useful in distributed applications e.g.
Naming Service, Event Service.

8. CORBA Architecture
• The CORBA architecture is based on
the object model.
• A CORBA-based system is a collection
of objects that isolates the requestors
of services (clients) from the providers
of services(servers) by a well-defined
encapsulating interface.
• CORBA is composed of five major
components: ORB, IDL, dynamic
invocation interface(DII), interface
repositories (IR), and object adapters
(OA).

9. 9
CORBA Architecture
client server
proxy
or dynamic invocation
implementation
repository object
adapter
ORBORB
skeleton
or dynamic skeleton
client
program
interface
repository
Request
Reply
corecorefor A
Servant
A
• The CORBA architecture is designed to allow clients to
invoke methods in CORBA objects
clients and objects can be implemented in a variety
of programming languages
it has the following additional components
• object adapter, implementation repository and
interface repository
ORB core
The role of the ORB core is similar to that of the
communication module
In addition, an ORB core provides an interface that includes
the following:
- operations enabling it to be started and stopped;
- operations to convert between remote object references
and strings;
- operations to provide argument lists for requests using
dynamic invocation.
Dynamic invocation interface
In some applications (e.g. browsers), a client
without the appropriate proxy class may need to
invoke a method in a remote object.
CORBA does not allow classes for proxies to be
downloaded at run time as in Java RMI.
The dynamic invocation interface is CORBA’s
alternative. (we will discuss it later with the
Interface Repository)
Object adapter
–an object adapter bridges the gap between
CORBA objects with IDL interfaces and
the programming language interfaces of the
corresponding servant classes.
–it does the work of the remote reference and
despatcher modules
Skeletons
–skeleton classes (for OO languages) are
generated in the language of the server by an
IDL compiler.
–remote method invocations are dispatched via
the appropriate skeleton to a particular servant,
–the skeleton unmarshals the arguments in
request messages and marshals exceptions and
results in reply messages.
Client stubs/proxies
– these are in the client language.
– an IDL compiler for the client language uses an IDL
interface to generate one of the following:
for object-oriented languages the class of a proxy
for procedural languages a set of stub procedures.
– as before, the client stubs/proxies marshal the
arguments in invocation requests and unmarshal
exceptions and results in replies.
Implementation repository
activates registered servers on demand and locates
running servers
uses the object adapter name to register and
activate servers.
Interface repository
the interface repository provides information
about registered IDL interfaces to clients and
servers that require it.
•

10. 10
CORBA RMI
• CORBA RMI is a multi-language RMI
system.
• The term CORBA object is used to refer
to remote objects.
a CORBA object implements an IDL
interface, has a remote object
reference and its methods can be
invoked remotely.
•

11. • A CORBA object can be implemented
by a language without classes.
the class concept does not exist in
CORBA.
therefore classes cannot be defined
in CORBA IDL, which means that
instances of classes cannot be
passed as arguments

12. Object Request Broker (ORB)
• For objects to communicate across
the network, they need a
communication infrastructure named
Object Request Broker (ORB).
• Both client and object implementation
are isolated from the ORB by an IDL
interface.

13. • Clients see only the object’s interface,
never the implementation.
• To communicate, the request does
not pass directly from client to object
implementation,instead every request
is passed to the client’s local ORB,
which manages it.

14. Object Request Broker (ORB)

15. CORBA Objects
• It is important to note that CORBA
objects differ from typical
programming objects in three ways:
• CORBA objects can run on any
platform.
• CORBA objects can be located
anywhere on the network.
• CORBA objects can be written in any
language that has IDL mapping.

16. CORBA works with interfaces
• All CORBA Objects are encapsulated
• Objects are accessible through interface
only.
• Separation of interfaces and
implementation enables multiple
implementations for one interface

17. Interface description language
(IDL)
• IDL is a specification language used
to describe a software component's
interface
• IDLs describe an interface in a
language-neutral way, enabling
communication between software
components that do not share a
language.
• for ex., between components written
in C++ and components written in
Java

18. Interface description language
(IDL)
• IDLs are commonly used in remote
procedure call software.
• In these cases the machines at either
end of the "link" may be using
different operating systems and
computer languages.
• IDLs offer a bridge between the two
different systems.

19. IDL Compiler

20. 1.Naming Service
-It is a binder that provides methods including
a) rebind for servers to register the remote
object references of CORBA objects by name
(e.g. rebind (path, Object)
b) resolve for clients to look them up by
name.these methods belong to an interface
called NamingContext
2.Transaction service and concurrency control
service
-TS provides flat or nested transactions
-CCS provides locking of CORBA objects
3.Persistent object service:
-for storing the state of CORBA objects in a
passive form and retrieving it

21. 21
•
4)Event Service and Notification Service:
-in ES suppliers and consumers
communicate via an event channel
-NS extends this to allow filtering and
typed events
5)Security service:
-authentication of principals and access
control of CORBA objects with policies
-auditing by servers, facilities for non-
repudiation
6)Trading service:
-allows CORBA objects to be located by
attribute

22. Advantages of CORBA
• Object Location Transparency:-
The client does not need to know where an object
is physically located. An object can either be
linked into the client, run in a different process on
the same machine, or run in a server on the other
side of the planet.
• Server Transparency:-
The client is, as far as the programming model is
concerned, ignorant of the existence of servers.
The client does not know (and cannot find out)
which server hosts a particular object, and does
not care whether the server is running at the time
the client invokes a request.

23. Advantages of CORBA
• Language Transparency :-
Client and server can be written in different
languages. A server can be implemented in a
different language without clients being aware
of this.
• Implementation Transparency :-
The client is unaware of how objects are
implemented. A server can use ordinary flat
files as its persistent store today and use an
OO database tomorrow, without clients ever
noticing a difference (other than performance).

24. Advantages of CORBA
• Architecture Transparency :-
The architectures are hidden from both clients and
servers. A client can communicate with a server
with different alignment restrictions.
• Operating System Transparency:-
Client and server are unaffected by each other's
operating system. In addition, source code does
not change if you need to port the source from one
operating system to another

25. Advantages of CORBA
• Protocol Transparency :-
Clients and servers do not care about
the data link and transport layer. They
can communicate via token ring,
Ethernet, wireless links, ATM
(Asynchronous Transfer Mode), or any
number of other networking
technologies.