int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
if (CORBA::is_nil (poa_object.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
// Install a persistent POA in order to achieve a persistent IOR
// for our object.
CORBA::PolicyList policies;
policies.length (2);
policies[0] =
root_poa->create_lifespan_policy(PortableServer::PERSISTENT);
policies[1] =
root_poa->create_id_assignment_policy (PortableServer::USER_ID);
PortableServer::POA_var persistent_poa =
root_poa->create_POA("persistent",
poa_manager.in (),
policies);
policies[0]->destroy ();
policies[1]->destroy ();
if (parse_args (argc, argv) != 0)
return 1;
UDP_i udp_i (orb.in ());
PortableServer::ObjectId_var id =
PortableServer::string_to_ObjectId ("UDP_Object");
persistent_poa->activate_object_with_id (id.in (),
&udp_i);
CORBA::Object_var obj =
persistent_poa->id_to_reference (id.in ());
UDP_var udp_var = UDP::_narrow (obj.in ());
// UDP_var udp_var = udp_i._this ();
if (CORBA::is_nil (udp_var.in ()))
ACE_DEBUG ((LM_DEBUG,
"Failed to narrow correct object reference.\n"));
CORBA::String_var ior =
orb->object_to_string (udp_var.in ());
ACE_DEBUG ((LM_DEBUG, "Activated as <%C>\n", ior.in ()));
// If the ior_output_file exists, output the ior to it
if (ior_output_file != 0)
{
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);
}
poa_manager->activate ();
orb->run ();
ACE_DEBUG ((LM_DEBUG, "event loop finished\n"));
root_poa->destroy (1, // ethernalize objects
0); // wait for completion
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught exception:");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
if (CORBA::is_nil (root_poa.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Panic: nil RootPOA\n"),
1);
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
// Make all oneways "reliable."
{
CORBA::Object_var manager_object =
orb->resolve_initial_references("ORBPolicyManager");
CORBA::PolicyManager_var policy_manager =
CORBA::PolicyManager::_narrow(manager_object.in());
if (CORBA::is_nil (policy_manager.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Panic: nil PolicyManager\n"),
1);
CORBA::Any policy_value;
policy_value <<= Messaging::SYNC_WITH_SERVER;
CORBA::PolicyList policies(1); policies.length(1);
policies[0] =
orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE,
policy_value);
policy_manager->set_policy_overrides (policies,
CORBA::ADD_OVERRIDE);
policies[0]->destroy ();
}
if (parse_args (argc, argv) != 0)
return 1;
Service *service_impl;
ACE_NEW_RETURN (service_impl,
Service(orb.in ()),
1);
PortableServer::ServantBase_var owner_transfer(service_impl);
PortableServer::ObjectId_var id =
root_poa->activate_object (service_impl);
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
Test::Service_var service =
Test::Service::_narrow (object.in ());
CORBA::String_var ior =
orb->object_to_string (service.in ());
// If the ior_output_file exists, output the ior to it
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);
poa_manager->activate ();
orb->run ();
ACE_DEBUG ((LM_DEBUG, "Event loop finished\n"));
service_impl->dump_results ();
root_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
{
// 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
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->string_to_object (ior);
UDP_var udp_var =
UDP::_narrow (object.in ());
if (CORBA::is_nil (udp_var.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%s> is nil.\n",
ior),
1);
// Activate POA to handle the call back.
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
if (CORBA::is_nil (poa_object.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
poa_manager->activate ();
// Instantiate reply handler
UDP_i udp_i (orb.in ());
PortableServer::ObjectId_var id =
root_poa->activate_object (&udp_i);
CORBA::Object_var object_act = root_poa->id_to_reference (id.in ());
UDP_var udpHandler_var =
UDP::_narrow (object_act.in ());
// Instantiate client
UDP_Client_i *client = new UDP_Client_i (orb.in (),
udp_var.in (),
udpHandler_var.in (),
msec,
iterations);
// let the client run in a separate thread
client->activate ();
// ORB loop, will be shut down by our client thread
orb->run ();
ACE_DEBUG ((LM_DEBUG, "event loop finished\n"));
root_poa->destroy (1, // ethernalize objects
0); // wait for completion
orb->destroy ();
client->wait ();
// it is save to delete the client, because the client was actually
// the one calling orb->shutdown () triggering the end of the ORB
// event loop.
delete client;
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught exception:");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
if (CORBA::is_nil (root_poa.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Panic: nil RootPOA\n"),
1);
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
CORBA::Object_var object =
orb->resolve_initial_references ("PolicyCurrent");
CORBA::PolicyCurrent_var policy_current =
CORBA::PolicyCurrent::_narrow (object.in ());
if (CORBA::is_nil (policy_current.in ()))
{
ACE_ERROR ((LM_ERROR, "ERROR: Nil policy current\n"));
return 1;
}
CORBA::Any scope_as_any;
scope_as_any <<= Messaging::SYNC_NONE;
CORBA::PolicyList policies(1); policies.length (1);
policies[0] =
orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE,
scope_as_any);
policy_current->set_policy_overrides (policies, CORBA::ADD_OVERRIDE);
policies[0]->destroy ();
if (parse_args (argc, argv) != 0)
return 1;
PortableServer::Servant_var<Echo_Caller> impl;
{
Echo_Caller * tmp;
// ACE_NEW_RETURN is the worst possible way to handle
// exceptions (think: what if the constructor allocates memory
// and fails?), but I'm not in the mood to fight for a more
// reasonable way to handle allocation errors in ACE.
ACE_NEW_RETURN (tmp,
Echo_Caller(orb.in()),
1);
impl = tmp;
}
PortableServer::ObjectId_var id =
root_poa->activate_object (impl.in ());
CORBA::Object_var object_act = root_poa->id_to_reference (id.in ());
Test::Echo_Caller_var server =
Test::Echo_Caller::_narrow (object_act.in ());
CORBA::String_var ior =
orb->object_to_string (server.in ());
// If the ior_output_file exists, output the ior to it
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);
poa_manager->activate ();
orb->run();
ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n"));
root_poa->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught in server:");
return 1;
}
return 0;
}
int
ServerApp::run (int argc, ACE_TCHAR* argv[])
{
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
// Parse the command-line args for this application.
// * Raises -1 if problems are encountered.
// * Returns 1 if the usage statement was explicitly requested.
// * Returns 0 otherwise.
int result = this->parse_args (argc, argv);
if (result != 0)
{
return result;
}
TheOrbShutdownTask::instance()->orb (orb.in ());
CORBA::Object_var obj
= orb->resolve_initial_references("RootPOA");
if (CORBA::is_nil(obj.in()))
{
ACE_ERROR((LM_ERROR,
"(%P|%t) Failed to resolve initial ref for 'RootPOA'.\n"));
throw TestException();
}
PortableServer::POA_var root_poa
= PortableServer::POA::_narrow(obj.in());
if (CORBA::is_nil(root_poa.in()))
{
ACE_ERROR((LM_ERROR,
"(%P|%t) Failed to narrow obj ref to POA interface.\n"));
throw TestException();
}
PortableServer::POAManager_var poa_manager
= root_poa->the_POAManager();
// Create the child POA.
CORBA::PolicyList policies(1);
policies.length(1);
policies[0] = root_poa->create_id_assignment_policy(PortableServer::USER_ID);
PortableServer::POA_var child_poa
= root_poa->create_POA("ChildPoa",
poa_manager.in(),
policies);
if (CORBA::is_nil(child_poa.in()))
{
ACE_ERROR((LM_ERROR, "(%P|%t) ERROR [ServerApp::run()]: "
"Failed to create the child POA.\n"));
throw TestException();
}
policies[0]->destroy ();
// Create the thread pool servant dispatching strategy object, and
// hold it in a (local) smart pointer variable.
TAO_Intrusive_Ref_Count_Handle<TAO::CSD::TP_Strategy> csd_tp_strategy =
new TAO::CSD::TP_Strategy();
csd_tp_strategy->set_num_threads(this->num_servants_);
// Tell the strategy to apply itself to the child poa.
if (csd_tp_strategy->apply_to(child_poa.in()) == false)
{
ACE_ERROR((LM_ERROR, "(%P|%t) ERROR [ServerApp::run()]: "
"Failed to apply custom dispatching strategy to child poa.\n"));
throw TestException();
}
FooServantList servants(this->ior_filename_.c_str(),
this->num_servants_,
this->num_clients_,
orb.in());
servants.create_and_activate(child_poa.in());
// Activate the POA Manager
poa_manager->activate();
ACE_DEBUG((LM_DEBUG,
"(%P|%t) ServerApp is ready. Running the ORB event loop.\n"));
// Run the ORB event loop.
orb->run();
ACE_DEBUG((LM_DEBUG,
"(%P|%t) ServerApp ORB has stopped running. "
"Stop the CSD strategy.\n"));
// Sleep for 2 second to let the done() two-way call complete
// before cleanup.
ACE_OS::sleep (2);
ACE_DEBUG((LM_DEBUG,
"(%P|%t) ServerApp is waiting for OrbShutdownTask.\n"));
TheOrbShutdownTask::instance()->wait ();
ACE_DEBUG((LM_DEBUG,
"(%P|%t) ServerApp is destroying the Root POA.\n"));
// Tear-down the root poa and orb.
root_poa->destroy(1, 1);
ACE_DEBUG((LM_DEBUG,
"(%P|%t) ServerApp is destroying the ORB.\n"));
orb->destroy();
ACE_DEBUG((LM_DEBUG,
"(%P|%t) ServerApp has completed running successfully.\n"));
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
PortableInterceptor::ORBInitializer_ptr temp_initializer;
ACE_NEW_RETURN (temp_initializer,
Server_ORBInitializer,
-1); // No exceptions yet!
PortableInterceptor::ORBInitializer_var initializer =
temp_initializer;
PortableInterceptor::register_orb_initializer (initializer.in ());
// Now we can create the ORB
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references ("RootPOA");
if (CORBA::is_nil (poa_object.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
poa_manager->activate ();
if (parse_args (argc, argv) != 0)
return 1;
CDR_Out_Arg_i server_impl (orb.in ());
PortableServer::ObjectId_var id =
root_poa->activate_object (&server_impl);
CORBA::Object_var test_obj =
root_poa->id_to_reference (id.in ());
Interop::CDR_Out_Arg_var server =
Interop::CDR_Out_Arg::_narrow (test_obj.in ());
CORBA::String_var ior =
orb->object_to_string (server.in ());
ACE_DEBUG ((LM_DEBUG,
"Interop::CDR_Out_Arg: <%C>\n",
ior.in ()));
// If the ior_output_file exists, output the ior to it
if (ior_output_file != 0)
{
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);
}
orb->run ();
ACE_DEBUG ((LM_DEBUG, "event loop finished\n"));
root_poa->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught exception in server:");
return 1;
}
return 0;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
MessageLog logger(HELLO_CALL_NUMBER);
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
PortableGroup::GOA_var root_poa =
PortableGroup::GOA::_narrow (poa_object.in ());
if (CORBA::is_nil (root_poa.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Panic: nil RootPOA\n"),
1);
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
// servant
Hello_Impl* hello_impl;
ACE_NEW_RETURN (hello_impl,
Hello_Impl (orb.in (), &logger),
1);
PortableServer::ServantBase_var owner_transfer (hello_impl);
if (parse_args (argc, argv) != 0)
return 2;
// create UIPMC reference
CORBA::String_var multicast_url =
CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR(uipmc_url));
CORBA::Object_var miop_ref =
orb->string_to_object (multicast_url.in ());
// create id
PortableServer::ObjectId_var id =
root_poa->create_id_for_reference (miop_ref.in ());
// activate Hello Object
root_poa->activate_object_with_id (id.in (),
hello_impl);
CORBA::String_var ior =
orb->object_to_string (miop_ref.in ());
ACE_DEBUG ((LM_DEBUG, "Activated as <%C>\n", ior.in ()));
// If the ior_output_file exists, output the ior to it
if (ior_output_file != 0)
{
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);
}
poa_manager->activate ();
orb->run ();
root_poa->destroy (1, 1);
orb->destroy ();
if (logger.report_statistics () == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"\n (%P|%t) ERROR: No single call got through to the server\n"),
3);
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught in server main ():");
return 4;
}
ACE_DEBUG ((LM_DEBUG,
"\n (%P|%t) server finished successfully..\n"));
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
if (::parse_args (argc, argv) != 0) return -1;
ORB_Initializer *temp_initializer = 0;
ACE_NEW_RETURN (temp_initializer,
ORB_Initializer,
-1); // No exceptions yet!
PortableInterceptor::ORBInitializer_var orb_initializer =
temp_initializer;
PortableInterceptor::register_orb_initializer (orb_initializer.in ());
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv, "Server ORB");
CORBA::Object_var poa_object =
orb->resolve_initial_references ("RootPOA");
if (CORBA::is_nil (poa_object.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
RolyPoly_i* roly_poly_impl;
ACE_NEW_RETURN (roly_poly_impl,
RolyPoly_i (orb.in ()),
1);
PortableServer::ServantBase_var owner_transfer (roly_poly_impl);
RolyPoly_var t =
roly_poly_impl->_this ();
CORBA::PolicyList policies; // Empty policy list.
CORBA::String_var ior =
orb->object_to_string (t.in ());
poa_manager->activate ();
FILE *output_file= ACE_OS::fopen (ior_file, "w");
if (output_file == 0)
{
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file <%s> for writing "
"IOR: %s",
ior.in ()),
1);
}
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
ACE_DEBUG ((LM_DEBUG, "Server is ready\n"));
// Run the ORB event loop.
orb->run ();
root_poa->destroy (1, 1);
orb->destroy ();
ACE_DEBUG ((LM_DEBUG, "Event loop finished.\n"));
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught exception:");
return -1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
// We do the command line parsing first
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
if (CORBA::is_nil (poa_object.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
CORBA::PolicyList policies;
policies.length (3);
policies[0] = root_poa->create_id_assignment_policy (
PortableServer::USER_ID);
policies[1] = root_poa->create_implicit_activation_policy (
PortableServer::NO_IMPLICIT_ACTIVATION);
policies[2] = root_poa->create_lifespan_policy (
PortableServer::PERSISTENT);
PortableServer::POA_var poa = root_poa->create_POA (
"PERS_POA", poa_manager.in (), policies);
for (CORBA::ULong i = 0; i < policies.length (); ++i)
{
policies[i]->destroy ();
}
// Instantiate the LCD_Display implementation class
Simple_Server_i display_impl (orb.in (), ACE_TEXT_ALWAYS_CHAR(key));
PortableServer::ObjectId_var id =
PortableServer::string_to_ObjectId ("IOGR_OID");
poa->activate_object_with_id (id.in(), &display_impl);
CORBA::Object_var server =
poa->id_to_reference (id.in ());
CORBA::String_var ior =
orb->object_to_string (server.in ());
ACE_DEBUG ((LM_DEBUG, "Activated as <%C>\n", ior.in ()));
// If the ior_output_file exists, output the ior to it
if (ior_output_file != 0)
{
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);
}
poa_manager->activate ();
orb->run ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught exception:");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
CORBA::ORB_var orb;
try {
// Initialize orb
orb = CORBA::ORB_init (argc, argv);
// Get reference to Root POA.
CORBA::Object_var obj
= orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa
= PortableServer::POA::_narrow (obj.in ());
// Get POA manager
PortableServer::POAManager_var poa_mgr = poa->the_POAManager ();
// Create a policy list. We use persistent objects with
// user-assigned IDs, and explicit activation.
CORBA::PolicyList policy_list;
policy_list.length (6);
policy_list[0] = poa->create_lifespan_policy (
PortableServer::TRANSIENT // REVISIT
);
policy_list[1] = poa->create_id_assignment_policy (
PortableServer::USER_ID
);
policy_list[2] = poa->create_implicit_activation_policy (
PortableServer::NO_IMPLICIT_ACTIVATION
);
policy_list[3] = poa->create_request_processing_policy (
PortableServer::USE_SERVANT_MANAGER
);
policy_list[4] = poa->create_servant_retention_policy (
PortableServer::NON_RETAIN
);
policy_list[5] = poa->create_thread_policy (
PortableServer::SINGLE_THREAD_MODEL
);
// Create a POA for all CCS elements.
PortableServer::POA_var ccs_poa
= poa->create_POA ("CCS_POA", poa_mgr.in (), policy_list);
// Create a controller and set static m_ctrl member
// for thermostats and thermometers.
Controller_impl ctrl_servant (ccs_poa.in (), "/tmp/CCS_assets");
Thermometer_impl::m_ctrl = &ctrl_servant;
// Create a reference for the controller and
// create the corresponding CORBA object.
PortableServer::ObjectId_var oid
= PortableServer::string_to_ObjectId (Controller_oid);
CORBA::Object_var ctrl
= ccs_poa->create_reference_with_id (
oid.in (), "IDL:acme.com/CCS/Controller:1.0"
);
// Get reference to initial naming context.
CosNaming::NamingContext_var inc
= resolve_init<CosNaming::NamingContext> (
orb.in (), "NameService"
);
// Attempt to create CCS context.
CosNaming::Name n;
n.length (1);
n[0].id = CORBA::string_dup ("CCS");
try {
CosNaming::NamingContext_var nc
= inc->bind_new_context (n);
} catch (const CosNaming::NamingContext::AlreadyBound &) {
// Fine, CCS context already exists.
}
// Force binding of controller reference to make
// sure it is always up-to-date.
n.length (2);
n[1].id = CORBA::string_dup ("Controller");
inc->rebind (n, ctrl.in ());
// Instantiate the servant locator for devices.
PortableServer::ServantManager_var locator =
new DeviceLocator_impl (&ctrl_servant);
// Set servant locator.
ccs_poa->set_servant_manager (locator.in ());
// Activate the POA manager.
poa_mgr->activate ();
// Accept requests
orb->run ();
}
catch (const CORBA::Exception & e) {
std::cerr << "Uncaught CORBA exception: "
<< e
<< std::endl;
return 1;
}
catch (...) {
assert (0); // Uncaught exception, dump core
}
return 0;
}
int
ServerApp::run_i(int argc, ACE_TCHAR *argv[])
{
// Initialize the ORB before parsing our own args.
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
// Parse the command-line args for this application.
// * Returns -1 if problems are encountered.
// * Returns 1 if the usage statement was explicitly requested.
// * Returns 0 otherwise.
int result = this->parse_args (argc, argv);
if (result != 0)
{
return result;
}
TheAppShutdown->init(orb.in(), num_clients_);
// Get the Root POA
PortableServer::POA_var root_poa =
RefHelper<PortableServer::POA>::resolve_initial_ref(orb.in(),
"RootPOA");
// Get the POAManager from the Root POA.
PortableServer::POAManager_var poa_manager
= root_poa->the_POAManager();
// Create the child POA Policies.
CORBA::PolicyList policies(0);
policies.length(0);
// Create the child POA
PortableServer::POA_var child_poa =
AppHelper::create_poa("ChildPoa",
root_poa.in(),
poa_manager.in(),
policies);
// Create the servant object.
Foo_A_i* servant = new Foo_A_i();
// Local smart pointer variable to deal with releasing the reference
// to the servant object when the variable falls out of scope.
PortableServer::ServantBase_var servant_owner(servant);
// Obtain the object reference using the servant
CORBA::Object_var obj = AppHelper::activate_servant(child_poa.in(),
servant);
// Stringify and save the object reference to a file
AppHelper::ref_to_file(orb.in(),
obj.in(),
this->ior_filename_.c_str());
// Activate the POA Manager
poa_manager->activate();
ACE_DEBUG((LM_DEBUG,
"(%P|%t) ServerApp is ready. Running the ORB event loop.\n"));
// Run the ORB event loop.
orb->run ();
ACE_DEBUG((LM_DEBUG,
"(%P|%t) ServerApp ORB event loop has completed.\n"));
TheAppShutdown->wait ();
// Calling wait on ACE_Thread_Manager singleton to avoid the problem
// that the main thread might exit before all CSD Threads exit.
// Wait for all CSD task threads exit.
ACE_Thread_Manager::instance ()->wait ();
ACE_DEBUG((LM_DEBUG,
"(%P|%t) ServerApp is destroying the Root POA.\n"));
root_poa->destroy(1, 1);
ACE_DEBUG((LM_DEBUG,
"(%P|%t) ServerApp is destroying the ORB.\n"));
orb->destroy();
ACE_DEBUG((LM_DEBUG,
"(%P|%t) ServerApp has completed running successfully.\n"));
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
Server_ORBInitializer2 *temp_initializer = 0;
ACE_NEW_RETURN (temp_initializer,
Server_ORBInitializer2,
-1); // No exceptions yet!
PortableInterceptor::ORBInitializer_var orb_initializer =
temp_initializer;
PortableInterceptor::register_orb_initializer (orb_initializer.in ());
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
if (CORBA::is_nil (root_poa.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Panic: nil RootPOA\n"),
-1);
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
CORBA::PolicyList policies (2);
policies.length (2);
policies[0] =
root_poa->create_id_assignment_policy (PortableServer::USER_ID);
policies[1] =
root_poa->create_lifespan_policy (PortableServer::PERSISTENT);
PortableServer::POA_var my_poa =
root_poa->create_POA ("my_poa",
poa_manager.in (),
policies);
// Creation of the new POA is over, so destroy the Policy_ptr's.
for (CORBA::ULong i = 0; i < policies.length (); ++i)
{
CORBA::Policy_ptr policy = policies[i];
policy->destroy ();
}
if (parse_args (argc, argv) != 0)
return -1;
Hello *hello_impl = 0;
ACE_NEW_RETURN (hello_impl,
Hello (orb.in (), Test::Hello::_nil (), my_id_number),
-1);
PortableServer::ServantBase_var owner (hello_impl);
PortableServer::ObjectId_var server_id =
PortableServer::string_to_ObjectId ("server_id");
my_poa->activate_object_with_id (server_id.in (),
hello_impl);
CORBA::Object_var hello =
my_poa->id_to_reference (server_id.in ());
CORBA::String_var ior =
orb->object_to_string (hello.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", ior.in ());
ACE_OS::fclose (output_file);
poa_manager->activate ();
orb->run ();
root_poa->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return -1;
}
return 0;
}
int acserrOldTestServer (char *szCmdLn){
ACE_OS_Object_Manager ace_os_object_manager;
ACE_Object_Manager ace_object_manager;
int argc;
char *argv[100];
argc = argUnpack(szCmdLn, argv);
argv[0] = "acserrOldTestServer";
#else
int acserrOldTestServer (int argc, char *argv[]){
#endif // defined( MAKE_VXWORKS )
if (argc<2){
ACE_OS::printf ("usage: errorServer <server_name> [destination_server_name] \n");
return -1;
}
ACE_OS::signal(SIGINT, TerminationSignalHandler); // Ctrl+C
ACE_OS::signal(SIGTERM, TerminationSignalHandler); // termination request
// create logging proxy
LoggingProxy m_logger (0, 0, 31, 0);
LoggingProxy::init (&m_logger);
// creating ORB
ACS_TEST_INIT_CORBA;
// init ACS error system (and inside also logging)
ACSError::init (orb.ptr());
try
{
//Get a reference to the RootPOA
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();
#ifdef MAKE_VXWORKS
ACSError::processName (szCmdLn);
#else
char *buf;
ACE_OS::argv_to_string (argv, buf);
ACSError::processName (buf);
delete[] buf;
#endif
ACS_DEBUG ("errorServer", "Creating test object ...");
acserrOldTest_var dest;
if (argc>2){
ACS_DEBUG ("errorServer", "Getting object reference ... ");
char refName[64];
sprintf(refName, "file://%s.ior", argv[2]);
CORBA::Object_var destObj = orb->string_to_object (refName);
ACS_DEBUG ("errorServer", "Narrowing it .... ");
dest = acserrOldTest::_narrow (destObj.in());
}//if
acserrOldTestImpl esTest (dest.in(), argv[1]);
acserrOldTest_var testObj = esTest._this ();
poa_manager->activate ();
ACS_DEBUG ("errorServer","POA Manager -> activate");
ACS_DEBUG_PARAM ("errorServer", "Writing ior to the file: %s .... ", argv[1]);
char* ior = orb->object_to_string (testObj.in());
char fileName[64];
sprintf(fileName, "%s.ior", argv[1]);
FILE *output_file = ACE_OS::fopen (fileName, "w");
if (output_file == 0) {
ACS_SHORT_LOG((LM_ERROR,
"Cannot open output files for writing IOR: ior.ior"));
return -1;
}
int result = ACE_OS::fprintf (output_file, "%s", ior);
if (result < 0) {
ACS_SHORT_LOG ((LM_ERROR,
"ACE_OS::fprintf failed while writing %s to ior.ior\n", ior));
return -1;
}
ACE_OS::fclose (output_file);
ACS_DEBUG ("errorServer", "Waiting for requests ...");
orb->run ();
}
catch( CORBA::Exception &ex )
{
ex._tao_print_exception("EXCEPTION CAUGHT");
return -1;
}
// orb->shutdown(true); //wait until all requests have completed
LoggingProxy::done();
std::cout << std::flush;
sleep(3);
return 0;
}//startErrorServer
#ifndef MAKE_VXWORKS
int main(int argc, char *argv[])
{
return acserrOldTestServer (argc, argv);
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
PortableInterceptor::ORBInitializer_ptr temp_initializer = 0;
ACE_NEW_RETURN (temp_initializer,
Server_ORBInitializer (),
-1); // No exceptions yet!
PortableInterceptor::ORBInitializer_var initializer =
temp_initializer;
PortableInterceptor::register_orb_initializer (initializer.in ());
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 root_poa =
PortableServer::POA::_narrow (poa_object.in ());
if (CORBA::is_nil (root_poa.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Panic: nil RootPOA\n"),
1);
PortableServer::POAManager_var poa_manager = root_poa->the_POAManager ();
Hello *hello_impl = 0;
ACE_NEW_RETURN (hello_impl,
Hello (orb.in ()),
1);
PortableServer::ServantBase_var owner_transfer(hello_impl);
PortableServer::ObjectId_var id =
root_poa->activate_object (hello_impl);
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
Test::Hello_var hello = Test::Hello::_narrow (object.in ());
CORBA::String_var ior = orb->object_to_string (hello.in ());
// Output the IOR to the <output_filename>
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", ior.in ());
ACE_OS::fclose (output_file);
poa_manager->activate ();
orb->run ();
ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n"));
root_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");
if (CORBA::is_nil (poa_object.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
Simple_Server_i server_impl (orb.in ());
PortableServer::ObjectId_var id =
root_poa->activate_object (&server_impl);
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
Simple_Server_var server =
Simple_Server::_narrow (object.in ());
CORBA::String_var ior =
orb->object_to_string (server.in ());
if (remove_object)
{
PortableServer::ObjectId_var oid = root_poa->reference_to_id(server.in());
root_poa->deactivate_object(oid.in());
ACE_DEBUG ((LM_DEBUG,
"server (%P) deactivated object immediately\n"
));
}
// ACE_DEBUG ((LM_DEBUG, "Activated as <%C>\n", ior.in ()));
// If the ior_output_file exists, output the ior to it
if (ior_output_file != 0)
{
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);
}
poa_manager->activate ();
orb->run ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught exception:");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
if (CORBA::is_nil (poa_object.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
if (parse_args (argc, argv) != 0)
return 1;
Roundtrip *roundtrip_impl = 0;
ACE_NEW_RETURN (roundtrip_impl,
Roundtrip (orb.in ()),
1);
PortableServer::ServantBase_var owner_transfer(roundtrip_impl);
PortableServer::ObjectId_var oid =
root_poa->activate_object (roundtrip_impl);
CORBA::Object_var roundtrip =
root_poa->id_to_reference (oid.in ());
CORBA::String_var ior =
orb->object_to_string (roundtrip.in ());
// If the ior_output_file exists, output the ior to it
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);
poa_manager->activate ();
orb->run ();
ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n"));
root_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[])
{
#if defined (ACE_WIN32)
ACE_UNUSED_ARG (argc);
ACE_UNUSED_ARG (argv);
cout << "HandleExhaustion test not available on Windows" << endl;
#else
try
{
#if !defined (ACE_LACKS_RLIMIT) && defined (RLIMIT_NOFILE)
// We must make sure that our file descriptor limit does not exceed
// the size allowed (in the fd set) by the reactor. If it does, this
// test will fail (in a different way than expected) which is a
// completely different bug than this test is designed to address
// (see Bug #3326).
//
// We must also make sure that this happens before creating the first
// ORB. Otherwise, the reactor will be created with a maximum size of
// the current rlimit for file desriptors (which will later on be
// increased).
rlimit rlim;
if (ACE_OS::getrlimit(RLIMIT_NOFILE, &rlim) == 0)
{
cout << "server evaluating rlimit, cur = "
<< rlim.rlim_cur << " max = " << rlim.rlim_max
<< " reactor max = "
<< ACE_DEFAULT_SELECT_REACTOR_SIZE << endl;
if (rlim.rlim_cur < static_cast<rlim_t> (ACE_DEFAULT_SELECT_REACTOR_SIZE) &&
rlim.rlim_max > static_cast<rlim_t> (ACE_DEFAULT_SELECT_REACTOR_SIZE))
{
rlim.rlim_cur = ACE_DEFAULT_SELECT_REACTOR_SIZE;
rlim.rlim_max = ACE_DEFAULT_SELECT_REACTOR_SIZE;
ACE_OS::setrlimit(RLIMIT_NOFILE, &rlim);
cout << "server set rlimit_nofile" << endl;
}
}
#else
cout << "server does not support setting rlimit, reactor max = "
<< ACE_DEFAULT_SELECT_REACTOR_SIZE << endl;
#endif /* !ACE_LACKS_RLIMIT && RLIMIT_NOFILE */
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
if (CORBA::is_nil (root_poa.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Panic: nil RootPOA\n"),
1);
if (parse_args (argc, argv) != 0)
return 1;
Test_i* test_i;
ACE_NEW_RETURN (test_i,
Test_i (orb.in ()),
1);
PortableServer::ServantBase_var owner_transfer(test_i);
PortableServer::ObjectId_var id = root_poa->activate_object (test_i);
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
Test_var test = Test::_narrow (object.in ());
CORBA::String_var ior = orb->object_to_string (test.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 %s for writing IOR: %C\n",
ior_output_file,
ior.in ()),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
poa_manager->activate ();
Descriptors descriptors;
descriptors.leak (
#ifdef _WRS_KERNEL
"server.out");
#else
argv[0]);
#endif
ACE_Time_Value tv (10);
orb->run (tv);
cout << "Server: closing some fds" << endl;
descriptors.allow_accepts ();
orb->run ();
orb->destroy ();
if (!descriptors.ok ())
{
cout << "Server: the accept error never occurred" << endl;
ACE_ERROR_RETURN ((LM_ERROR, "The accept error never occurred\n"), 1);
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
#endif /* ACE_WIN32 */
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
// All factories are kindly provided by
// compiler so we just to put everything in a right order.
// Create and register factory for BaseNode.
BaseNode_init *bn_factory = 0;
ACE_NEW_RETURN (bn_factory,
BaseNode_init,
1);
orb->register_value_factory (bn_factory->tao_repository_id (),
bn_factory);
bn_factory->_remove_ref (); // release ownership
// Create and register factory for TreeController.
TreeController_init *tc_factory = 0;
ACE_NEW_RETURN (tc_factory,
TreeController_init,
1);
orb->register_value_factory (tc_factory->tao_repository_id (),
tc_factory);
tc_factory->_remove_ref (); // release ownership
// Create and register factory for StringNode.
StringNode_init *sn_factory = 0;
ACE_NEW_RETURN (sn_factory,
StringNode_init,
1);
orb->register_value_factory (sn_factory->tao_repository_id (),
sn_factory);
sn_factory->_remove_ref (); // release ownership
//Well, done with factories.
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
if (CORBA::is_nil (root_poa.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Panic: nil RootPOA\n"),
1);
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
if (parse_args (argc, argv) != 0)
return 1;
Test_impl *test_impl;
ACE_NEW_RETURN (test_impl,
Test_impl (orb.in ()),
1);
PortableServer::ServantBase_var owner_transfer(test_impl);
PortableServer::ObjectId_var id =
root_poa->activate_object (test_impl);
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
Test_var test = Test::_narrow (object.in ());
CORBA::String_var ior =
orb->object_to_string (test.in ());
// If the ior_output_file exists, output the ior to it
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);
poa_manager->activate ();
orb->run ();
ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n"));
root_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);
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
if (CORBA::is_nil (root_poa.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"backend_server(%P|%t) - panic: nil RootPOA\n"),
1);
}
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var tmp = orb->string_to_object(ior);
// one second in TimeT units
TimeBase::TimeT const second = 10 * TimeBase::TimeT(1000000);
CORBA::Any timeout_as_any;
timeout_as_any <<= TimeBase::TimeT(timeout * second);
CORBA::Any scope_as_any;
scope_as_any <<= scope;
TAO::Utils::PolicyList_Destroyer plist(1);
plist.length(2);
plist[0] =
orb->create_policy(Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE,
timeout_as_any);
plist[1] =
orb->create_policy(Messaging::SYNC_SCOPE_POLICY_TYPE,
scope_as_any);
CORBA::PolicyCurrent_var policy_current =
TAO::Utils::RIR_Narrow<CORBA::PolicyCurrent>::narrow(
orb.in (),
"PolicyCurrent");
policy_current->set_policy_overrides(
plist, CORBA::ADD_OVERRIDE);
Bug_3647_Regression::Backend_var backend =
Bug_3647_Regression::Backend::_narrow(tmp.in ());
if (CORBA::is_nil (backend.in ()))
{
ACE_ERROR_RETURN ((LM_DEBUG,
"middle_server(%P|%t) - nil backend reference <%s>\n",
ior),
1);
}
using namespace Bug_3647_Regression;
PortableServer::ServantBase_var impl(
new Middle_Impl(backend.in(), orb.in(), verbose,
timeout));
PortableServer::ObjectId_var id =
root_poa->activate_object (impl.in());
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
Bug_3647_Regression::Middle_var middle =
Bug_3647_Regression::Middle::_narrow (object.in ());
CORBA::String_var ior = orb->object_to_string (middle.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,
"middle_server(%P|%t) - Cannot open output file "
"for writing IOR: %s\n",
ior_output_file),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
poa_manager->activate ();
orb->run ();
ACE_DEBUG ((LM_DEBUG,
"middle_server(%P|%t) - event loop finished\n"));
root_poa->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ACE_DEBUG ((LM_DEBUG,
"middle_server"));
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::Object_var object;
// ORB.
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
// Parse arguments.
if (parse_args (argc, argv) != 0)
return -1;
// RootPOA.
object =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (object.in ());
// POAManager.
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
// Servant.
Test_i servant (orb.in ());
// Create the first object in Root POA
create_object (root_poa.in (),
orb.in (),
&servant,
simple_servant_ior_file);
object =
orb->resolve_initial_references ("NetworkPriorityMappingManager");
RTCORBA::NetworkPriorityMappingManager_var mapping_manager =
RTCORBA::NetworkPriorityMappingManager::_narrow (object.in ());
Custom_Network_Priority_Mapping *cnpm = 0;
ACE_NEW_RETURN (cnpm,
Custom_Network_Priority_Mapping,
-1);
cnpm->corba_priority (corba_priority);
mapping_manager->mapping (cnpm);
// RTORB.
object =
orb->resolve_initial_references ("RTORB");
RTCORBA::RTORB_var rt_orb =
RTCORBA::RTORB::_narrow (object.in ());
// Set transport protocol properties
RTCORBA::TCPProtocolProperties_var tcp_properties =
rt_orb->create_tcp_protocol_properties (ACE_DEFAULT_MAX_SOCKET_BUFSIZ,
ACE_DEFAULT_MAX_SOCKET_BUFSIZ,
1,
0,
1,
1);
RTCORBA::ProtocolList protocols;
protocols.length (1);
protocols[0].protocol_type = 0;
protocols[0].transport_protocol_properties =
RTCORBA::ProtocolProperties::_duplicate (tcp_properties.in ());
protocols[0].orb_protocol_properties =
RTCORBA::ProtocolProperties::_nil ();
CORBA::PolicyList policy_list;
policy_list.length (1);
policy_list[0] =
rt_orb->create_server_protocol_policy (protocols);
// Create POA with Diffserv enabled
PortableServer::POA_var poa_with_diffserv =
root_poa->create_POA ("POA_WITH_DS",
poa_manager.in (),
policy_list);
// Create object 2.
create_object (poa_with_diffserv.in (),
orb.in (),
&servant,
diffserv_servant_ior_file);
// Activate POA manager.
poa_manager->activate ();
// Start ORB event loop.
orb->run ();
ACE_DEBUG ((LM_DEBUG, "Server ORB event loop finished\n\n"));
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Unexpected exception caught:");
return -1;
}
return 0;
}
int main(int argc, char *argv[])
{
CosNaming::NamingContext_var naming_context;
int nargc=0;
char **nargv=0;
const char *hn=ACSPorts::getIP();
ACE_CString iorFile;
if (argc>=2 && !ACE_OS_String::strcmp(argv[1], "-?")) {
ACE_OS::printf ("USAGE: acsLogSvc [-ORBInitRef NameService=iiop://yyy:xxxx/NameService] [-ORBEndpoint iiop://ip:port] [-o iorfile] [-silent]\n");
return -1;
}
// here we have to unset ACS_LOG_CENTRAL that we prevent filtering of log messages
char *logCent=getenv("ACS_LOG_CENTRAL");
if (logCent)
{
unsetenv("ACS_LOG_CENTRAL");
printf("Unset ACS_LOG_CENTRAL which was previously set to %s\n", logCent);
}//if
// create logging proxy
LoggingProxy::ProcessName(argv[0]);
ACE_Log_Msg::instance()->local_host(hn);
LoggingProxy m_logger (0, 0, 31, 0);
LoggingProxy::init (&m_logger);
ACS_SHORT_LOG((LM_INFO, "Logging proxy successfully created !"));
ACE_CString argStr;
for(int i=1; i<argc; i++)
{
argStr += argv[i];
argStr += " ";
if (!ACE_OS_String::strcmp(argv[i], "-o") && (i+1)<argc)
{
iorFile = argv[i+1];
}//if
}//for
if (argStr.find ("-ORBEndpoint")==ACE_CString::npos)
{
argStr = argStr + "-ORBEndpoint iiop://" + hn + ":" + ACSPorts::getLogPort().c_str();
}
ACS_SHORT_LOG((LM_INFO, "New command line is: %s", argStr.c_str()));
ACE_OS::string_to_argv ((ACE_TCHAR*)argStr.c_str(), nargc, nargv);
ACE_OS::signal(SIGINT, TerminationSignalHandler); // Ctrl+C
ACE_OS::signal(SIGTERM, TerminationSignalHandler); // termination request
try
{
// Initialize the ORB
ACE_OS::printf ("Initialising ORB ... \n");
orb = CORBA::ORB_init (nargc, nargv, 0);
ACE_OS::printf ("ORB initialsed !\n");
}
catch( CORBA::Exception &ex )
{
ex._tao_print_exception("Failed to initalise ORB");
return -1;
}
if (!ACSError::init(orb.in()))
{
ACS_SHORT_LOG ((LM_ERROR, "Failed to initalise the ACS Error System"));
return -1;
}
// resolve naming service
try
{
ACS_SHORT_LOG((LM_INFO, "Trying to connect to the Naming Service ...."));
CORBA::Object_var naming_obj = orb->resolve_initial_references ("NameService");
if (!CORBA::is_nil (naming_obj.in ()))
{
naming_context = CosNaming::NamingContext::_narrow (naming_obj.in ());
ACS_SHORT_LOG((LM_INFO, "Connected to the Name Service"));
}
else
{
ACS_SHORT_LOG((LM_ERROR, "Could not connect the Name Service!"));
return -1;
}//if-else
}
catch( CORBA::Exception &_ex )
{
ACS_SHORT_LOG((LM_ERROR, "Could not connect the Name Service!"));
return -1;
}
// logging service
try
{
CORBA::Object_var log_obj;
/*
if (argStr.find ("-ORBInitRef NameService=")!=ACE_CString::npos)
{
// Initialize the ORB
ACE_OS::printf ("Initialising ORB ... \n");
orb = CORBA::ORB_init (nargc, nargv, 0);
ACE_OS::printf ("ORB initialsed !\n");
//Naming Service
ACE_OS::printf ("Resolving Naming service ... \n");
CORBA::Object_var naming_obj =
orb->resolve_initial_references ("NameService");
if (!CORBA::is_nil (naming_obj.in ()))
{
CosNaming::NamingContext_var naming_context =
CosNaming::NamingContext::_narrow (naming_obj.in ());
ACE_OS::printf ( "Naming Service resolved !\n");
*/
ACE_OS::printf ( "Resolving Logging Service from Naming service ...\n");
CosNaming::Name name;
name.length(1);
name[0].id = CORBA::string_dup("Log");
log_obj = naming_context->resolve(name);
/*
}
else
{
ACS_LOG(LM_SOURCE_INFO, "main", (LM_ERROR, "Failed to initialise the Name Service!"));
}
}//if naming Service
else
{
ACE_OS::printf ("Getting Log from the Manager... \n");
CORBA::ULong status;
maci::Manager_ptr manager = maci::MACIHelper::resolveManager (orb.in(), nargc, nargv, 0, 0);
log_obj = manager->get_COB(0, "Log", true, status);
}
*/
if (!CORBA::is_nil (log_obj.in()))
{
Logging::AcsLogService_var logger = Logging::AcsLogService::_narrow(log_obj.in());
ACE_OS::printf ( "Logging Service resolved !\n");
m_logger.setCentralizedLogger(logger.in());
}
else
{
ACS_LOG(LM_SOURCE_INFO, "main", (LM_ERROR, "Failed to initialise the Logging Service!"));
return -1;
}//if-else
}
catch( CORBA::Exception &__ex )
{
__ex._tao_print_exception("Failed to get and set the centralized logger");
return -1;
}
try
{
//Get a reference to the RootPOA
ACE_OS::printf("Creating POA ... \n");
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();
CORBA::PolicyList policy_list;
policy_list.length(5);
policy_list[0] = root_poa->create_request_processing_policy (PortableServer::USE_DEFAULT_SERVANT);
policy_list[1] = root_poa->create_id_uniqueness_policy (PortableServer::MULTIPLE_ID);
policy_list[2] = root_poa->create_id_assignment_policy(PortableServer::USER_ID);
policy_list[3] = root_poa->create_servant_retention_policy(PortableServer::NON_RETAIN);
policy_list[4] = root_poa->create_lifespan_policy (PortableServer::PERSISTENT);
printf("policies are created !\n");
PortableServer::POA_var poa = root_poa->create_POA("ACSLogSvc", poa_manager.in(), policy_list);
ACE_OS::printf("POA created !\n");
for (CORBA::ULong i = 0; i < policy_list.length (); ++i) {
CORBA::Policy_ptr policy = policy_list[i];
policy->destroy ();
}
printf("Policies are destroyed !\n");
ACSLogImpl acsLogSvc (m_logger);
poa->set_servant (&acsLogSvc);
PortableServer::ObjectId_var oid = PortableServer::string_to_ObjectId ("ACSLogSvc");
obj = poa->create_reference_with_id (oid.in(), acsLogSvc._interface_repository_id());
CORBA::String_var ior = orb->object_to_string (obj.in());
// if ther is file name write ior in it
if (iorFile.length()!=0)
{
FILE *output_file = ACE_OS::fopen (iorFile.c_str(), "w");
if (output_file == 0)
{
ACS_SHORT_LOG ((LM_ERROR,
"Cannot open output files for writing IOR: ior.ior"));
return -1;
}//if
int result = ACE_OS::fprintf (output_file, "%s", ior.in());
if (result < 0)
{
ACS_SHORT_LOG ((LM_ERROR,
"ACE_OS::fprintf failed while writing %s to ior.ior", ior.in()));
return -1;
}//if
ACE_OS::fclose (output_file);
ACS_SHORT_LOG((LM_INFO, "ACSLogSvc's IOR has been written into: %s", iorFile.c_str()));
}//if
// adding ACSLog to NamingService
if (!CORBA::is_nil (naming_context.in ()))
{
// register cdb server in Naming service
CosNaming::Name name (1);
name.length (1);
name[0].id = CORBA::string_dup ("ACSLogSvc");
naming_context->rebind (name, obj.in ());
ACS_SHORT_LOG((LM_INFO, "ACSLogSvc service registered with Naming Services"));
}//if
CORBA::Object_var table_object =
orb->resolve_initial_references ("IORTable");
IORTable::Table_var adapter =
IORTable::Table::_narrow (table_object.in ());
if (CORBA::is_nil (adapter.in ()))
{
ACS_SHORT_LOG ((LM_ERROR, "Nil IORTable"));
}
else
{
adapter->bind ("ACSLogSvc", ior.in ());
}
poa_manager->activate ();
ACS_SHORT_LOG((LM_INFO, "ACSLogSvc is waiting for incoming log messages ..."));
if (argStr.find ("-ORBEndpoint")!=ACE_CString::npos)
m_logger.setStdio(31);
orb->run ();
ACSError::done();
LoggingProxy::done();
}
catch( 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);
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
if (CORBA::is_nil (root_poa.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Panic: nil RootPOA\n"),
1);
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
if (parse_args (argc, argv) != 0)
return 1;
PortableServer::Servant_var<Simple_C> simple_c_impl(
new Simple_C(orb.in()));
PortableServer::ObjectId_var id =
root_poa->activate_object (simple_c_impl.in ());
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
Baz::C_var simple_c =
Baz::C::_narrow (object.in ());
CORBA::String_var ior =
orb->object_to_string (simple_c.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",
ior_output_file),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
poa_manager->activate ();
orb->run ();
ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n"));
root_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[])
{
DANCE_DISABLE_TRACE ();
int retval = 0;
try
{
DAnCE::Logger_Service * dlf =
ACE_Dynamic_Service<DAnCE::Logger_Service>::instance ("DAnCE_Logger");
if (dlf)
{
dlf->init (argc, argv);
}
DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_TRACE, DLINFO
ACE_TEXT("PL_Daemon - initializing ORB\n")));
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_TRACE, DLINFO
ACE_TEXT("PL_Daemon - initializing module instance\n")));
TAO::Utils::ORB_Destroyer safe_orb (orb);
CORBA::Object_var poa_obj
= orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa
= PortableServer::POA::_narrow (poa_obj.in ());
PortableServer::POAManager_var mgr = poa->the_POAManager ();
PortableServer::POA_var persistent_poa;
TAO::Utils::PolicyList_Destroyer policies (2);
policies.length (2);
try
{
DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_TRACE, DLINFO ACE_TEXT("PL_Daemon - ")
ACE_TEXT("before creating the \"Managers\" POA.\n")));
policies[0] = poa->create_id_assignment_policy (PortableServer::USER_ID);
policies[1] = poa->create_lifespan_policy (PortableServer::PERSISTENT);
persistent_poa = poa->create_POA ("Managers",
mgr.in(),
policies);
}
catch (const PortableServer::POA::AdapterAlreadyExists &)
{
persistent_poa = poa->find_POA ("Managers", 0);
}
DAnCE::Plan_Launcher_Daemon_i *pl_daemon (0);
ACE_NEW_RETURN (pl_daemon,
DAnCE::Plan_Launcher_Daemon_i (orb.in ()),
0);
PortableServer::ServantBase_var safe_servant (pl_daemon);
PortableServer::ObjectId_var oid =
PortableServer::string_to_ObjectId ("Plan_Launcher_Daemon");
persistent_poa->activate_object_with_id (oid, pl_daemon);
CORBA::Object_var pl_obj = persistent_poa->id_to_reference (oid.in ());
CORBA::String_var pl_ior = orb->object_to_string (pl_obj.in ());
DAnCE::Utility::write_IOR (ACE_TEXT ("PL_Daemon.ior"),
pl_ior.in ());
orb->run ();
DANCE_TRACE_LOG (DANCE_LOG_TRACE, (LM_TRACE, DLINFO
ACE_TEXT("PL_Daemon - destroying ORB\n")));
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
DANCE_ERROR (DANCE_LOG_EMERGENCY,
(LM_EMERGENCY, DLINFO
"PL_Daemon - Error - CORBA Exception :%C\n",
ex._info ().c_str ()));
retval = -1;
}
catch (...)
{
DANCE_ERROR (DANCE_LOG_EMERGENCY,
(LM_ERROR, "PL_Daemon - Error: Unknown exception.\n"));
retval = -1;
}
return retval;
}
int main (int argc, char** argv)
{
try {
for (int i = 1; i < argc; i++) {
if (!strcmp(argv[i], "-sysConf")) {
if ((i+1) < argc)
sysConf = new SWConfig(argv[i+1]);
}
}
swordMgr = new WebMgr(sysConf);
const char* options[][2] = {
{ "nativeCharCodeSet", "UTF-8" }
, { 0, 0 }
};
// Initialise the ORB.
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv, "omniORB4", options);
// Obtain a reference to the root POA.
CORBA::Object_var obj = orb->resolve_initial_references("RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow(obj);
// We allocate the objects on the heap. Since these are reference
// counted objects, they will be deleted by the POA when they are no
// longer needed.
// swordorb_SWModule_i* myswordorb_SWModule_i = new swordorb_SWModule_i();
swordorb_SWMgr_i* myswordorb_SWMgr_i = new swordorb_SWMgr_i(swordMgr);
// Activate the objects. This tells the POA that the objects are
// ready to accept requests.
// PortableServer::ObjectId_var myswordorb_SWModule_iid = poa->activate_object(myswordorb_SWModule_i);
PortableServer::ObjectId_var myswordorb_SWMgr_iid = poa->activate_object(myswordorb_SWMgr_i);
{
// IDL interface: swordorb::SWMgr
CORBA::Object_var ref = myswordorb_SWMgr_i->_this();
CORBA::String_var sior(orb->object_to_string(ref));
std::cout << (char*)sior << std::endl;
}
// Obtain a POAManager, and tell the POA to start accepting
// requests on its objects.
PortableServer::POAManager_var pman = poa->the_POAManager();
pman->activate();
orb->run();
orb->destroy();
}
catch(CORBA::TRANSIENT&) {
std::cerr << "Caught system exception TRANSIENT -- unable to contact the "
<< "server." << std::endl;
}
catch(CORBA::SystemException& ex) {
std::cerr << "Caught a CORBA::" << ex._name() << std::endl;
}
catch(CORBA::Exception& ex) {
std::cerr << "Caught CORBA::Exception: " << ex._name() << std::endl;
}
catch(omniORB::fatalException& fe) {
std::cerr << "Caught omniORB::fatalException:" << std::endl;
std::cerr << " file: " << fe.file() << std::endl;
std::cerr << " line: " << fe.line() << std::endl;
std::cerr << " mesg: " << fe.errmsg() << std::endl;
}
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
// Initialize the ORB.
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
CORBA::ORB_var s_orb;
// Find the Naming Service.
CORBA::Object_var obj = orb->resolve_initial_references ("NameService");
CosNaming::NamingContextExt_var root_context =
CosNaming::NamingContextExt::_narrow (obj.in ());
obj = root_context->resolve_str ("CosEventService");
// Downcast the object reference to an EventChannel reference.
CosEventChannelAdmin::EventChannel_var ec =
CosEventChannelAdmin::EventChannel::_narrow (obj.in ());
if (CORBA::is_nil (ec.in ()))
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Could not narrow the EventChannel.\n")));
return 1;
}
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Found the EventChannel.\n")));
bool consumer = false;
bool supplier = false;
bool hang = false;
for (int i=1; i < argc; ++i)
{
if (0 == ACE_OS::strcasecmp (argv[i], ACE_TEXT ("-consumer")))
consumer = true;
else if (0 == ACE_OS::strcasecmp (argv[i], ACE_TEXT ("-supplier")))
supplier = true;
else if (0 == ACE_OS::strcasecmp (argv[i], ACE_TEXT ("-hang")))
hang = true;
}
TestEventConsumer_i servant (orb.in (), hang);
if (consumer)
{
// Register it with the RootPOA.
obj = orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa =
PortableServer::POA::_narrow (obj.in ());
PortableServer::ObjectId_var oid = poa->activate_object (&servant);
CORBA::Object_var consumer_obj = poa->id_to_reference (oid.in ());
CosEventComm::PushConsumer_var consumer =
CosEventComm::PushConsumer::_narrow (consumer_obj.in ());
// Get a ConsumerAdmin object from the EventChannel.
CosEventChannelAdmin::ConsumerAdmin_var consumerAdmin =
ec->for_consumers ();
// Get a ProxyPushSupplier from the ConsumerAdmin.
CosEventChannelAdmin::ProxyPushSupplier_var supplier =
consumerAdmin->obtain_push_supplier ();
// Connect to the ProxyPushSupplier, passing our PushConsumer object
// reference to it.
supplier->connect_push_consumer (consumer.in ());
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Consumer connected\n")));
// Activate the POA via its POAManager.
PortableServer::POAManager_var poa_manager = poa->the_POAManager ();
poa_manager->activate ();
servant.activate ();
}
ACE_Auto_Ptr<SupplierTask> pST;
if (supplier)
{
// The supplier will use its own ORB.
CORBA::String_var ec_str = orb->object_to_string (ec.in ());
int no_args = 0;
ACE_TCHAR **no_argv = 0;
s_orb = CORBA::ORB_init (no_args, no_argv,
"Supplier_pure_client_ORB");
CORBA::Object_var s_ec_obj = s_orb->string_to_object (ec_str.in ());
CosEventChannelAdmin::EventChannel_var s_ec =
CosEventChannelAdmin::EventChannel::_narrow (s_ec_obj.in ());
// Get a SupplierAdmin object from the EventChannel.
CosEventChannelAdmin::SupplierAdmin_var supplierAdmin =
s_ec->for_suppliers ();
// Get a ProxyPushConsumer from the SupplierAdmin.
CosEventChannelAdmin::ProxyPushConsumer_var consumer =
supplierAdmin->obtain_push_consumer ();
// Connect to the ProxyPushConsumer as a PushSupplier
// (passing a nil PushSupplier object reference to it because
// we don't care to be notified about disconnects).
consumer->connect_push_supplier
(CosEventComm::PushSupplier::_nil ());
SupplierTask *tmp = 0;
ACE_NEW_RETURN (tmp, SupplierTask (consumer.in (), s_orb.in ()), -1);
pST.reset (tmp);
pST->activate ();
}
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Ready to receive events...\n")));
// Enter the ORB event loop.
orb->run ();
ACE_Thread_Manager::instance ()->wait ();
if (!CORBA::is_nil (s_orb.in ()))
{
s_orb->destroy ();
}
orb->destroy ();
return 0;
}
catch (CORBA::Exception &ex)
{
ex._tao_print_exception (
ACE_TEXT (
"TimeoutTest: Caught CORBA::Exception:"));
}
return 1;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try {
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
int server_num = 0;
int init_delay_secs = 0;
ACE_Get_Opt get_opts (argc, argv, ACE_TEXT ("d:n:?"));
int c;
while ((c = get_opts ()) != -1)
switch (c)
{
case 'd':
init_delay_secs = ACE_OS::atoi (get_opts.opt_arg ());
break;
case 'n':
server_num = ACE_OS::atoi (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;
}
ACE_OS::sleep (init_delay_secs);
CORBA::Object_var obj = orb->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa = PortableServer::POA::_narrow(obj.in());
PortableServer::POAManager_var mgr = root_poa->the_POAManager();
ACE_CString poa_name = ACE_CString("TestObject_") + toStr (server_num);
PortableServer::POA_var test_poa = createPOA(root_poa.in(), poa_name.c_str ());
Terminator terminator;
if (terminator.open (0) == -1)
ACE_ERROR_RETURN((LM_ERROR,
ACE_TEXT ("main Error opening terminator\n")),-1);
PortableServer::Servant_var<Test_i> test_servant =
new Test_i(server_num, terminator);
PortableServer::ObjectId_var object_id =
PortableServer::string_to_ObjectId("test_object");
//
// Activate the servant with the test POA,
// obtain its object reference, and get a
// stringified IOR.
//
test_poa->activate_object_with_id(object_id.in(), test_servant.in());
//
// 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*>(test_poa.in());
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(poa_name.c_str (), test_ior.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.
//
mgr->activate();
ACE_DEBUG ((LM_DEBUG,
"Started Server %s \n",
poa_name.c_str()));
{
ACE_CString status_file = poa_name + ACE_CString(".status");
ofstream out(status_file.c_str ());
out << "started" << endl;
}
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
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var object =
orb->resolve_initial_references ("RTORB");
RTCORBA::RTORB_var rtorb =
RTCORBA::RTORB::_narrow (object.in ());
object =
orb->resolve_initial_references ("ORBPolicyManager");
CORBA::PolicyManager_var policy_manager =
CORBA::PolicyManager::_narrow (object.in ());
int parse_args_result =
parse_args (argc, argv);
if (parse_args_result != 0)
return parse_args_result;
object =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
object =
orb->string_to_object (ior);
test_var receiver =
test::_narrow (object.in ());
test_i *servant =
new test_i (orb.in (),
root_poa.in (),
rtorb.in (),
policy_manager.in (),
receiver.in ());
PortableServer::ServantBase_var safe_servant (servant);
ACE_UNUSED_ARG (safe_servant);
test_var test =
servant->_this ();
CORBA::String_var ior =
orb->object_to_string (test.in ());
FILE *output_file =
ACE_OS::fopen (ior_file, "w");
ACE_ASSERT (output_file != 0);
u_int result =
ACE_OS::fprintf (output_file,
"%s",
ior.in ());
ACE_ASSERT (result == ACE_OS::strlen (ior.in ()));
ACE_UNUSED_ARG (result);
ACE_OS::fclose (output_file);
poa_manager->activate ();
orb->run ();
ACE_OS::sleep(1);
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught");
return -1;
}
return 0;
}
int
Consumer::run (int argc, ACE_TCHAR* argv[])
{
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);
// Do *NOT* make a copy because we don't want the ORB to outlive
// the run() method.
this->orb_ = orb.in ();
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 name (1);
name.length (1);
name[0].id = CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR(ecname));
CORBA::Object_var ec_obj =
naming_context->resolve (name);
RtecEventChannelAdmin::EventChannel_var event_channel =
RtecEventChannelAdmin::EventChannel::_narrow (ec_obj.in ());
if (CORBA::is_nil (event_channel.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to get Event Channel.\n"),
1);
// The canonical protocol to connect to the EC
RtecEventChannelAdmin::ConsumerAdmin_var consumer_admin =
event_channel->for_consumers ();
RtecEventChannelAdmin::ProxyPushSupplier_var supplier =
consumer_admin->obtain_push_supplier ();
RtecEventComm::PushConsumer_var consumer =
this->_this ();
ACE_ConsumerQOS_Factory qos;
qos.start_disjunction_group ();
qos.insert (MY_SOURCE_ID, // Source ID
MY_EVENT_TYPE, // Event Type
0); // handle to the rt_info
for (int i = 0; i < 10; i++)
{
qos.insert (MY_SOURCE_ID + i, // Source ID
MY_EVENT_TYPE + i, // Event Type
0); // handle to the rt_info
}
supplier->connect_push_consumer (consumer.in (), qos);
// Wait for events, using work_pending()/perform_work() may help
// or using another thread, this example is too simple for that.
orb->run ();
// We don't do any cleanup, it is hard to do it after shutdown,
// and would complicate the example; plus it is almost
// impossible to do cleanup after ORB->run() because the POA is
// in the holding state. Applications should use
// work_pending()/perform_work() to do more interesting stuff.
// Check the supplier for the proper way to do cleanup.
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Consumer::run");
return 1;
}
return 0;
}
/**
* starts the server for the component installer object
*/
int
main (int argc, char** argv)
{
std::cout << "Qedo Component Installer " << QEDO_VERSION << std::endl;
//
// Resolve config values from config file
//
if (! strcmp (Qedo::ConfigurationReader::instance()->lookup_config_value ("/General/VerboseOutput"), "true"))
{
Qedo::debug_output = true;
}
for (int i = 1; i < argc; i++)
{
if (! strcmp (argv[i], "--verbose"))
{
Qedo::debug_output = true;
}
}
//
// get the qedo dir
//
Qedo::g_qedo_dir = Qedo::getEnvironment( "QEDO" );
if(Qedo::g_qedo_dir.empty())
{
std::cout << "Missing Environment Variable QEDO" << std::endl;
std::cout << "Assuming current dir as local deployment dir" << std::endl;
Qedo::g_qedo_dir = Qedo::getCurrentDirectory();
}
std::cout << "..... Qedo directory is " << Qedo::g_qedo_dir << std::endl;
//
// init ORB
//
orb = CORBA::ORB_init (argc, argv);
Qedo::ComponentInstallationImpl* component_installation = new Qedo::ComponentInstallationImpl (orb);
try
{
component_installation->initialize();
}
catch (Qedo::ComponentInstallationImpl::CannotInitialize&)
{
std::cerr << "Cannot initialize Component Installer... exiting." << std::endl;
orb->destroy();
exit (1);
}
#ifdef HAVE_SIGACTION
struct sigaction act;
/* Assign sig_chld as our SIGINT handler */
act.sa_handler = handle_sigint;
/* We don't want to block any other signals in this example */
sigemptyset(&act.sa_mask);
/*
* Make these values effective. If we were writing a real
* application, we would probably save the old value instead of
* passing NULL.
*/
if (sigaction(SIGINT, &act, NULL) < 0)
{
std::cerr << "sigaction failed" << std::endl;
return 1;
}
#else
signal ( SIGINT, handle_sigint );
#endif
std::cout << "Qedo Component Installer is up and running ...\n";
orb->run();
return 0;
}