1. CORBA Programming: Presentation of a simple “Hello World” CORBA client and server application

2. Only small steps in CORBA programming – much complexity
Outline
CORBA programming
Code examples
We will make a very small CORBA application with a Java server, Java Client & C++ client application
In Java (SUN ORB)
What gets generated?
What files do we need to write (client + server)?
In Orbacus C++ ORB
We make a client
Only small steps in CORBA programming – much complexity

3. “Hello World” CORBA Example with file IOR
Development PC
User activa-
tes client
Server returns “Hello World !“
Client app.
Server app.
CORBA
Java / C++
Hello World
Client
Java
Server
TCP/IP
Network

4. Who’s doing what? Some code will get generated by the IDL compiler
Some code we will need to implement ourselves
Staring with the IDL file

5. IDL Interface of Hello Servant
module HelloApp
interface Hello { string sayHello(); };

6. IDL Compiler Example Java
Hello.java (Both Client & Server)
contains the Java version of the IDL interface.
HelloOperations.java
contains the methods – here only sayHello(). All the operations in the IDL interface are placed in the operations file.
_HelloStub.java
is the client stub.
HelloPOA.java
is the skeleton class you should extend from. It implements dynamic invocation functions.
HelloHelper.java (Both Client & Server)
provides auxiliary functionality, notably the narrow() method required to cast CORBA object references to their proper types.
HelloHolder.java
Whenever the IDL type is an out or an inout parameter, the Holder class is used.
Hello.idl file
Java IDL Compiler -IDLJ
Generates
Input
What gets generated
by the IDL Compiler

7. Extract from _HelloStub.java
What are we looking at?

8. Extract from HelloHelper.java
Discuss with your neighbor 1 min. what is this? what is it used for?

9. Discuss with your neighbor 1 min. what is this? what is used for?
Extract from HelloPOA
More on this later
Discuss with your neighbor 1 min. what is this? what is used for?

10. HelloServant The server object (Part 1) Implemented manually
// HelloServer.java, stringified object reference version
// Stefan Wagner, 2003
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
import org.omg.CORBA.*;
import org.omg.PortableServer.*;
import org.omg.PortableServer.POA;
import HelloApp.*;
//This is the servant - implementing the methods from the IDL
class HelloServant extends HelloPOA {
private ORB orb;
public HelloServant(ORB orb) {
this.orb = orb; }
public String sayHello()
return "\nHello world !!\n";
HelloServant
The server object
(Part 1)
Implemented manually
By extending from HelloPOA we may communicate with ORB
Constructor taking ORB as a parameter (from HelloPOA)
The CORBA operation implemented

11. HelloServant The server object (Part 2)
//This is the HelloServer - the server running the HelloServant - Servant
public class HelloServer {
public static void main(String args[]) {
try{ // create and initialize the ORB
org.omg.CORBA.ORB orb = org.omg.CORBA.ORB.init(args, null);
// create servant and register it with the ORB
HelloServant helloRef = new HelloServant(orb);
// get reference to rootpoa and activate the POAManager
POA rootpoa = POAHelper.narrow(orb.resolve_initial_references("RootPOA"));
rootpoa.the_POAManager().activate();
// get object reference from the servant
org.omg.CORBA.Object ref = rootpoa.servant_to_reference(helloRef);
Hello href = HelloHelper.narrow(ref);
// stringify the helloRef and dump it in a file
String oir = orb.object_to_string(href);
java.io.PrintWriter out = new java.io.PrintWriter(new java.io.FileOutputStream("object.ref"));
out.println(oir);
out.close();
// wait for invocations from clients
orb.run();
} catch (Exception e) { System.err.println("ERROR: " + e); e.printStackTrace(System.out); } } }
HelloServant
The server object
(Part 2)
Init ORB and register servant with ORB
Activate rootPOA
The POA produces the reference
Narrow the call (CORBA type cast + IDL type check)
Object reference
”stringified” and
Sent to file object.ref
Start the orb server process

12. Narrow the call (CORBA type cast + IDL type check)
// HelloClientSOR.java, stringified object reference version
import java.io.*;
import org.omg.CORBA.*;
import HelloApp.HelloHelper;
import HelloApp.*;
public class HelloClientSOR {
public static void main(String args[])
try {
// create and initialize the ORB
org.omg.CORBA.ORB orb = org.omg.CORBA.ORB.init(args, null);
// Get the stringified object reference and destringify it.
java.io.BufferedReader in = new java.io.BufferedReader(new java.io.FileReader("object.ref"));
String ref = in.readLine();
org.omg.CORBA.Object obj = orb.string_to_object(ref) ;
Hello helloRef = HelloHelper.narrow(obj);
// call the Hello server object and print results
String Hello = helloRef.sayHello();
System.out.println(Hello);
} catch (Exception e) { System.out.println("ERROR : " + e) ; e.printStackTrace(System.out); } }
HelloClientSOR
The Client program
Implemented manually
Init ORB
Object reference
Read from file
Narrow the call (CORBA type cast + IDL type check)
Call via Proxy

13. What is this object.ref file?
IOR: Interoperable Object Reference
Includes info on: Repository ID (standard), Endpoint Info (standard) - including IP and port number, Object Key (proprietary)
Can be written into a file
Not really nice with a file-based reference – or what?
May employ a naming service instead
This we shall look at later
File-based may be necessary due to firewall problems
Possible to use a HTTP or FTP server for distributing the references
IOR: c3a48656c6c6f f48656c6c6f3a312e c e e e312e b afabcb a80a a

14. Call run method (see next slide)
#include <OB/CORBA.h>
#include <Hello.h>
#include <fstream.h>
int run(CORBA::ORB_ptr);
int main(int argc, char* argv[])
{ int status = EXIT_SUCCESS;
CORBA::ORB_var orb;
try {
orb = CORBA::ORB_init(argc, argv);
status = run(orb);
} catch (const CORBA::Exception&) {
status = EXIT_FAILURE; }
if(!CORBA::is_nil(orb))
{ try {
orb -> destroy();
} catch(const CORBA::Exception&) { status = EXIT_FAILURE; }
return status;
HelloCorba
C++ Client
Part 1
Implemented manually
Init ORB
Call run method (see next slide)
Destroy ORB

15. HelloCorba C++ Client Part 2…
int run(CORBA::ORB_ptr orb) {
const char* refFile = "object.ref";
ifstream in(refFile);
char s[2048];
in >> s;
CORBA::Object_var obj = orb -> string_to_object(s);
HelloApp::Hello_var hello = HelloApp::Hello::_narrow(obj);
cout << hello->sayHello() << endl;
return 0; }
HelloCorba
C++ Client
Part 2
Object reference
Read from file
HelloApp::Hello_var smartpointer type
Generated by IDL compiler + Hello
Narrow the call (CORBA type cast)
to the Hello_var smartpointer
(helper + memory management)
Call method via Proxy and print result
Read more on Smartpointer types in OOMI-1 chapter 4