CORBA. CORBA Background. (Common Object Request Broker Architecture)

Transcription

1 CORBA (Common Object Request Broker Architecture) CORBA Background CORBA is an architectural framework for distributed object management. Intended to support distributed client-server applications. Developed as an open standard by the Object Management Group (OMG) Consortium of approx. 800 companies. Basically, everybody except Microsoft. 1

2 Elements of CORBA Distributed object model CORBA objects are binary components that can reside anywhere in a network. CORBA objects (components) can be transactional, secure, lockable, and persistent. Remote clients can access server objects without knowledge of their location, platform type, operating system, or implementation language. Interfaces are specified in a neutral Interface Definition Language (IDL) C C++ Java... COBOL C C++ Java... COBOL IDL IDL IDL IDL Client Stubs Server Skeletons CORBA Object Request Broker (ORB) 2

3 Elements of CORBA--Continued The Interface Definition Language (IDL) Used to specify the contractual interfaces (APIs) of components (services). Purely declarative--no implementation details. Syntax is a subset of C++ IDL can be used to specify: signatures of attributes and methods inheritance from parent classes exceptions and events Elements of CORBA--Continued Interface Repository contains interface definitions for registered CORBA server components. Interfaces are represented in a metadata format so that they can be discovered dynamically at run time. 3

4 Elements of CORBA--Continued The Object request Broker (ORB) functions as an object bus, facilitating location independent communication among CORBA objects provides a range of distributed services the CORBA standard provides a specification for ORB services it is up to individual vendors and/or third parties to provide implementations for varius platforms/operating systems Elements of CORBA--Continued ORB Services: programming language bindings method invocations static (compile time) dynamic (run-time) interface repository local/remote transparency within a process among different processes on same machine across heterogeneous networks Internet Inter-ORB Protocol (IIOP) 4

5 Elements of CORBA--Continued ORB Services--Continued: Transaction processing security Note that CORBA supports a true object model--i.e operations are invoked on specific target objects. allows polymorphism Can encapsulate existing (non-oo) applications through IDL interfaces to function as CORBA objects A Simple View of the Object Management Architecture (OMA) Application Interfaces Domain Interfaces Common Facilities Object Request Broker Object Services 5

6 Elements of the OMA Object Services: domain-independent interfaces used by many distributed-object programs naming service--allows clients to locate objects by name only. Trading service--allow clients to find objects by their properties. Also security, transaction management, etc. Common Facilities: interfaces oriented toward end-user applications e.g. Distributed Document Component Facility(DDCF)--interchange of objects based on a document model. Elements of OMA--Continued Domain Interfaces: interfaces oriented toward specific application domains e.g. Product Data Management (PDM) enablers for manufacturing. Application Interfaces: developed specifically for a given application 6

7 CORBA OMA--A More Detailed View Application Objects Distributed Documents (Common Facilities) CORBAfacilities Information Management Systems Management Task Management Object Request Broker Naming Persistence Life Cycle Properties Concurrency Collection Security Trader Externalization Events Transactions Query Relationships Time Startup Licensing Common Object Services (CORBAServices) The Object Request Broker Architecture 7

8 Elements of the ORB Object: implementation of the operations that implement a CORBA interface. Client: Entity that invokes an operation on an object implementation ORB: Entity that transparently communicates client requests to target object implementations ORB Interface: Abstract interface that decouples applications from implementation details. Elements of the ORB--Continued IDL stubs and skeletons: serve as the glue between clients/servers and the ORB. IDL compiler provides transformations between IDL definitions and target programming languages. Dynamic Invocation Interface(DII): allows clients to directly access underlying request mechanisms provided by an ORB (without using IDL interface-specific stubs). 8

9 Elements of the ORB--Continued Dynamic Skeleton Interface DSI): Serverside analog to the DII. Object Adapter: Associates object implementations with the ORB Assists ORB with delivering requests to the object and with activating the object. Using CORBA Steps to develop a server class (for static method invocation): Define server interfaces using IDL Place interface definitions into the Interface Repository Precompile interface definitions using an IDL compiler. IDL compiler produces: Client stubs for the IDL methods server skeletons for invoking server methods a language-specific example class 9

10 Using CORBA--Continued Steps to create a server class--continued: Implement the server interface, using the example class as a template. Compile the code Register with the Implementation Repository Instantiate run-time objects (instances of the servant class) on the server Using CORBA--A Simple Example A simple server that increments a counter each time it is invoked and returns the count value to the client. 1. The IDL definition of the interface (file count.idl): module Counter { interface Count { attribute long sum; long increment( ); ; ; 2. Compile the IDL using an IDL-to-Java compiler % idl2java count.idl 10

11 CORBA Example Continued Results of IDL Compilation of count.idl (all are Java classes): Counter._countImplBase -- server side skeleton for Count. Implements the Java org.omg.corba.object interface. Counter._st.Count -- implements the client-side stub for Count.Provides data marshalling functionality. Must be included with any client application that uses Count. Counter.CounterHelper--Provides useful helper functions for Count clients Counter.CountHolder--Holds a public instance member of type Count. Used by clents and servers to pass objects of type Count as out and inout parameters inside method invocations. Counter.Count--Java interface that maps Count interface to Java. We must provide the implementation for this interface. Counter._example_Count--Example class. Contains constructors and example methods. Serves as template for implementation of Count. CORBA Example--Continued Counter.Count would look something like: Package Counter; public interface Count extends org.omg.corba.object { public int sum( ); public void sum(int _val); public int increment( ); 11

12 CORBA Example--Continued Counter._example_Count might look like the following: package Counter; public class_example_count extends Counter.CountImplBase { public _example_count(java.lang.string name) { super(name); public example_count( ) { super( ); public int increment( ) { // implement the increment method public void sum(int sum) { // implement attribute writer for sum public int sum( ) { //implement attribute reader for sum CORBA Example--Continued 3. Implement Count //CountImpl.java--the Count implementation class Count Impl extends Counter.CountImplBase { private int sum; CountImpl(String name) { //Constructor super(name); System.out.println( Count object created ); sum = 0; public int sum( ) { return sum; public void sum(int val) { sum = val; public int increment( ) { sum++; return sum; 12

13 CORBA Example--Continued 4. Implement the main server program: //CountServer.java--count server main program class CountServer { static public void main(string[ ] args) { try { // initialize the ORB (class method) org.omg.corba.orb orb = org.corba.orb.init(args, null); //initialize the BOA org.omg.corba.boa boa = orb.boa_init( ); // Create the Count Object CountImpl count = new CountImpl( MyCount ); //export the Count object to the ORB boa.obj_is_ready(count); // end of try block catch(org.omg.corba.systemexception e) { System.err.println(e); // end of main // end of CountServer CORBA Example--Continued 5. Implement the Client Side //CountClient.java--static client class CountClient { public static void main(string args[ ]) { try { //initialize the ORB org.omg.corba.orb orb = org.omg.corba.orb.init(args, null); //bind to the count object Counter.Count counter = Counter.CounterHelper.bind(orb, MyCount ); // initialize sum to zero; counter.sum((int)0); //increment 1000 times for ( int i= 0; i< 1000; i++) { counter.increment( ); System.out.println( Sum = + counter.sum( )); catch (org.omg.corba.systemexception e) { System.err.println( System Exception ); System.err.println(e); 13

14 Object Interaction Diagram--Server- Side CountServer ORB BOA ORB.init BOA.init new CountImpl obj_is_ready impl_is_ready wait for client requests Object Interaction Diagram--Client- Side CountClient ORB CountHelper CountImpl ORB_init bind Count Proxy Sum(0) increment Sum(0) increment 14

15 Another CORBA Example-Using the CORBA Name Server (from the Java Tutorial) A distributed Hello World application: Hello Client Object Reference sayhello Hello world! Hello Server Hello Servant SayHello ORB ORB Internet (IIOP) Hello World Example--Continued The IDL Server Interface Specification (filename: Hello.idl): Module HelloApp { interface Hello { string sayhello( ); ; ; IDL Compilation: %idltojava Hello.idl Files produced by idltojava compiler: _HelloImplBase.java _HelloStub.java Hello.Java HelloHelper.java HelloHelper.java All are placed in a package called HelloApp 15

16 Hello World Example--Continued The Hello.java file will look like: package HelloApp; public interface Hello extends org.omg.corba.object { String SayHello( ); The Hello World Server (HelloServer.java) import HelloApp.*; //import OMG naming service and associated exceptions import org.omg.cosnaming.*; import org.omg.cosnaming.namingcontextpackage.*; //import CORBA classes import org.omg.corba.* //Continued on next page Hello World Server (HelloServer.java)--Continued //Continued from previous page public class HelloServer { public static void main(string args[ ]) { try { ORB orb = ORB.init(args, null); //create and initialize ORB HelloServant helloref = new HelloServant //instantiate servant orb.connect(helloref) // register servant with ORB // Get root naming context org.omg.corba.object objref = orb.resolve_initial_references( Name Service); NamingContext ncref = NamingContextHelper.narrow(objRef); // Bind the object reference in naming server NameComponent nc = new NameComponent( Hello, ); NameComponent path[ ] = {nc; ncref.rebind(path, helloref); // Continued on next page 16

17 Hello Server --Continued //Continued from previous page // Wait for Client calls java.lang.object sync = new java.lang.object( ); synchronized(sync) { sync.wait( ); // end of try\ catch(exception e) { System.err.println( Error: + e); e.printstacktrace(system.out); // end of method main // end of class HelloServer class HelloServant extends _HelloImplBase { public String sayhello( ) { return \nhello world!\n ; // end of class HelloServant A Client for the Hello World Example (filename: HelloClient.java) Import HelloApp.* // import IDL-generated classes import org.omg.cosnaming.* // import OMG naming services import org.omg.corba.* //import CORBA classes public class HelloClient { public static void main(string args[ ]) { try { ORB orb = ORB.init(args, null); // Get root naming context org.omg.corba.object objref = orb.resolve_initial_references( NameService ); NamingContext ncref = NamingContextHelper.narrow(objRef); //look up server object in Naming Service NameCompoent nc = new NameComponent( Hello, ); NameComponent path[ ] = {nc; Hello helloref = HelloHelper.narrow(ncRef.resolve(path)); // Invoke the sayhello method on server and print the returned result String str = helloref.sayhello; System.out.println(str); // remainder of client code can be found in Java Tutorial 17

18 Value of CORBA for CBD Developer/system integrators can customize objects (components) for specific customer needs by inheriting appropriate CORBA services. Original Class CORBA Transaction Service CORBA Security Service Customized Subclass CORBA for CBD--Continued CORBA Business Object framework Provides a component framework for business enterprises. Several doman-specific sub-frameworks are in development--manufacturing, healthcare, finance,... Based on a variation of Model-View-Controller pattern Business Objects--encapsulate storage, metadata, concurrency and business rules of an active business entity. (Model) Business process objects--encapsulate the business logic. (Controller) Presentation objects--visual and non-visual interfaces 18

19 A CORBA Business Object Component Business Object Servers Interfaces Presentation Object Business Process Object Other Business Objects CORBABeans The Business Object Framework is being merged with JavaBeans CORBA strengths language-neutral component infrastructure. Process and location transparency (the object bus ) sophisticated object services--transactions, security, etc. JavaBeans strengths automatic introspection better event mechanisms better component packaging--jar Files Better support for Integrated Design Environments 19

20 DCOM The Microsoft Alternative to CORBA Acronym Soup COM (Component Object Model)-- Microsoft s basic component framework DCOM (Distributed COM)--extends COM to provide transparent distributed services. OLE (Object Linking Environment)-- compound document standard, based on COM ActiveX--Extended specification for OLE (sometimes used interchangeably with COM) 20

21 COM/DCOM Basics COM is not based on a true object model like that of CORBA no implementation inheritance no multiple interface inheritance no object identifiers COM object reuse is based upon object composition (containment, aggregation) rather than inheritance. DCOM Interfaces Client Pointer Pointers to functions Interface Node Pointer Internal Data vtable DCOM Object 21

22 DCOM Objects IUnknown Interface A Interface B Interface C DCOM Object A DCOM Class is identified by a unique 128 bit Class ID ( CLSID) Each interface is identified by a unique interface identifier (IID) Clients can use the IID to query a DCOM object to determine if it implements a given interface More about COM/DCOM Objects DCOM objects (instantiations of DCOM classes) do not have unique Object IDs. Instead, they obtain pointers to the interfaces. This limits DCOM s ability to support persistent objects. DCOM classes are implemented by DCOM servers which provide the necessary structure to make the objects available to clients. 22

23 DCOM Server Structure DCOM Class A DCOM Class B IClassFactory or IClassFactory2 Class A factory IClassFactory or IClassFactory2 Class B factory DCOM Client/Server Interaction Client Process Client Application In-Process Object In-Process Server Local Object Proxy COM LRPC Local Server Process Stub COM Local Object Local Server Remote Machine Remote Server Process Remote Object Proxy DCOM RPC Stub DCOM Remote Object Remote Server 23

24 DCOM Object Creation Scenario Client DCOM API IClassFactory2 CoGetClassObject CoRegisterClassObject CreateInstanceLic (or CoCreateInstanceEx) (use) Release Release CoRevokeClassObject IMyInterface Create DCOM Aggregation and Containment IUnknown(A, B, C) IUnknown(A, B, C) Outer Object A Outer Object A Inner Object B Inner Object B Inner Object C Containment/Delegation Inner Object C Aggregation 24

25 COM/DCOM IDL Different from CORBA (OMG) IDL DCOM also has a separate ODL for specification of interface metadata. Compiled by Microsoft IDL Compiler(MIDL). Produces stubs, proxies and type libraries Most Microsoft programming tools (Visual C++, Visual J++) directly generate stubs, proxies and type libraries without the need for a separate IDL. Example--A DCOM Version of the Count Server The DCOM IDL: //Count.idl [ uuid(1689cb21-2ade-11d0-892e-00a ), version(1.0) ] library Counter { [ object, uuid(1689cb21-2ade-11d0-892e-00a ), pointer_default(unique) oleautomation ] interface Icount : Iunknown { import oaidl.idl ; HRESULT set_sum([in] int val); HRESULT get_sum([out, retval] int* retval); HRESULT increment([out retval] int* retval); ; Importlib( stdole32.tlb ); [ uuid(1689cb21-2ade-11d0-892e-00a ), ] coclass Count { [default] interface ICount; ; ; 25

26 The DCOM Count Server: //Count.java--must be compiled with Microsoft java compiler import com.ms.com* // for exceptions import count.*; class Count implements ICount { private int sum; // Note: no constructor. DCOM provides default factory implemenation public int get_sum( ) throws ComException { return sum; public void set_sum(int val) throws ComException { sum = val; public int increment( ) throws ComException { sum++; return sum: A DCOM Client: //CountDCOMClient.java import count.*; class CountDCOMClient { public static void main (String args[ ]) { try { //Bind to Count object ICount counter = (ICount) new count.count( ); //Initialize sum to zero; counter.set_sum((int)0); // increment 1000 times for (int i = 0; i < 1000, i++) { counter.increment( ); system.out.println( Sum = + counter.get_sum( )); catch(exception e) { System.err.println( System Exception ); System.err.println(e); 26