int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
long retryCount = 0;
const ACE_TCHAR *ior_arg = ACE_TEXT("manager.ior");
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("r:o:"));
int c;
while ((c = get_opts ()) != -1)
{
switch (c)
{
case 'r':
retryCount = ACE_OS::atoi(get_opts.opt_arg());
break;
case 'o':
ior_arg = get_opts.opt_arg();
break;
case '?':
default:
cout << "Usage: " << argv[0] << " [-r retryCount]"
<< " [-o iorfile]" << endl;
break;
}
}
CORBA::Object_var obj = orb->resolve_initial_references("RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow(obj.in());
PortableServer::POAManager_var mgr = poa->the_POAManager();
Manager_i servant(retryCount);
PortableServer::ObjectId_var oid = poa->activate_object(&servant);
obj = poa->id_to_reference(oid.in());
{
CORBA::String_var ior = orb->object_to_string(obj.in());
ofstream iorFile(ACE_TEXT_ALWAYS_CHAR(ior_arg));
iorFile << ior.in() << endl;
}
cout << "IMR Test Manager activated (servers retry = " << retryCount << ")." << endl;
mgr->activate();
orb->run();
poa->destroy(1, 1);
orb->destroy();
return 0;
}
catch (const CORBA::Exception& ex)
{
cerr << "Manager: " << ex << endl;
}
return 1;
}
void
test_i::destroy_poa (void)
{
PortableServer::POA_var poa = this->_default_POA ();
CORBA::Boolean etherealize_objects = 1;
CORBA::Boolean wait_for_completion = 0;
poa->destroy (etherealize_objects,
wait_for_completion);
}
void
ImR_Locator_i::destroy_poa (const ACE_CString &poa_name)
{
PortableServer::POA_var poa = findPOA (poa_name.c_str());
if (! CORBA::is_nil (poa.in ()))
{
bool etherealize = true;
bool wait = false;
poa->destroy (etherealize, wait);
}
}
int ACE_TMAIN (int argc, ACE_TCHAR* argv[])
{
try {
// First initialize the ORB, that will remove some arguments...
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
poa->the_POAManager ();
poa_manager->activate ();
// Create the servant
Quoter_Stock_Factory_i stock_factory_i;
// Activate it to obtain the object reference
Quoter::Stock_Factory_var stock_factory =
stock_factory_i._this ();
// Get the Naming Context reference
CORBA::Object_var naming_context_object =
orb->resolve_initial_references ("NameService");
CosNaming::NamingContext_var naming_context =
CosNaming::NamingContext::_narrow (naming_context_object.in ());
// Create and initialize the name.
CosNaming::Name name (1);
name.length (1);
name[0].id = CORBA::string_dup ("Stock_Factory");
// Bind the object
naming_context->bind (name, stock_factory.in ());
orb->run ();
// Destroy the POA, waiting until the destruction terminates
poa->destroy (1, 1);
orb->destroy ();
}
catch (CORBA::Exception &) {
cerr << "CORBA exception raised!" << endl;
}
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR* argv[])
{
try {
// First initialize the ORB, that will remove some arguments...
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
poa->the_POAManager ();
poa_manager->activate ();
CORBA::Object_var naming_context_object =
orb->resolve_initial_references ("NameService");
CosNaming::NamingContext_var naming_context =
CosNaming::NamingContext::_narrow (naming_context_object.in ());
CosNaming::Name name (1);
name.length (1);
name[0].id = CORBA::string_dup ("CosEventService");
CORBA::Object_var ec_object =
naming_context->resolve (name);
// Now downcast the object reference to the appropriate type
CosEventChannelAdmin::EventChannel_var ec =
CosEventChannelAdmin::EventChannel::_narrow (ec_object.in ());
Stock_Consumer stock_consumer_i;
stock_consumer_i.connect (ec.in ());
orb->run ();
stock_consumer_i.disconnect ();
poa->destroy (1, 1);
orb->destroy ();
}
catch (CORBA::Exception &) {
cerr << "CORBA exception raised!" << endl;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
MessageFactory::register_new_factory(* orb.in());
CORBA::Object_var obj = orb->resolve_initial_references("RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow(obj.in());
PortableServer::POAManager_var poaman = poa->the_POAManager();
PortableServer::Servant_var<Messenger_i> svt = new Messenger_i;
PortableServer::ObjectId_var id = poa->activate_object(svt.in());
obj = poa->id_to_reference(id.in());
CORBA::String_var ior = orb->object_to_string(obj.in());
write_ior(ior.in());
std::cout << "Starting server." << std::endl;
poaman->activate();
orb->run();
poa->destroy(true, true);
orb->destroy();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
TAO_EC_Default_Factory::init_svcs ();
try
{
// ORB initialization boiler plate...
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var object =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa =
PortableServer::POA::_narrow (object.in ());
PortableServer::POAManager_var poa_manager =
poa->the_POAManager ();
poa_manager->activate ();
// ****************************************************************
run_test (poa.in (), 0);
run_test (poa.in (), 1);
// ****************************************************************
poa->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Service");
return 1;
}
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR* argv[])
{
try {
// First initialize the ORB, that will remove some arguments...
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
poa->the_POAManager ();
poa_manager->activate ();
// Create the servant
Quoter_Stock_Factory_i stock_factory_i;
// Activate it to obtain the object reference
Quoter::Stock_Factory_var stock_factory =
stock_factory_i._this ();
// Put the object reference as an IOR string
CORBA::String_var ior = orb->object_to_string (stock_factory.in ());
// Print it out!
cout << ior.in () << endl;
orb->run ();
// Destroy the POA, waiting until the destruction terminates
poa->destroy (1, 1);
orb->destroy ();
}
catch (CORBA::Exception &) {
cerr << "CORBA exception raised!" << endl;
}
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR* argv[])
{
try
{
// First initialize the ORB, that will remove some arguments...
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
if (argc < 2)
{
ACE_DEBUG ((LM_DEBUG, "\nUsage:\n %s [NAME to insert in Naming Service]\n", argv[0]));
return -1;
}
// Get a reference to the RootPOA
CORBA::Object_var poa_object =
orb->resolve_initial_references ("RootPOA");
// narrow down to the correct reference
PortableServer::POA_var poa =
PortableServer::POA::_narrow (poa_object.in ());
// Set a POA Manager
PortableServer::POAManager_var poa_manager =
poa->the_POAManager ();
// Activate the POA Manager
poa_manager->activate ();
// Create the servant
corbaloc_Status_i status_i;
status_i.set_name (ACE_TEXT_ALWAYS_CHAR (argv[1]));
// Activate it to obtain the reference
PortableServer::ObjectId_var id =
poa->activate_object (&status_i);
CORBA::Object_var object = poa->id_to_reference (id.in ());
corbaloc::Status_var status =
corbaloc::Status::_narrow (object.in ());
// Get a reference to Naming Context
CORBA::Object_var naming_context_object =
orb->resolve_initial_references ("NameService");
// Narrow down the reference
CosNaming::NamingContext_var naming_context =
CosNaming::NamingContext::_narrow (naming_context_object.in ());
// Bind Iterator_Factory to the Naming Context
CosNaming::Name name (1);
name.length (1);
name[0].id = CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR (argv[1]));
naming_context->rebind (name, status.in ());
// Run the orb
orb->run ();
// Destroy the POA, waiting until the destruction terminates
poa->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::SystemException& ex){
ex._tao_print_exception ("CORBA exception raised! ");
}
catch (const CORBA::Exception& ex){
ex._tao_print_exception ("Exception caught in server");
}
return 0;
}
int
TAO_MonitorManager::ORBTask::svc (void)
{
try
{
if (CORBA::is_nil (this->orb_.in ()))
{
ORBSVCS_ERROR_RETURN ((LM_ERROR,
"(%P|%t) TAO_MonitorManager: Unable to "
"initialize the ORB\n"),
1);
}
PortableServer::POA_var poa;
{
ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, guard, this->mutex_, -1);
CORBA::Object_var obj =
this->orb_->resolve_initial_references ("RootPOA");
poa = PortableServer::POA::_narrow (obj.in ());
if (CORBA::is_nil (poa.in ()))
{
ORBSVCS_ERROR_RETURN ((LM_ERROR,
"(%P|%t) TAO_MonitorManager: Unable to "
"resolve the RootPOA\n"),
1);
}
PortableServer::POAManager_var poa_manager = poa->the_POAManager ();
poa_manager->activate ();
// Activate the object
NotificationServiceMonitor_i* servant;
ACE_NEW_RETURN (servant,
NotificationServiceMonitor_i (this->orb_.in ()), 1);
PortableServer::ServantBase_var owner_transfer(servant);
PortableServer::ObjectId_var id = poa->activate_object (servant);
// Register the object with the IORTable
obj = poa->id_to_reference (id.in ());
CosNotification::NotificationServiceMonitorControl_var monitor =
CosNotification::NotificationServiceMonitorControl::_narrow (obj.in ());
CORBA::String_var ior = this->orb_->object_to_string (monitor.in ());
obj = this->orb_->resolve_initial_references ("IORTable");
IORTable::Table_var iortable = IORTable::Table::_narrow (obj.in ());
if (CORBA::is_nil (iortable.in ()))
{
ORBSVCS_ERROR_RETURN ((LM_ERROR,
"(%P|%t) TAO_MonitorManager: Unable to "
"resolve the IORTable\n"),
1);
}
iortable->bind(ACE_TEXT_ALWAYS_CHAR(mc_orb_name_.c_str()), ior.in ());
if (this->use_name_svc_)
{
TAO_Naming_Client nc;
nc.init (this->orb_.in ());
CosNaming::Name name (1);
name.length (1);
name[0].id = CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR(mc_orb_name_.c_str()));
nc->rebind (name, monitor.in ());
}
if (this->ior_output_.length () > 0)
{
FILE* fp = ACE_OS::fopen (this->ior_output_.c_str (), "w");
if (fp == 0)
{
ORBSVCS_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("(%P|%t) TAO_MonitorManager: "
ACE_TEXT ("Unable to write to %s\n")),
this->ior_output_.c_str ()),
1);
}
else
{
ACE_OS::fprintf (fp, "%s", ior.in ());
ACE_OS::fclose (fp);
}
}
}
// R1: race condition (partially fixed):
// TAO_MonitorManager::fini() is called directly after
// TAO_MonitorManager::run(), the shutdown call on the ORB could
// happen but the ORB::run() loop won't exit.
startup_barrier_.wait ();
this->orb_->run ();
ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, guard, this->mutex_, -1);
// Destroy the POA and ORB
if (!CORBA::is_nil (poa.in ()))
{
poa->destroy (true, true);
}
this->orb_->destroy ();
// Set to nil to avoid double shutdown in TAO_MonitorManager::fini()
this->orb_ = CORBA::ORB::_nil ();
}
catch (const CORBA::Exception& ex)
{
if (!CORBA::is_nil (this->orb_.in ()))
{
try
{
this->orb_->shutdown ();
}
catch (...)
{
}
this->orb_ = CORBA::ORB::_nil ();
}
ex._tao_print_exception ("Caught in "
"TAO_MonitorManager::ORBTask::svc");
}
catch (...)
{
if (!CORBA::is_nil (this->orb_.in ()))
{
try
{
this->orb_->shutdown ();
}
catch (...)
{
}
this->orb_ = CORBA::ORB::_nil ();
}
ORBSVCS_ERROR ((LM_ERROR,
"Unexpected exception type caught "
"in TAO_MonitorManager::ORBTask::svc"));
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
{
return 1;
}
CORBA::Object_var object =
orb->resolve_initial_references ("RootPOA");
ORB_Task worker (orb.in ());
worker.activate (THR_NEW_LWP | THR_JOINABLE,
1);
PortableServer::POA_var rootPOA =
PortableServer::POA::_narrow (object.in ());
PortableServer::POAManager_var poa_manager =
rootPOA->the_POAManager ();
CORBA::PolicyList policies (5);
policies.length (5);
// Lifespan policy
policies[0] =
rootPOA->create_lifespan_policy (PortableServer::PERSISTENT);
// Servant Retention Policy
policies[1] =
rootPOA->create_servant_retention_policy (PortableServer::RETAIN );
// ID Assignment Policy
policies[2] =
rootPOA->create_id_assignment_policy (PortableServer::USER_ID );
// Request Processing Policy
policies[3] =
rootPOA->create_request_processing_policy (PortableServer::USE_ACTIVE_OBJECT_MAP_ONLY );
// Threading policy
policies[4] =
rootPOA->create_thread_policy (PortableServer::ORB_CTRL_MODEL);
if (server_notify_delay > 0)
{
ACE_OS::sleep (server_notify_delay);
ACE_DEBUG ((LM_DEBUG, "(%P|%t)ServerB Now register with IMR \n"));
}
PortableServer::POA_var poa_a = rootPOA->create_POA ("poaB",
poa_manager.in (),
policies
);
for (CORBA::ULong i = 0;
i < policies.length ();
++i)
{
CORBA::Policy_ptr policy = policies[i];
policy->destroy ();
}
Test_Dummy_i* dummy = new Test_Dummy_i();
PortableServer::ObjectId_var oid =
PortableServer::string_to_ObjectId ("Server_B");
poa_a->activate_object_with_id (oid.in (), dummy);
CORBA::Object_var dummy_obj = poa_a->id_to_reference(oid.in());
CORBA::String_var ior =
orb->object_to_string (dummy_obj.in ());
poa_manager->activate ();
// Output the IOR to the <ior_output_file>
FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s",
ior_output_file),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
worker.wait ();
rootPOA->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::Exception &ex)
{
ex._tao_print_exception ("Exception caught by serverB:");
return 1;
}
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
//init the orb
CORBA::ORB_var orb=CORBA::ORB_init(argc, argv);
//get the root poa
CORBA::Object_var poa_object = orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager = poa->the_POAManager ();
if (parse_args (argc, argv) != 0)
return 1;
poa_manager->activate ();
// Get a reference to the IOR Table
CORBA::Object_var tobj = orb->resolve_initial_references("IORTable");
IORTable::Table_var table = IORTable::Table::_narrow(tobj.in());
//get an object id for the name
PortableServer::ObjectId_var oid =
PortableServer::string_to_ObjectId ("Messenger");
//activate the object for the given id
Messenger_i messenger (orb.in ());
poa->activate_object_with_id(oid.in (), &messenger);
CORBA::Object_var messenger_obj = poa->id_to_reference (oid.in ());
//bind the ior string to the name
CORBA::String_var messenger_ior_string = orb->object_to_string(messenger_obj.in());
table->bind("Messenger", messenger_ior_string.in());
// Output the IOR to the <ior_output_file>
FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s\n",
ior_output_file),
1);
ACE_OS::fprintf (output_file, "%s", messenger_ior_string.in ());
ACE_OS::fclose (output_file);
orb->run ();
ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n"));
poa->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var poa_object = orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var rootPOA = PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager = rootPOA->the_POAManager ();
// Policies for the firstPOA to be created.
CORBA::PolicyList policies (5);
policies.length (5);
// Lifespan policy
policies[0] =
rootPOA->create_lifespan_policy (PortableServer::PERSISTENT );
// Servant Retention Policy
policies[1] =
rootPOA->create_servant_retention_policy (PortableServer::RETAIN );
// ID Assignment Policy
policies[2] =
rootPOA->create_id_assignment_policy (PortableServer::USER_ID );
// Request Processing Policy
policies[3] =
rootPOA->create_request_processing_policy (PortableServer::USE_ACTIVE_OBJECT_MAP_ONLY );
// Threading policy
policies[4] =
rootPOA->create_thread_policy (PortableServer::ORB_CTRL_MODEL );
PortableServer::POA_var demoPOA
= rootPOA->create_POA ("HelloWorldServer",
poa_manager.in (),
policies
);
for (CORBA::ULong i = 0;
i < policies.length ();
++i)
{
CORBA::Policy_ptr policy = policies[i];
policy->destroy ();
}
// Create object for shutdown commanded by client.
{
// create the object
Demo_HelloWorld_i * hello = new Demo_HelloWorld_i(orb.in());
// Get the Object ID.
PortableServer::ObjectId_var oid = PortableServer::string_to_ObjectId ("shutdown");
demoPOA->activate_object_with_id (oid.in (), hello);
// Create an object reference.
CORBA::Object_var myhello = demoPOA->id_to_reference(oid.in());
// Put the object reference as an IOR string
ofstream out(ACE_TEXT_ALWAYS_CHAR (shutdown_ior_output_file));
CORBA::String_var ior = orb->object_to_string (myhello.in ());
out << ior.in();
// save the reference into a file
out.close();
}
// Create object to handle client sayHello requests.
{
// create the object
Demo_HelloWorld_i * hello = new Demo_HelloWorld_i(orb.in());
// Get the Object ID.
PortableServer::ObjectId_var oid = PortableServer::string_to_ObjectId ("hello");
demoPOA->activate_object_with_id (oid.in (), hello);
// Create an object reference.
CORBA::Object_var myhello = demoPOA->id_to_reference(oid.in());
// Put the object reference as an IOR string
ofstream out(ACE_TEXT_ALWAYS_CHAR (ior_output_file));
CORBA::String_var ior = orb->object_to_string (myhello.in ());
out << ior.in();
// save the reference into a file
out.close();
}
//////////////////////////////////////////////////////////////////////////////////////////////////
poa_manager->activate ();
std::cout << ior_output_file << " is ready " << std::endl;
orb->run ();
// Destroy the POA, waiting until the destruction terminates
rootPOA->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::Exception &e)
{
std::cerr << "Unexpected exception: " << e << std::endl;
return 1;
}
return 0;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
// Initialize orb
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
// Get reference to Root POA.
CORBA::Object_var obj =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var rootpoa =
PortableServer::POA::_narrow (obj.in ());
// Activate POA manager
PortableServer::POAManager_var mgr =
rootpoa->the_POAManager ();
mgr->activate ();
PortableServer::POA_var poa;
TAO::Utils::PolicyList_Destroyer PolicyList (3);
PolicyList.length (3);
PolicyList [0] =
rootpoa->create_lifespan_policy (PortableServer::PERSISTENT);
PolicyList [1] =
rootpoa->create_id_assignment_policy (PortableServer::USER_ID);
CORBA::Any CallbackPolicy;
CallbackPolicy <<= BiDirPolicy::BOTH;
const char* sServerPoaName = "TelemetryServer";
PolicyList [2] =
orb->create_policy (BiDirPolicy::BIDIRECTIONAL_POLICY_TYPE,
CallbackPolicy);
poa = rootpoa->create_POA (sServerPoaName,
mgr.in(),
PolicyList);
PortableServer::ObjectId_var ServerId =
PortableServer::string_to_ObjectId ("TimeServer");
// Create an object
Time_impl *time_servant = new Time_impl;
PortableServer::ServantBase_var self_manage (time_servant);
poa->activate_object_with_id (ServerId.in (),
time_servant);
// Get a reference after activating the object
CORBA::Object_var object = poa->id_to_reference (ServerId.in ());
TimeModule::Time_var tm = TimeModule::Time::_narrow (object.in ());
// Get reference to initial naming context
CORBA::Object_var name_obj =
orb->resolve_initial_references ("NameService");
CosNaming::NamingContext_var inc =
CosNaming::NamingContext::_narrow (name_obj.in ());
if (CORBA::is_nil (inc.in ()))
{
ACE_ERROR ((LM_ERROR,
"(%P|%t) Error fetching naming context\n"));
}
CosNaming::Name service_name;
service_name.length(1);
service_name[0].id =
CORBA::string_dup ("Time");
inc->rebind (service_name,
tm.in ());
// Run the event loop for fun
ACE_Time_Value tv (3, 0);
// Accept requests
orb->run (&tv);
rootpoa->destroy (0 , 0);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught an exception\n");
return -1;
}
return 0;
}
int
Server_i::init (int &argc,
ACE_TCHAR **argv)
{
this->argc_ = argc;
this->argv_ = argv;
try
{
// First initialize the ORB, that will remove some arguments...
this->orb_ =
CORBA::ORB_init (this->argc_, this->argv_);
// Get a reference to the RootPOA.
CORBA::Object_var poa_object =
this->orb_->resolve_initial_references ("RootPOA");
// Narrow down to the correct reference.
PortableServer::POA_var poa =
PortableServer::POA::_narrow (poa_object.in ());
// Set a POA Manager.
PortableServer::POAManager_var poa_manager =
poa->the_POAManager ();
// Activate the POA Manager.
poa_manager->activate ();
CORBA::String_var ior;
// Create the servant
MCast_Server_i server_i;
// Activate it to obtain the reference
MCast::Server_var mcast_server =
server_i._this ();
CORBA::Object_var table_object =
this->orb_->resolve_initial_references ("IORTable");
IORTable::Table_var adapter =
IORTable::Table::_narrow (table_object.in ());
if (CORBA::is_nil (adapter.in ()))
{
ACE_ERROR ((LM_ERROR, "Nil IORTable\n"));
}
else
{
ior =
this->orb_->object_to_string (mcast_server.in ());
adapter->bind ("MCASTServer", ior.in ());
}
// Enable such that the server can listen for multicast requests
// at the specified address.
if (this->enable_multicast (ior.in ()) != 0)
{
ACE_ERROR ((LM_ERROR,
"ERROR: Unable to enable multicast "
"on specified address.\n"));
throw CORBA::INTERNAL ();
}
// Run the ORB
this->orb_->run ();
//Destroy the POA, waiting until the destruction terminates.
poa->destroy (1, 1);
this->orb_->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("client");
return 1;
}
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR* argv[])
{
try {
// First initialize the ORB, that will remove some arguments...
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
poa->the_POAManager ();
poa_manager->activate ();
CORBA::Object_var naming_context_object =
orb->resolve_initial_references ("NameService");
CosNaming::NamingContext_var naming_context =
CosNaming::NamingContext::_narrow (naming_context_object.in ());
CosNaming::Name name (1);
name.length (1);
name[0].id = CORBA::string_dup ("EventService");
CORBA::Object_var ec_object =
naming_context->resolve (name);
// Now downcast the object reference to the appropriate type
RtecEventChannelAdmin::EventChannel_var ec =
RtecEventChannelAdmin::EventChannel::_narrow (ec_object.in ());
ACE_ConsumerQOS_Factory qos;
qos.start_disjunction_group ();
for (int i = 1; i != argc; ++i) {
if (ACE_OS::strlen (argv[i]) < 4)
continue;
CORBA::ULong type =
((int(argv[i][0]) << 24)
| (int(argv[i][1]) << 16)
| (int(argv[i][2]) << 8)
| int(argv[i][3]));
qos.insert_type (type, 0);
}
Stock_Consumer stock_consumer_i;
stock_consumer_i.connect (ec.in (), qos.get_ConsumerQOS ());
orb->run ();
stock_consumer_i.disconnect ();
poa->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::Exception &ex) {
cerr << "CORBA exception raised!" << ex << endl;
}
return 0;
}
static void s_destroy_send(void) {
poa->destroy (1, 1);
orb->destroy ();
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
// Initialiaze the ORB.
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
// This call MUST come after ORB_init(), which may need to
// extract -ORB options first.
if (parse_args (argc, argv) != 0)
return 1;
// Get a reference to the RootPOA.
CORBA::Object_var obj = orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow (obj.in ());
// Activate the POAManager.
PortableServer::POAManager_var mgr = poa->the_POAManager ();
mgr->activate ();
// Read and destringify the Stock_Distributor object's IOR.
obj = get_distributor_reference (orb.in ());
// Narrow the IOR to a Stock_Distributor object reference.
Stock::StockDistributor_var stock_distributor =
Stock::StockDistributor::_narrow (obj.in ());
if (CORBA::is_nil (stock_distributor.in ()))
ACE_ERROR_RETURN ((LM_DEBUG,
"Nil StockDistributor object reference <%s>\n",
ior.c_str ()),
1);
// Create an instance of the <StockBroker>.
// Create the factory object. Create a <Stock::StockBroker>.
Stock_StockBrokerHome_i stock_broker_home (orb.in ());
Stock::StockBroker_var stock_broker =
stock_broker_home.create (stock_distributor.in (),
stock_name.c_str ());
if (CORBA::is_nil (stock_broker.in ()))
ACE_ERROR_RETURN ((LM_DEBUG,
"Nil StockBroker object reference <%s>\n",
ior.c_str ()),
1);
// Create a new consumer and initialize it.
Stock::StockNameConsumer_var consumer =
stock_broker->get_consumer_notifier ();
// Subscribe the consumer with the distributor.
::Stock::Cookie_var cookie =
stock_distributor->subscribe_notifier (consumer.in (), priority_level);
consumer->cookie_ (cookie.in ());
// Get the object reference to a StockQuoter that's been
// activated at the appropriate priority.
Stock::StockQuoter_var stock_quoter =
stock_distributor->provide_quoter_info (cookie.in ());
if (CORBA::is_nil (stock_quoter.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
"ERROR: Quoter reference was nil!\n"),
-1);
// Stash the stock_quoter object reference away for later use.
stock_broker->connect_quoter_info (stock_quoter.in ());
// Run the event loop.
ACE_DEBUG ((LM_DEBUG,
"running the event loop:\n"
"*** message: ready to receive stock information...\n\n"));
orb->run ();
// Cleanup the POA and ORB.
poa->destroy (1, 1);
orb->destroy ();
}
catch (CORBA::Exception &ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
catch (...)
{
ACE_ERROR ((LM_ERROR, "Broker: Caught unknown C++ exception\n"));
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
{
return 1;
}
CORBA::Object_var object =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var rootPOA =
PortableServer::POA::_narrow (object.in ());
PortableServer::POAManager_var poa_manager =
rootPOA->the_POAManager ();
CORBA::PolicyList policies (5);
policies.length (5);
// Lifespan policy
policies[0] =
rootPOA->create_lifespan_policy (PortableServer::PERSISTENT);
// Servant Retention Policy
policies[1] =
rootPOA->create_servant_retention_policy (PortableServer::RETAIN );
// ID Assignment Policy
policies[2] =
rootPOA->create_id_assignment_policy (PortableServer::USER_ID );
// Request Processing Policy
policies[3] =
rootPOA->create_request_processing_policy (PortableServer::USE_ACTIVE_OBJECT_MAP_ONLY );
// Threading policy
policies[4] =
rootPOA->create_thread_policy (PortableServer::ORB_CTRL_MODEL);
PortableServer::POA_var poa_a = rootPOA->create_POA ("poaA",
poa_manager.in (),
policies
);
PortableServer::POA_var poa_c = rootPOA->create_POA ("poaC",
poa_manager.in (),
policies
);
for (CORBA::ULong i = 0;
i < policies.length ();
++i)
{
CORBA::Policy_ptr policy = policies[i];
policy->destroy ();
}
Test_Time_i* time = new Test_Time_i();
PortableServer::ObjectId_var oid =
PortableServer::string_to_ObjectId ("Server_A");
poa_a->activate_object_with_id (oid.in (), time);
CORBA::Object_var time_obj = poa_a->id_to_reference(oid.in());
CORBA::String_var ior =
orb->object_to_string (time_obj.in ());
poa_manager->activate ();
FILE *output_file = ACE_OS::fopen (pid_file, ACE_TEXT ("w"));
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("Cannot open output file for writing IOR: %s\n"),
pid_file),
1);
int pid = static_cast<int> (ACE_OS::getpid ());
ACE_OS::fprintf (output_file, "%d\n", pid);
ACE_OS::fclose (output_file);
orb->run ();
rootPOA->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::Exception &ex)
{
ex._tao_print_exception (ACE_TEXT ("server:"));
return 1;
}
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR* argv[])
{
try {
// First initialize the ORB, that will remove some arguments...
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
// There must be at least two arguments, the first is the factory
// name, the rest are the names of the stock symbols we want to
// get quotes for.
if (argc < 3) {
cerr << "Usage: " << argv[0]
<< " Factory_IOR symbol symbol..." << endl;
return 1;
}
CORBA::Object_var poa_object =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
poa->the_POAManager ();
poa_manager->activate ();
// Use the first argument to create the factory object reference,
// in real applications we use the naming service, but let's do
// the easy part first!
CORBA::Object_var factory_object =
orb->string_to_object (argv[1]);
// Now downcast the object reference to the appropriate type
Quoter::Stock_Factory_var factory =
Quoter::Stock_Factory::_narrow (factory_object.in ());
// Create and activate the handler...
int response_count = 0;
Single_Query_Stock_Handler_i handler_i (&response_count);
Quoter::AMI_Single_Query_StockHandler_var handler =
handler_i._this ();
// Send all the requests, careful with error handling
int request_count = 0;
for (int i = 2; i != argc; ++i) {
try {
// Get the stock object
Quoter::Stock_var tmp =
factory->get_stock (ACE_TEXT_ALWAYS_CHAR (argv[i]));
Quoter::Single_Query_Stock_var stock =
Quoter::Single_Query_Stock::_narrow (tmp.in ());
if (CORBA::is_nil (stock.in ())) {
cerr << "Cannot get single query interface for <"
<< argv[i] << ">" << endl;
}
stock->sendc_get_price_and_names (handler.in ());
request_count++;
}
catch (Quoter::Invalid_Stock_Symbol &) {
cerr << "Invalid stock symbol <"
<< argv[i] << ">" << endl;
}
}
while (response_count < request_count
&& orb->work_pending ()) {
orb->perform_work ();
}
// Destroy the POA, waiting until the destruction terminates
poa->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::Exception &) {
cerr << "CORBA exception raised!" << endl;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
TAO_CEC_Default_Factory::init_svcs ();
try
{
// ORB initialization boiler plate...
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var object =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa =
PortableServer::POA::_narrow (object.in ());
PortableServer::POAManager_var poa_manager =
poa->the_POAManager ();
poa_manager->activate ();
// ****************************************************************
TAO_CEC_EventChannel_Attributes attributes (poa.in (),
poa.in ());
TAO_CEC_EventChannel ec_impl (attributes);
ec_impl.activate ();
CosEventChannelAdmin::EventChannel_var event_channel =
ec_impl._this ();
// ****************************************************************
// Obtain the consumer admin..
CosEventChannelAdmin::ConsumerAdmin_var consumer_admin =
event_channel->for_consumers ();
// Obtain the supplier admin..
CosEventChannelAdmin::SupplierAdmin_var supplier_admin =
event_channel->for_suppliers ();
// ****************************************************************
const int milliseconds = 50;
CEC_Counting_Supplier supplier_00;
supplier_00.connect (supplier_admin.in ());
// ****************************************************************
CEC_Counting_Supplier supplier_01;
supplier_01.connect (supplier_admin.in ());
// ****************************************************************
CEC_Counting_Supplier supplier_10;
supplier_10.connect (supplier_admin.in ());
// ****************************************************************
CEC_Counting_Supplier supplier_11;
supplier_11.connect (supplier_admin.in ());
// ****************************************************************
// Create a consumer, intialize its RT_Info structures, and
// connnect to the event channel....
CEC_Counting_Consumer consumer_00 ("Consumer/00");
consumer_00.connect (consumer_admin.in ());
// ****************************************************************
CEC_Counting_Consumer consumer_01 ("Consumer/01");
consumer_01.connect (consumer_admin.in ());
// ****************************************************************
CEC_Counting_Supplier_Task task_00 (&supplier_00, milliseconds);
CEC_Counting_Supplier_Task task_01 (&supplier_01, milliseconds);
CEC_Counting_Supplier_Task task_10 (&supplier_10, milliseconds);
CEC_Counting_Supplier_Task task_11 (&supplier_11, milliseconds);
if (task_00.activate (THR_BOUND|THR_NEW_LWP, 1) != 0)
{
ACE_ERROR ((LM_ERROR, "Cannot activate task 00\n"));
}
if (task_01.activate (THR_BOUND|THR_NEW_LWP, 1) != 0)
{
ACE_ERROR ((LM_ERROR, "Cannot activate task 01\n"));
}
if (task_10.activate (THR_BOUND|THR_NEW_LWP, 1) != 0)
{
ACE_ERROR ((LM_ERROR, "Cannot activate task 10\n"));
}
if (task_11.activate (THR_BOUND|THR_NEW_LWP, 1) != 0)
{
ACE_ERROR ((LM_ERROR, "Cannot activate task 11\n"));
}
ACE_Time_Value tv (5, 0);
ACE_OS::sleep (tv);
task_00.stop ();
task_01.stop ();
task_10.stop ();
task_11.stop ();
// Wait for all the threads to complete and the return
ACE_Thread_Manager::instance ()->wait ();
// ****************************************************************
consumer_01.disconnect ();
consumer_00.disconnect ();
supplier_11.disconnect ();
supplier_10.disconnect ();
supplier_01.disconnect ();
supplier_00.disconnect ();
// ****************************************************************
event_channel->destroy ();
// ****************************************************************
poa->destroy (1, 1);
orb->destroy ();
// ****************************************************************
CORBA::ULong expected =
task_00.push_count ()
+ task_01.push_count ()
+ task_10.push_count ()
+ task_11.push_count ();
consumer_00.dump_results (expected, 5);
consumer_01.dump_results (expected, 5);
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Service");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
// Initialize orb
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
//Get reference to Root POA
CORBA::Object_var POA_obj = orb->resolve_initial_references( "RootPOA" );
PortableServer::POA_var poa = PortableServer::POA::_narrow( POA_obj.in() );
// Activate POA Manager
PortableServer::POAManager_var mgr = poa->the_POAManager();
mgr->activate();
// Create an object
Messenger_i messenger_servant (orb);
Messenger_var messenger_factory = messenger_servant._this ();
// In order to allow collocated invocations we need to allow unsecured
// collocated invocations to the object else our security manager will
// block the collocated invocation unless you explicitly allow it
CORBA::Object_var sec_man =
orb->resolve_initial_references ("SecurityLevel2:SecurityManager");
SecurityLevel2::SecurityManager_var sec2manager =
SecurityLevel2::SecurityManager::_narrow (sec_man.in ());
SecurityLevel2::AccessDecision_var ad_tmp =
sec2manager->access_decision ();
TAO::SL2::AccessDecision_var ad =
TAO::SL2::AccessDecision::_narrow (ad_tmp.in ());
// Allow unsecured collocated invocations
ad->default_collocated_decision (true);
CORBA::String_var ior =
orb->object_to_string (messenger_factory.in ());
// If the ior_output_file exists, output the ior to it
if (ior_output_file != 0)
{
FILE *output_file= ACE_OS::fopen (ACE_TEXT_ALWAYS_CHAR(ior_output_file), "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s",
ACE_TEXT_ALWAYS_CHAR(ior_output_file)),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
}
// Accept requests
orb->run();
poa->destroy (1, 1);
orb->destroy();
}
catch (const CORBA::Exception&)
{
ACE_ERROR((LM_ERROR, "Caught a CORBA exception: "));
return 1;
}
return 0;
}
int
Gateway::run (int argc, ACE_TCHAR* argv[])
{
TAO_EC_Gateway_IIOP_Factory::init_svcs ();
try
{
// First parse our command line options
if (this->parse_args(argc, argv) != 0)
{
return -1;
}
// ORB initialization boiler plate...
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var object =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa =
PortableServer::POA::_narrow (object.in ());
PortableServer::POAManager_var poa_manager =
poa->the_POAManager ();
poa_manager->activate ();
// Obtain the event channel from the naming service
CORBA::Object_var naming_obj =
orb->resolve_initial_references ("NameService");
if (CORBA::is_nil (naming_obj.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to get the Naming Service.\n"),
1);
CosNaming::NamingContext_var naming_context =
CosNaming::NamingContext::_narrow (naming_obj.in ());
CosNaming::Name supplierecname (1);
supplierecname.length (1);
supplierecname[0].id = CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR(supplierec));
CORBA::Object_var supplierec_obj =
naming_context->resolve (supplierecname);
CosNaming::Name consumerecname (1);
consumerecname.length (1);
consumerecname[0].id = CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR(consumerec));
CORBA::Object_var consumerec_obj =
naming_context->resolve (consumerecname);
RtecEventChannelAdmin::EventChannel_var supplier_event_channel =
RtecEventChannelAdmin::EventChannel::_narrow (supplierec_obj.in ());
if (CORBA::is_nil (supplier_event_channel.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to get the supplier event channel.\n"),
1);
RtecEventChannelAdmin::EventChannel_var consumer_event_channel =
RtecEventChannelAdmin::EventChannel::_narrow (consumerec_obj.in ());
if (CORBA::is_nil (consumer_event_channel.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to get the consumer event channel.\n"),
1);
TAO_EC_Gateway_IIOP gateway;
gateway.init(supplier_event_channel.in(), consumer_event_channel.in());
PortableServer::ObjectId_var gateway_oid =
poa->activate_object(&gateway);
CORBA::Object_var gateway_obj =
poa->id_to_reference(gateway_oid.in());
RtecEventChannelAdmin::Observer_var obs =
RtecEventChannelAdmin::Observer::_narrow(gateway_obj.in());
RtecEventChannelAdmin::Observer_Handle local_ec_obs_handle =
consumer_event_channel->append_observer (obs.in ());
// Wait for events, using work_pending()/perform_work() may help
// or using another thread, this example is too simple for that.
orb->run ();
consumer_event_channel->remove_observer (local_ec_obs_handle);
poa->deactivate_object (gateway_oid.in ());
// Destroy the POA
poa->destroy (1, 0);
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Gateway::run");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
// Register the default factory in the Service Configurator.
// If your platform supports static constructors then you can
// simply using the ACE_STATIC_SVC_DEFINE() macro, unfortunately TAO
// must run on platforms where static constructors do not work well,
// so we have to explicitly invoke this function.
TAO_EC_Default_Factory::init_svcs ();
// The exception macros are described in $ACE_ROOT/docs/exceptions.html
// and defined in $ACE_ROOT/ace/CORBA_macros.h.
// If your platform supports native exceptions, and TAO was compiled
// with native exception support then you can simply use try/catch
// and avoid the argument.
// Unfortunately many embedded systems cannot use exceptions due to
// the space and time overhead.
//
try
{
// **************** HERE STARTS THE ORB SETUP
// Create the ORB, pass the argv list for parsing.
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
// Parse the arguments, you usually want to do this after
// invoking ORB_init() because ORB_init() will remove all the
// -ORB options from the command line.
if (parse_args (argc, argv) == -1)
{
ACE_ERROR ((LM_ERROR,
"Usage: Service [-m udp_mcast_addr]\n"));
return 1;
}
if (valuetype)
{
Hello::ValueTypeData_init *vb_factory = 0;
ACE_NEW_RETURN (vb_factory,
Hello::ValueTypeData_init,
1); // supplied by mapping
orb->register_value_factory (vb_factory->tao_repository_id (),
vb_factory);
vb_factory->_remove_ref (); // release ownership
}
// This is the standard code to get access to the POA and
// activate it.
// The POA starts in the holding state, if it is not activated
// it will not process any requests.
CORBA::Object_var object =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa =
PortableServer::POA::_narrow (object.in ());
PortableServer::POAManager_var poa_manager =
poa->the_POAManager ();
poa_manager->activate ();
// **************** THAT COMPLETS THE ORB SETUP
// **************** HERE START THE LOCAL EVENT CHANNEL SETUP
// This structure is used to define the startup time event
// channel configuration.
// This structure is described in
//
// $TAO_ROOT/docs/ec_options.html
//
TAO_EC_Event_Channel_Attributes attributes (poa.in (),
poa.in ());
// Create the Event Channel implementation class
TAO_EC_Event_Channel ec_impl (attributes);
// Activate the Event Channel, depending on the configuration
// that may involve creating some threads.
// But it should always be invoked because several internal data
// structures are initialized at that point.
ec_impl.activate ();
// The event channel is activated as any other CORBA servant.
// In this case we use the simple implicit activation with the
// RootPOA
RtecEventChannelAdmin::EventChannel_var event_channel =
ec_impl._this ();
// **************** THAT COMPLETES THE LOCAL EVENT CHANNEL SETUP
// **************** HERE STARTS THE FEDERATION SETUP
// The next step is to setup the multicast gateways.
// There are two gateways involved, one sends the locally
// generated events to the federated peers, the second gateway
// receives multicast traffic and turns it into local events.
// The sender requires a helper object to select what
// multicast group will carry what traffic, this is the
// so-called 'Address Server'.
// The intention is that advanced applications can use different
// multicast groups for different events, this can exploit
// network interfaces that filter unwanted multicast traffic.
// The helper object is accessed through an IDL interface, so it
// can reside remotely.
// In this example, and in many application, using a fixed
// multicast group is enough, and a local address server is the
// right approach.
// First we convert the string into an INET address, then we
// convert that into the right IDL structure:
ACE_INET_Addr udp_addr (udp_mcast_address);
ACE_DEBUG ((LM_DEBUG,
"udp mcast address is: %s\n",
udp_mcast_address));
// Now we create and activate the servant
AddrServer as_impl (udp_addr);
RtecUDPAdmin::AddrServer_var address_server =
as_impl._this ();
TAO_ECG_Refcounted_Endpoint endpoint(new TAO_ECG_UDP_Out_Endpoint);
// Now we connect the sender as a consumer of events, it will
// receive any event from any source and send it to the "right"
// multicast group, as defined by the address server set above:
RtecEventChannelAdmin::ConsumerQOS sub;
sub.is_gateway = 1;
sub.dependencies.length (1);
sub.dependencies[0].event.header.type =
ACE_ES_EVENT_ANY; // first free event type
sub.dependencies[0].event.header.source =
ACE_ES_EVENT_SOURCE_ANY; // Any source is OK
// To receive events we need to setup an event handler:
PortableServer::Servant_var<TAO_ECG_UDP_Receiver> receiver =
TAO_ECG_UDP_Receiver::create();
TAO_ECG_Mcast_EH mcast_eh (&(*receiver));
// The event handler uses the ORB reactor to wait for multicast
// traffic:
mcast_eh.reactor (orb->orb_core ()->reactor ());
// The multicast Event Handler needs to know to what multicast
// groups it should listen to. To do so it becomes an observer
// with the event channel, to determine the list of events
// required by all the local consumer.
// Then it register for the multicast groups that carry those
// events:
mcast_eh.open (event_channel.in ());
// Again the receiver connects to the event channel as a
// supplier of events, using the Observer features to detect
// local consumers and their interests:
receiver->init (event_channel.in (),
endpoint,
address_server.in ());
// The Receiver is also a supplier of events. The exact type of
// events is only known to the application, because it depends
// on the traffic carried by all the multicast groups that the
// different event handlers subscribe to.
// In this example we choose to simply describe our publications
// using wilcards, any event from any source. More advanced
// application could use the Observer features in the event
// channel to update this information (and reduce the number of
// multicast groups that each receive subscribes to).
// In a future version the event channel could perform some of
// those tasks automatically
RtecEventChannelAdmin::SupplierQOS pub;
pub.publications.length (1);
pub.publications[0].event.header.type = ACE_ES_EVENT_ANY;
pub.publications[0].event.header.source = ACE_ES_EVENT_SOURCE_ANY;
pub.is_gateway = 1;
receiver->connect (pub);
// **************** THAT COMPLETES THE FEDERATION SETUP
// **************** HERE STARTS THE CLIENT SETUP
// First let us create a consumer and connect it to the event
// channel
Consumer consumer (valuetype);
RtecEventChannelAdmin::ConsumerAdmin_var consumer_admin =
event_channel->for_consumers ();
consumer.connect (consumer_admin.in ());
// **************** THAT COMPLETES THE CLIENT SETUP
// **************** HERE STARTS THE EVENT LOOP
// Wait for events, including incoming multicast data.
// We could also use orb->run(), but that will not let us
// terminate the application in a nice way.
for (int i = 0; i != 100; ++i)
{
CORBA::Boolean there_is_work =
orb->work_pending ();
if (there_is_work)
{
// We use a TAO extension. The CORBA mechanism does not
// provide any decent way to control the duration of
// perform_work() or work_pending(), so just calling
// them results in a spin loop.
ACE_Time_Value tv (0, 50000);
orb->perform_work (tv);
}
ACE_Time_Value tv (0, 100000);
ACE_OS::sleep (tv);
if (consumer.event_count () == 25)
{
break;
}
}
// **************** THAT COMPLETES THE EVENT LOOP
// **************** HERE STARTS THE CLEANUP CODE
consumer.disconnect ();
// Now let us close the Receiver
receiver->shutdown ();
int const r = mcast_eh.shutdown ();
if (r == -1)
{
ACE_ERROR_RETURN ((LM_ERROR,
"Closing MCast event handler\n"), 1);
}
// The event channel must be destroyed, so it can release its
// resources, and inform all the clients that are still
// connected that it is going away.
event_channel->destroy ();
// Deactivating the event channel implementation is not strictly
// required, the POA will do it for us, but it is good manners:
{
// Using _this() activates with the default POA, we must gain
// access to that POA to deactivate the object.
// Notice that we 'know' that the default POA for this servant
// is the root POA, but the code is more robust if we don't
// rely on that.
PortableServer::POA_var poa =
ec_impl._default_POA ();
// Get the Object Id used for the servant..
PortableServer::ObjectId_var oid =
poa->servant_to_id (&ec_impl);
// Deactivate the object
poa->deactivate_object (oid.in ());
}
// Now we can destroy the POA, the flags mean that we want to
// wait until the POA is really destroyed
poa->destroy (1, 1);
// Finally destroy the ORB
orb->destroy ();
// **************** THAT COMPLETES THE CLEANUP CODE
ACE_DEBUG ((LM_DEBUG,
"UDP receiver ready\n"));
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Service");
return 1;
}
return 0;
}
int
ACE_TMAIN(int, ACE_TCHAR *[])
{
int niterations = 10;
int norbs = 10;
try
{
for (int i = 0; i != niterations; ++i)
{
for (int j = 0; j != norbs; ++j)
{
char buf[16];
ACE_OS::sprintf (buf, "ORB_%4.4d", j);
int argc = 0;
ACE_TCHAR **argv = 0;
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv, buf);
CORBA::Object_var object =
orb->string_to_object ("DLL:Test_Object");
Test_var test =
Test::_narrow (object.in ());
if (CORBA::is_nil (test.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Nil object reference.\n"),
1);
}
CORBA::Long count =
test->instance_count ();
if (count != norbs*i + j + 1)
{
ACE_DEBUG ((LM_DEBUG,
"Incorrect number of objects "
"(%d != %d)\n",
count, norbs * i + j + 1));
}
test->destroy ();
}
}
for (int j = 0; j != norbs; ++j)
{
char buf[16];
ACE_OS::sprintf (buf, "ORB_%4.4d", j);
int argc = 0;
ACE_TCHAR **argv = 0;
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv, buf);
CORBA::Object_var obj =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa =
PortableServer::POA::_narrow (obj.in ());
poa->destroy (1, 1);
orb->destroy ();
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("main()");
return 1;
}
return 0;
}
int
TAO_Notify_Service_Driver::fini (void)
{
/// Release all the _vars as the ORB about to go away.
CosNotifyChannelAdmin::EventChannelFactory_var factory =
this->notify_factory_._retn ();
CORBA::ORB_var orb = this->orb_._retn ();
CORBA::ORB_var dispatching_orb = this->dispatching_orb_._retn ();
PortableServer::POA_var poa = this->poa_._retn ();
CosNaming::NamingContextExt_var naming = this->naming_._retn ();
// This must be called to ensure that all services shut down
// correctly. Depending upon the type of service loaded, it may
// or may not actually perform any actions.
this->notify_service_->finalize_service (factory.in ());
factory = CosNotifyChannelAdmin::EventChannelFactory::_nil ();
this->notify_service_->fini ();
// Deactivate.
if (this->use_name_svc_ && !CORBA::is_nil (naming.in ()))
{
// Unbind all event channels from the naming service
if (this->register_event_channel_)
{
for (ACE_Unbounded_Set<ACE_CString>::const_iterator ci (
this->notify_channel_name_); !ci.done(); ci++)
{
CosNaming::Name_var name = naming->to_name ((*ci).c_str ());
naming->unbind (name.in ());
}
}
// Unbind from the naming service.
CosNaming::Name_var name =
naming->to_name (this->notify_factory_name_.c_str ());
naming->unbind (name.in ());
naming = CosNaming::NamingContextExt::_nil ();
}
if (!CORBA::is_nil (poa.in ()))
{
poa->destroy (true, true);
poa = PortableServer::POA::_nil ();
}
if (this->shutdown_dispatching_orb_ && !CORBA::is_nil (dispatching_orb_.in ()))
{
dispatching_orb->shutdown ();
}
// shutdown the ORB.
if (this->shutdown_orb_ && !CORBA::is_nil (orb.in ()))
{
orb->shutdown ();
}
// Make sure all worker threads are gone.
this->worker_.wait ();
this->logging_worker_.wait ();
// Destroy the ORB
if (this->shutdown_dispatching_orb_ && !CORBA::is_nil (dispatching_orb_.in ()))
{
dispatching_orb->destroy ();
}
// Destroy the ORB.
if (this->shutdown_orb_ && !CORBA::is_nil (orb.in ()))
{
orb->destroy ();
}
dispatching_orb_ = CORBA::ORB::_nil ();
worker_.orb (CORBA::ORB::_nil ());
orb = CORBA::ORB::_nil ();
return 0;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try {
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
const ACE_TCHAR *iorfile = ACE_TEXT ("");
ACE_Get_Opt get_opts (argc, argv, ACE_TEXT ("o:?"));
int c;
while ((c = get_opts ()) != -1)
switch (c)
{
case 'o':
iorfile = get_opts.opt_arg ();
break;
case '?':
ACE_DEBUG ((LM_DEBUG,
"usage: %s "
"-d <seconds to delay before initializing POA> "
"-n Number of the server\n",
argv[0]));
return 1;
break;
}
CORBA::Object_var obj = orb->resolve_initial_references ("RootPOA");
root_poa = PortableServer::POA::_narrow (obj.in ());
// TAO_Root_POA::imr_client_adapter_name ("Test_Imr_Adapter");
ACE_CString base = ACE_CString ("TestObject");
createPOAs (base);
PortableServer::Servant_var<Test_i> test_servant = new Test_i ();
PortableServer::ObjectId_var object_id =
PortableServer::string_to_ObjectId (base.c_str());
poa_a->activate_object_with_id (object_id.in(), test_servant.in ());
obj = poa_a->id_to_reference (object_id.in());
Test_var tva = Test::_narrow (obj.in());
if (ACE_OS::strlen (iorfile) > 0)
{
CORBA::String_var ior = orb->object_to_string (obj.in());
FILE *output_file= ACE_OS::fopen (iorfile, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s\n",
iorfile),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
}
poa_b->activate_object_with_id (object_id.in(), test_servant.in ());
obj = poa_b->id_to_reference (object_id.in());
Test_var tvb = Test::_narrow (obj.in());
// object_id = root_poa->activate_object (test_servant.in());
//
// This server is now ready to run.
// This version does not create an IOR
// file as demonstrated in the
// Developer's Guide. It assumes that
// users create IORs for the client using
// the tao_imr utility.
//
//
// Stop discarding requests.
//
activatePOAs ();
//
// Create binding between "TestService" and
// the test object reference in the IOR Table.
// Use a TAO extension to get the non imrified poa
// to avoid forwarding requests back to the ImR.
TAO_Root_POA* tpoa = dynamic_cast<TAO_Root_POA*> (poa_a.in ());
ACE_ASSERT (tpoa != 0);
obj = tpoa->id_to_reference_i (object_id.in (), false);
CORBA::String_var test_ior = orb->object_to_string (obj.in ());
obj = orb->resolve_initial_references("IORTable");
IORTable::Table_var table = IORTable::Table::_narrow (obj.in ());
table->bind(base.c_str (), test_ior.in ());
{
ACE_CString status_file = base + ACE_CString(".status");
ofstream out(status_file.c_str ());
out << "started" << endl;
}
test_ior = orb->object_to_string (tva.in());
base += "_a";
ACE_DEBUG ((LM_DEBUG, "%s:\n%s\n", base.c_str(), test_ior.in()));
table->bind (base.c_str (), test_ior.in ());
base[base.length()-1] = 'b';
test_ior = orb->object_to_string (tvb.in());
ACE_DEBUG ((LM_DEBUG, "%s:\n%s\n", base.c_str(), test_ior.in()));
table->bind (base.c_str (), test_ior.in ());
ACE_DEBUG ((LM_DEBUG,
"Started Server %s \n",
base.c_str()));
orb->run();
root_poa->destroy(1,1);
orb->destroy();
}
catch(const CORBA::Exception& ex) {
ex._tao_print_exception ("Server main()");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
ACE_TString env (ACE_TEXT ("SSL_CERT_FILE="));
env += cert_file;
ACE_OS::putenv ( ACE_TEXT_ALWAYS_CHAR(env.c_str ()));
//
// Initialize the ORB
//
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
//
// Get the Root POA.
//
CORBA::Object_var obj =
orb->resolve_initial_references ( "RootPOA" );
PortableServer::POA_var poa =
PortableServer::POA::_narrow (obj.in ());
//
// Get a reference to the server.
//
obj = orb->string_to_object ( ior );
if (CORBA::is_nil (obj.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("(%P) orb->string_to_object ")
ACE_TEXT ("(\"file://server.ior\") failed.\n")),
-1);
}
//
// Downcast the IOR to the appropriate object type.
//
server_var server_obj =
server::_narrow (obj.in ());
if (CORBA::is_nil (server_obj.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("(%P) server::_narrow(obj) failed.\n")),
-1);
}
//
// Create and activate the client.
//
client_i *servant = 0;
ACE_NEW_RETURN (servant,
client_i (server_obj.in ()),
-1);
PortableServer::ServantBase_var theClient = servant;
client_var client_ref = servant->_this ();
//
// Activate the POA manager.
//
PortableServer::POAManager_var mgr =
poa->the_POAManager ();
mgr->activate ();
//
// Set the server's callback and invoke the test request.
//
server_obj->set_client (client_ref.in ());
server_obj->test_request ("first secure callback to client");
//
// Repeat the callback test.
//
server_obj->set_client (client_ref.in ());
server_obj->test_request ("second secure callback to client");
server_obj->shutdown ();
poa->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception (ACE_TEXT ("Caught exception\n"));
return -1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
TAO_EC_Default_Factory::init_svcs ();
try
{
// ORB initialization boiler plate...
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var object =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa =
PortableServer::POA::_narrow (object.in ());
PortableServer::POAManager_var poa_manager =
poa->the_POAManager ();
poa_manager->activate ();
// ****************************************************************
TAO_EC_Event_Channel_Attributes attributes (poa.in (),
poa.in ());
attributes.consumer_reconnect = 1;
attributes.supplier_reconnect = 1;
TAO_EC_Event_Channel ec_impl (attributes);
ec_impl.activate ();
RtecEventChannelAdmin::EventChannel_var event_channel =
ec_impl._this ();
// ****************************************************************
// Obtain the consumer admin..
RtecEventChannelAdmin::ConsumerAdmin_var consumer_admin =
event_channel->for_consumers ();
// Obtain the supplier admin..
RtecEventChannelAdmin::SupplierAdmin_var supplier_admin =
event_channel->for_suppliers ();
// ****************************************************************
const int milliseconds = 50;
EC_Counting_Supplier first_supplier;
first_supplier.activate (consumer_admin.in (),
milliseconds);
first_supplier.connect (supplier_admin.in (),
0x00001111UL,
0x11110000UL,
0x00001111UL,
0x11110000UL);
EC_Counting_Supplier second_supplier;
second_supplier.activate (consumer_admin.in (),
milliseconds);
second_supplier.connect (supplier_admin.in (),
0x01100000UL,
0x00000110UL,
0x01100000UL,
0x00000110UL);
// ****************************************************************
EC_Counting_Consumer consumer_bitmask_reject ("Consumer/bitmask/reject");
// Create a consumer, intialize its RT_Info structures, and
// connnect to the event channel....
{
ACE_ConsumerQOS_Factory consumer_qos;
consumer_qos.start_bitmask (0x00001111, 0x11110000);
consumer_qos.start_disjunction_group (1);
consumer_qos.insert (0x01100000, 0x00000110, 0);
consumer_bitmask_reject.connect (consumer_admin.in (),
consumer_qos.get_ConsumerQOS ());
}
// ****************************************************************
EC_Counting_Consumer consumer_bitmask_accept ("Consumer/bitmask/accept");
// Create a consumer, intialize its RT_Info structures, and
// connnect to the event channel....
{
ACE_ConsumerQOS_Factory consumer_qos;
consumer_qos.start_bitmask (0x01100110, 0x01100110);
consumer_qos.insert_null_terminator ();
consumer_bitmask_accept.connect (consumer_admin.in (),
consumer_qos.get_ConsumerQOS ());
}
// ****************************************************************
EC_Counting_Consumer consumer_bitmask_filter ("Consumer/bitmask/filter");
// Create a consumer, intialize its RT_Info structures, and
// connnect to the event channel....
{
ACE_ConsumerQOS_Factory consumer_qos;
consumer_qos.start_bitmask (0x00000110, 0x01100000);
consumer_qos.insert_null_terminator ();
consumer_bitmask_filter.connect (consumer_admin.in (),
consumer_qos.get_ConsumerQOS ());
}
// ****************************************************************
EC_Counting_Consumer consumer_bitmask_value ("Consumer/bitmask/value");
// Create a consumer, intialize its RT_Info structures, and
// connnect to the event channel....
{
ACE_ConsumerQOS_Factory consumer_qos;
consumer_qos.start_disjunction_group (1);
consumer_qos.insert_bitmasked_value (0x11110000, 0x00001111,
0x01100000, 0x00000110);
consumer_bitmask_value.connect (consumer_admin.in (),
consumer_qos.get_ConsumerQOS ());
}
// ****************************************************************
EC_Counting_Consumer consumer_bitmask_loose ("Consumer/bitmask/loose");
// Create a consumer, intialize its RT_Info structures, and
// connnect to the event channel....
{
ACE_ConsumerQOS_Factory consumer_qos;
consumer_qos.start_disjunction_group (1);
consumer_qos.insert_bitmasked_value (0x11111111, 0x11111111,
0x01100000, 0x00000110);
consumer_bitmask_loose.connect (consumer_admin.in (),
consumer_qos.get_ConsumerQOS ());
}
// ****************************************************************
ACE_Time_Value tv (5, 0);
// Wait for events, using work_pending()/perform_work() may help
// or using another thread, this example is too simple for that.
orb->run (tv);
// ****************************************************************
consumer_bitmask_loose.disconnect ();
consumer_bitmask_value.disconnect ();
consumer_bitmask_filter.disconnect ();
consumer_bitmask_accept.disconnect ();
consumer_bitmask_reject.disconnect ();
// ****************************************************************
second_supplier.deactivate ();
second_supplier.disconnect ();
first_supplier.deactivate ();
first_supplier.disconnect ();
// ****************************************************************
event_channel->destroy ();
// ****************************************************************
poa->destroy (1, 1);
// ****************************************************************
consumer_bitmask_reject.dump_results (0, 5);
CORBA::ULong expected =
first_supplier.event_count
+ second_supplier.event_count;
consumer_bitmask_accept.dump_results (expected, 5);
expected = second_supplier.event_count;
consumer_bitmask_filter.dump_results (expected, 5);
expected = second_supplier.event_count;
consumer_bitmask_value.dump_results (expected, 5);
expected = second_supplier.event_count;
consumer_bitmask_loose.dump_results (expected, 5);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Service");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
if (parse_args(argc, argv) != 0) {
return 1;
}
// Create a bidirectional POA
CORBA::Object_var obj = orb->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa = PortableServer::POA::_narrow(obj.in());
PortableServer::POAManager_var poa_manager = root_poa->the_POAManager();
// Policies for the childPOA to be created.
CORBA::PolicyList policies(1);
policies.length(1);
CORBA::Any pol;
pol <<= BiDirPolicy::BOTH;
policies[0] =
orb->create_policy(BiDirPolicy::BIDIRECTIONAL_POLICY_TYPE, pol);
// Create POA as child of RootPOA with the above policies. This POA
// will receive request in the same connection in which it sent
// the request
PortableServer::POA_var poa = root_poa->create_POA("bidirPOA", poa_manager.in(), policies);
// Creation of bidirPOA is over. Destroy the Policy objects.
for (CORBA::ULong i = 0; i < policies.length (); ++i) {
policies[i]->destroy ();
}
poa_manager->activate ();
PortableServer::Servant_var<Simple_i> svt = new Simple_i(orb.in(), callback_count);
// Register and activate Simple servant
PortableServer::ObjectId_var id = poa->activate_object(svt.in());
obj = poa->id_to_reference(id.in());
Simple_var server = Simple::_narrow(obj.in());
CORBA::String_var ior = orb->object_to_string(server.in());
if (ior_output_file != ACE_TEXT("")) {
std::ofstream outfile(ACE_TEXT_ALWAYS_CHAR(ior_output_file.c_str()));
outfile << ior.in();
}
std::cout << "Activated as " << ior.in() << std::endl;
// Our own special orb->run() that knows how to callback clients
while (true) {
// returns 1 as soon as it has successfully called back.
if (svt->call_client()) {
break;
}
// We don't want to check for work pending, because we really want
// to simulate a normal orb->run() while adding the ability to call
// our routine which calls back to the client.
orb->perform_work();
}
std::cout << "Event loop finished." << std::endl;
CORBA::Boolean etherealize = true, wait = true;
poa->destroy(etherealize, wait);
orb->destroy();
return 0;
}
catch(const CORBA::Exception& ex) {
std::cerr << "Caught CORBA::Exception: " << std::endl << ex << std::endl;
}
return 1;
}
