[omniORB] Communication between a OmniServer and JavaClient using NamingService

[Rajesh Khan]

Skipped content of type multipart/alternative-------------- next part --------------
import java.io.Console;

import HelloApp.*;
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
import org.omg.CORBA.*;

public class HelloClient
{
  static Hello helloImpl;

  public static void main(String args[])
    {
      try{
        // create and initialize the ORB

	    ORB orb = ORB.init(args, null);

        // get the root naming context
        org.omg.CORBA.Object objRef = 
	    orb.resolve_initial_references("NameService");
        // Use NamingContextExt instead of NamingContext. This is 
        // part of the Interoperable naming Service.  
        NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);
 
        // resolve the Object Reference in Naming
        String name = "Hello";
        helloImpl = HelloHelper.narrow(ncRef.resolve_str(name));

        
        System.out.println("Obtained a handle on server object: " + helloImpl);
        System.out.println(helloImpl.sayHello());
        
       // System.console().readLine();
       // helloImpl.shutdown();

	} catch (Exception e) {
          System.out.println("ERROR : " + e) ;
	  e.printStackTrace(System.out);
	  }
    }

}
-------------- next part --------------
//Creates the object and passes it to the client developed in C++

#include "hello.hh"

#ifdef HAVE_STD
#  include <iostream>
using namespace std;
#else
#  include <iostream.h>
#endif

static CORBA::Boolean bindObjectToName(CORBA::ORB_ptr, CORBA::Object_ptr);


class CustObj_implimentation : public POA_HelloApp::Hello
{
public:
	virtual char* sayHello();
	virtual void shutdown();
};


//Provide a body
char* CustObj_implimentation::sayHello() throw (CORBA::SystemException)
{
	//Initialize the object as usual
	return "Hello Java Server";
}

void CustObj_implimentation::shutdown() throw (CORBA::SystemException)
{
	std::cout << "Function called";
}

//////////////////////////////////////////////////////////////////////

int	main(int argc, char **argv)
{
	try {
		CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);

		CORBA::Object_var obj = orb->resolve_initial_references("RootPOA");
		PortableServer::POA_var poa = PortableServer::POA::_narrow(obj); //returns reference

		CustObj_implimentation *obj_ptr = new CustObj_implimentation();
		PortableServer::ObjectId_var myechoid = poa->activate_object(obj_ptr);

		// Obtain a reference to the object, and register it in
		obj = obj_ptr->_this();


		//------------------------------------------------------------------------------------------------
		CORBA::String_var x;
		x = orb->object_to_string(obj);
		cout << x << endl;

		if( !bindObjectToName(orb, obj) )
			return 1;
		//------------------------------------------------------------------------------------------------

		obj_ptr->_remove_ref();

		PortableServer::POAManager_var pman = poa->the_POAManager();
		pman->activate();

		orb->run();
	}
	catch(CORBA::SystemException& ex) {
		cerr << "Caught CORBA::" << ex._name() << endl;
	}
	catch(CORBA::Exception& ex) {
		cerr << "Caught CORBA::Exception: " << ex._name() << endl;
	}
	catch(omniORB::fatalException& fe) {
		cerr << "Caught omniORB::fatalException:" << endl;
		cerr << "  file: " << fe.file() << endl;
		cerr << "  line: " << fe.line() << endl;
		cerr << "  mesg: " << fe.errmsg() << endl;
	}
	std::cin.get();
	return 0;
}

//////////////////////////////////////////////////////////////////////

static CORBA::Boolean bindObjectToName(CORBA::ORB_ptr orb, CORBA::Object_ptr objref)
{
	CosNaming::NamingContext_var rootContext;

	try 
	{
		// Obtain a reference to the root context of the Name service:
		CORBA::Object_var obj;
		obj = orb->resolve_initial_references("NameService");

		// Narrow the reference returned.
		rootContext = CosNaming::NamingContext::_narrow(obj);
		if( CORBA::is_nil(rootContext) ) 
		{
			cerr << "Failed to narrow the root naming context." << endl;
			std::cin.get();
			return 0;
		}
	
		// Bind a context called "test" to the root context:
		CosNaming::Name contextName;

		contextName.length(1);
		contextName[0].id   = (const char*) "Hello";       // string copied
		//contextName[0].kind = (const char*) "my_context"; // string copied
		

		CosNaming::NamingContext_var testContext;
			// Bind the context to root.
		//testContext = rootContext->bind_new_context(contextName);
		rootContext->bind(contextName,objref);

	}
	catch(CORBA::SystemException& ex) 
	{
		cerr << "Caught a CORBA::" << ex._name()
			<< " while using the naming service." << endl;
		std::cin.get();
		return 0;
	}

	return 1;
}