Quick RTCORBA - Client - Server - HOWTO (ACE/TAO)
=================================================

1.) define Interface (hosted Objects)

create file interface.idl:

----// interface.idl //----------------------------------------

module benchmark{

	exception invalidRequest{};

	struct dataStruct{
		string data;
		short  valPort1;
		short  valPort2;
		short  valPort3;
	};

	interface Put{
		void connect() raises(invalidRequest);
		void onePort(in short portNo, in short value) raises(invalidRequest);
		void allPorts( in short valPort1,
			       in short valPort2,
			       in short valPort3) raises(invalidRequest);

		void dataAndPorts( in dataStruct data) raises(invalidRequest);
	};
};

----------------------------------------------------------------------

2.) generate implementation files

tao_idl -GI interface.idl

3.) rename implementation files

mv interfaceI.h interface_i.h
mv interfaceI.cpp interface_i.cpp

4.) change interfaceI.h include in interface_i.cpp in interface_i.h

5.) implement functionality of hosted objects into interface_i.cpp

6.) write RTCORBA Server

----// Server.cpp //----------------------------------------------------

include "interface_i.h"

#include "orbsvcs/CosNamingC.h"
#include <tao/RTCORBA/RTCORBA.h>

#include <iostream>

int main(int argc, char* argv[]){
    try{
    	// initialize ORB
        CORBA::ORB_var orb = CORBA::ORB_init(argc, argv, "ServerORB");
        std::cout<<"ORB initialized"<<std::endl;

        // access RT Extensions
        CORBA::Object_var rtorb = orb->resolve_initial_references("RTORB");
        RTCORBA::RTORB_var rtORB = RTCORBA::RTORB::_narrow(rtorb);
        std::cout<<"RT Extensions OK"<<std::endl;

        // obtain rootPOA
        CORBA::Object_var poa = orb->resolve_initial_references("RootPOA");
        PortableServer::POA_var rootPOA = PortableServer::POA::_narrow(poa.in());

        // activate POA Manager
        PortableServer::POAManager_var poaManager = rootPOA->the_POAManager();
        poaManager->activate();
        std::cout<<"rootPOA OK"<<std::endl;

        // create Policy
        CORBA::PolicyList benchPolicy(1);
        benchPolicy.length(1);
        benchPolicy[0] = rtORB->create_priority_model_policy(RTCORBA::CLIENT_PROPAGATED, 9879 /*Priority*/ );

         // create ObjectAdapter, assign Policy
         PortableServer::POA_var benchPOA = rootPOA->create_POA("benchPOA", poaManager.in(), benchPolicy);
         std::cout<<"Policy assigned"<<std::endl;

         // create the servant
         benchmark_Put_i bench_i;

         // activate servant
         PortableServer::ObjectId_var objectID = benchPOA->activate_object(&bench_i);
         CORBA::Object_var benchObj = benchPOA->id_to_reference(objectID.in());
         CORBA::String_var ior = orb->object_to_string(benchObj.in());
         std::cout<<"Servant activated"<<std::endl;

         // NameService
         CORBA::Object_var  namingObject = orb->resolve_initial_references("NameService");
         CosNaming::NamingContext_var namingContext = CosNaming::NamingContext::_narrow(namingObject.in());
         CosNaming::Name name(1);
         name.length(1);
         name[0].id = CORBA::string_dup("Receiver");
         namingContext->bind(name, benchObj.in());
         std::cout<<"Bound Receiver to NameService"<<std::endl;

         // start ORB
         orb->run();
         std::cout<<"ORB ready"<<std::endl;

         //destroy ORB
         rootPOA->destroy(1,1);
         orb->destroy();
    }catch(CORBA::Exception &any){
        std::cout<<"Exception: "<<any<<std::endl;
    }
    return 0;
}

---------------------------------------------------------------------------

7.) write RTCORBA Client

---// Client.cpp //--------------------------------------------------------

#include <iostream>
#include "interfaceC.h"
#include "orbsvcs/CosNamingC.h"
#include <tao/RTCORBA/RTCORBA.h>

#include "cpx.h"

benchmark::Put_var put;
CPX cpx;

int main(int argc, char* argv[]){

   try{
        // initialize ORB
        CORBA::ORB_var orb = CORBA::ORB_init(argc, argv, "ClientORB");
        std::cout<<"ORB ok"<<std::endl;

        // get RTORB
        CORBA::Object_var rtorb = orb->resolve_initial_references("RTORB");
        RTCORBA::RTORB_var rtORB = RTCORBA::RTORB::_narrow(rtorb.in());
        std::cout<<"RTORB ok"<<std::endl;

        // NamingService
        CORBA::Object_var namingObject = orb->resolve_initial_references("NameService");
        CosNaming::NamingContext_var namingContext = CosNaming::NamingContext::_narrow(namingObject.in());
        std::cout<<"NamingService ok"<<std::endl;

        CosNaming::Name name(1);
        name.length(1);

        name[0].id = CORBA::string_dup("Receiver");

        // receive Object
        CORBA::Object_var benchObj = namingContext->resolve(name);
        put = benchmark::Put::_narrow(benchObj.in());
        std::cout<<"TransferOjekt ok"<<std::endl;

        // rtCurrent set priority
        CORBA::Object_var rtCurrentObj = orb->resolve_initial_references("RTCurrent");
        RTCORBA::Current_var rtCurrent = RTCORBA::Current::_narrow(rtCurrentObj.in());
        rtCurrent->the_priority(RTCORBA::maxPriority);
        std::cout<<"PriorityChange ok"<<std::endl;

        // Input auf Interface schreiben (use Object hosted by Server)
        put->connect();
        put->allPorts(0, 0, 0);

        // destroy ORB
        orb->destroy();

        }catch(CORBA::Exception &any){
                std::cout<<"Exception occured: "<<any<<std::endl;
        }
        return 0;
}

--------------------------------------------------------------------------

8.) define MakeProjectCreator file

---// project.mpc //------------------------------------------------------

project(Server): rt_server, naming {
        requires += exceptions
        Source_Files {
                cpx.cpp
                interfaceI.cpp
                Server.cpp
        }
        Header_Files {
                cpx.h
        }
}

project(Client): rt_client, naming {
        requires += exceptions
        Source_Files {
                cpx.cpp
                interfaceC.cpp
                Client.cpp
        }
        Header_Files {
                cpx.h
        }
}

----------------------------------------------------------------------------

9.) generate GNUMakefiles

mpc.pl -type gnuace project.mpc

10.) build Client & Server

make -f GNUMakefile_Client && make -f GNUMakefile_Server

11.) start NamingService

$ACE_ROOT/TAO/orbsvcs/Naming_Service/Naming_Service -m1 orbendpoint localhost:1234

12.) start Server

./Server

13.) start Client

./Client