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;
Memory_Growth *memory;
ACE_NEW_RETURN (memory,
Memory_Growth (orb.in ()),
1);
PortableServer::ServantBase_var owner_transfer(memory);
Test::Memory_Growth_var mem =
memory->_this ();
CORBA::String_var ior =
orb->object_to_string (mem.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 ();
// Run the evnt loop for ever
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
{
// Initialize the ORB.
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
// Initialize options based on command-line arguments.
int parse_args_result = parse_args (argc, argv);
if (parse_args_result != 0)
return parse_args_result;
CORBA::Object_var base =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (base.in ());
// Get an object reference from the argument string.
base = orb->string_to_object (IOR);
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
poa_manager->activate ();
// Try to narrow the object reference to a <test> reference.
test_var test_object = test::_narrow (base.in ());
Reply_Handler reply_handler_servant;
AMI_testHandler_var reply_handler_object = reply_handler_servant._this ();
if (setup_buffering)
{
setup_buffering_constraints (orb.in ());
}
for (CORBA::ULong i = 1; i <= iterations; ++i)
{
ACE_DEBUG ((LM_DEBUG,
"client: Iteration %d @ %T\n",
i));
if (invoke_ami_style)
{
// Invoke the AMI method.
test_object->sendc_method (reply_handler_object.in (),
i);
}
else
{
CORBA::ULong reply_number = 0;
// Invoke the regular method.
test_object->method (i,
reply_number);
ACE_DEBUG ((LM_DEBUG,
"client: Regular Reply %d @ %T\n",
reply_number));
}
// Interval between successive calls.
ACE_Time_Value sleep_interval (0,
interval * 1000);
orb->run (sleep_interval);
}
// Loop until all replies have been received.
while (!received_all_replies)
{
orb->perform_work ();
}
// Shutdown server.
if (shutdown_server)
{
test_object->shutdown ();
}
root_poa->destroy (1,
1);
// Destroy the ORB. On some platforms, e.g., Win32, the socket
// library is closed at the end of main(). This means that any
// socket calls made after main() fail. Hence if we wait for
// static destructors to flush the queues, it will be too late.
// Therefore, we use explicit destruction here and flush the
// queues before main() ends.
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return -1;
}
return 0;
}
// Initialize the server.
template <class Servant> int
Server<Servant>::init (const char *servant_name,
int argc,
ACE_TCHAR *argv[])
{
// Call the init of <TAO_ORB_Manager> to initialize the ORB and
// create a child POA under the root POA.
if (this->orb_manager_.init_child_poa (argc,
argv,
"child_poa") == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("init_child_poa")),
-1);
this->argc_ = argc;
this->argv_ = argv;
int retval = this->parse_args ();
if (retval != 0)
return retval;
CORBA::ORB_var orb = this->orb_manager_.orb ();
// Stash our ORB pointer for later reference.
this->servant_->orb (orb.in ());
// Activate the servant in its own child POA.
// Make sure that you check for failures here via the try?!
try
{
CORBA::String_var str =
this->orb_manager_.activate_under_child_poa (servant_name,
this->servant_.in ());
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("The IOR is: <%C>\n"),
str.in ()));
if (this->ins_ && this->test_for_ins (str.in ()) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("test_for_ins (): failed\n")),
-1);
if (this->ior_output_file_)
{
FILE *fh = ACE_OS::fopen (this->ior_output_file_, "w");
if (fh == 0)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("Unable to open %s for writing (%p)\n"),
this->ior_output_file_,
ACE_TEXT ("fopen")),
-1);
ACE_OS::fprintf (fh, "%s", str.in ());
ACE_OS::fclose (fh);
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("\tException in activation of POA");
return -1;
}
return 0;
}
int
Server_Worker::test_main (int argc, ACE_TCHAR *argv[])
{
try
{
// Making sure there are no stale ior files to confuse a client
ACE_OS::unlink (ior_file_.c_str ());
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,
ACE_TEXT ("(%P|%t) Panic: nil RootPOA\n")),
1);
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
if (parse_args (argc, argv) != 0)
return 1;
Hello *hello_impl;
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 hello_obj =
root_poa->id_to_reference (id.in ());
Test::Hello_var hello =
Test::Hello::_narrow (hello_obj.in ());
CORBA::String_var ior =
orb->object_to_string (hello.in ());
poa_manager->activate ();
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Server activated POA manager\n")));
// Output the IOR to the <ior_output_file>
FILE *output_file= ACE_OS::fopen (ior_file_.c_str (), "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("(%P|%t) Cannot open output file %s for writing IOR: %C"),
ior_file_.c_str (),
ior.in ()),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Server entering the event loop\n")));
orb->run ();
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Server exiting the event loop\n")));
root_poa->destroy (1, 1);
// During normal test execution the ORB would have been destroyed
// by a request from the client.
// orb->shutdown (0);
orb->destroy ();
}
catch (const ::CORBA::Exception &e)
{
e._tao_print_exception("Server_Worker::test_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 obj
= orb->resolve_initial_references ("RootPOA");
// Get the POA_var object from Object_var
PortableServer::POA_var root_poa
= PortableServer::POA::_narrow (obj.in ());
PortableServer::POAManager_var mgr
= root_poa->the_POAManager ();
mgr->activate ();
// Initialize the AV Stream components.
/* TAO_AV_CORE::instance ()->init (orb.in (),
root_poa.in ()); */
// Initialize the AVStreams components.
TAO_AV_CORE::instance ()->init (orb.in (), root_poa.in ());
// Initialize the Sender.
int result = 0;
result = SENDER::instance ()->init (argc,
argv);
if (result < 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Sender::init failed\n"),
-1);
// Make sure we have a valid <output_file>
output_file = ACE_OS::fopen (output_file_name,
"w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_DEBUG,
"Cannot open output file %s\n",
output_file_name),
-1);
else
ACE_DEBUG ((LM_DEBUG,
"File Opened Successfully\n"));
// Start sending data.
result = SENDER::instance ()->pace_data ();
ACE_Time_Value tv(3,0);
orb->run (tv);
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Sender Failed\n");
return -1;
}
SENDER::close (); // Explicitly finalize the Unmanaged_Singleton.
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
int retval = 0;
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var tmp =
orb->string_to_object(ior);
Test::Hello_var hello =
Test::Hello::_narrow(tmp.in ());
if (CORBA::is_nil (hello.in ()))
{
ACE_ERROR_RETURN ((LM_DEBUG,
"Nil Test::Hello reference <%s>\n",
ior),
1);
}
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
poa_manager->activate ();
// Let the client perform the test in a separate thread
Client_Task client (hello.in (),
orb.in (),
ACE_Thread_Manager::instance ());
if (client.activate (THR_NEW_LWP | THR_JOINABLE, nthreads) != 0)
{
ACE_ERROR_RETURN ((LM_ERROR,
"ERROR - Cannot activate client threads\n"),
1);
}
ACE_Time_Value thread_deadline = ACE_OS::gettimeofday();
thread_deadline += 30;
if(client.thr_mgr ()->wait (&thread_deadline) == -1)
{
ACE_ERROR((LM_ERROR,
"ERROR - Timeout waiting for client threads\n"));
retval = 1;
}
root_poa->destroy (1, // ethernalize objects
0); // wait for completion
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return retval;
}
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;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
// Create the ORB initializer.
Server_ORBInitializer *temp_initializer = 0;
ACE_NEW_RETURN (temp_initializer,
Server_ORBInitializer,
-1);
PortableInterceptor::ORBInitializer_var initializer =
temp_initializer;
PortableInterceptor::register_orb_initializer (initializer.in ());
// Now initialize the ORB.
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv,
"Remote_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 ();
poa_manager->activate ();
if (parse_args (argc, argv) != 0)
{
return 1;
}
// Create the interceptor.
Echo_Server_Request_Interceptor * server_interceptor =
temp_initializer->server_interceptor();
if (server_interceptor == 0)
{
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) Could not obtain reference to "
"server request interceptor.\n"),
-1);
}
// Pull in the ior from the remote server to use as the forward location.
CORBA::Object_var forward_location = orb->string_to_object (ior_input_file);
if (CORBA::is_nil (forward_location.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%s> is nil\n",
ior_input_file),
1);
}
server_interceptor->forward_reference (forward_location.in ());
Bug1495_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 ());
Bug1495_Regression::Bug1495_var server =
Bug1495_Regression::Bug1495::_narrow (test_obj.in ());
CORBA::String_var ior =
orb->object_to_string (server.in ());
// Output the server IOR to a file
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 the "
"server IOR: %s", ior_output_file),
1);
}
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
}
ACE_Time_Value tv (15, 0);
orb->run (tv);
if (server_interceptor->forward_location_done() == false)
{
ACE_ERROR ((LM_ERROR, "ERROR: Forward location has not occured!\n"));
}
ACE_DEBUG ((LM_DEBUG, "Threaded Server event loop finished\n"));
root_poa->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught an exception in server:");
return 1;
}
ACE_DEBUG ((LM_DEBUG, "Threaded Server ready\n"));
return 0;
}
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);
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"));
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");
if (CORBA::is_nil (poa_object.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("SERVER: 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;
// Servant
test_i *servant = 0;
ACE_NEW_RETURN (servant,
test_i (0, orb.in ()),
-1);
PortableServer::ServantBase_var safe (servant);
PortableServer::ObjectId_var oid =
root_poa->activate_object (servant);
CORBA::Object_var obj =
root_poa->servant_to_reference (servant);
CORBA::String_var ior =
orb->object_to_string (obj.in ());
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("SERVER: test_i servant: <%C>\n"),
ior.in ()));
poa_manager->activate ();
// IOR
FILE *output_file= ACE_OS::fopen (ior_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("SERVER: Cannot open output file <%s> ")
ACE_TEXT ("for writting IOR: %C"),
ior_file,
ior.in ()),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
// Run the ORB event loop.
orb->run ();
root_poa->destroy (1, 1);
orb->destroy ();
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("SERVER: 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[])
{
int priority =
(ACE_Sched_Params::priority_min (ACE_SCHED_FIFO)
+ ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2;
priority = ACE_Sched_Params::next_priority (ACE_SCHED_FIFO,
priority);
priority = ACE_Sched_Params::next_priority (ACE_SCHED_FIFO,
priority);
// Enable FIFO scheduling, e.g., RT scheduling class on Solaris.
if (ACE_OS::sched_params (ACE_Sched_Params (ACE_SCHED_FIFO,
priority,
ACE_SCOPE_PROCESS)) != 0)
{
if (ACE_OS::last_error () == EPERM)
{
ACE_DEBUG ((LM_DEBUG,
"server (%P|%t): user is not superuser, "
"test runs in time-shared class\n"));
}
else
ACE_ERROR ((LM_ERROR,
"server (%P|%t): sched_params failed\n"));
}
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;
ACE_NEW_RETURN (roundtrip_impl,
Roundtrip (orb.in ()),
1);
PortableServer::ServantBase_var owner_transfer(roundtrip_impl);
Test::Roundtrip_var roundtrip =
roundtrip_impl->_this ();
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 ();
Server_Task server_task (orb.in ());
if (server_task.activate (THR_NEW_LWP | THR_JOINABLE,
nthreads) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot activate server threads\n"),
1);
server_task.thr_mgr ()->wait ();
ACE_DEBUG ((LM_DEBUG, "event loop finished\n"));
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 obj = orb->resolve_initial_references("NameService");
CosNaming::NamingContextExt_var naming_context =
CosNaming::NamingContextExt::_narrow(obj.in());
obj = naming_context->resolve_str("MyEventChannel");
CosNotifyChannelAdmin::EventChannel_var ec =
CosNotifyChannelAdmin::EventChannel::_narrow(obj.in());
CosNotifyChannelAdmin::AdminID adminid;
CosNotifyChannelAdmin::InterFilterGroupOperator ifgop =
CosNotifyChannelAdmin::AND_OP;
CosNotifyChannelAdmin::ConsumerAdmin_var consumer_admin =
ec->new_for_consumers(ifgop,
adminid);
obj = orb->resolve_initial_references("RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow (obj.in());
PortableServer::Servant_var<EventSequenceConsumer_i> servant =
new EventSequenceConsumer_i(orb.in());
PortableServer::ObjectId_var objectId = poa->activate_object(servant.in());
obj = poa->id_to_reference (objectId.in());
CosNotifyComm::SequencePushConsumer_var consumer =
CosNotifyComm::SequencePushConsumer::_narrow(obj.in());
CosNotifyChannelAdmin::ProxyID consumeradmin_proxy_id;
CosNotifyChannelAdmin::ProxySupplier_var proxy_supplier =
consumer_admin->obtain_notification_push_supplier(
CosNotifyChannelAdmin::SEQUENCE_EVENT,
consumeradmin_proxy_id);
CosNotifyChannelAdmin::SequenceProxyPushSupplier_var supplier_proxy =
CosNotifyChannelAdmin::SequenceProxyPushSupplier::_narrow(proxy_supplier.in());
supplier_proxy->connect_sequence_push_consumer(consumer.in());
CosNotification::EventTypeSeq added (1);
CosNotification::EventTypeSeq removed (1);
added.length (1);
removed.length (1);
added[0].domain_name = CORBA::string_dup ("OCI_TAO");
added[0].type_name = CORBA::string_dup ("examples");
removed[0].domain_name = CORBA::string_dup ("*");
removed[0].type_name = CORBA::string_dup ("*");
supplier_proxy->subscription_change(added, removed);
PortableServer::POAManager_var poa_manager = poa->the_POAManager();
poa_manager->activate();
orb->run();
orb->destroy();
return 0;
}
catch(const CORBA::Exception& ex)
{
std::cerr << "Caught exception: " << ex << std::endl;
}
return 1;
}
int main(int argc, char** argv)
{
ProgOptions po;
initProgOptions(po,argc,argv);
const char* name;
const char* passwd;
const char* alias;
name=po.argument("name");
passwd=po.argument("passwd");
alias=po.argument("alias");
if (alias==NULL) alias = "";
if (name==NULL || passwd==NULL) {
cerr << "please, use name and password" << endl;
return 1;
}
try {
#ifdef CORBA_ORB_INIT_HAVE_3_ARGS
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv, CORBA_ORB_INIT_THIRD_ARG);
#else
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
#endif
initUAKGQueryService(orb.in());
CORBA::Object_var obj;
try {
obj = orb->resolve_initial_references("UAKGQueryService");
}catch(const CORBA::ORB::InvalidName&){
cerr << argv[0] << ": can't resolve UAKGQueryService" << endl;
return 1;
}
if(CORBA::is_nil(obj)) {
cerr << argv[0] << ": UAKGQueryService is a nil object reference" << endl;
return 1;
}
DBConnectionManager_var dbManager = DBConnectionManager::_narrow(obj);
if (CORBA::is_nil(dbManager)) {
cerr << argv[0] << ": can't narrow dbManager to correct type" << endl;
return 1;
}
QueryManager_var queryManager;
try {
queryManager =
dbManager->createQueryManager(name,passwd,alias,"Oracle8","");
}catch(QueryManagerNotFound){
cerr << argv[0] <<": can't find query manager." << endl;
return 1;
}
cout << "\t BEGIN TESTS." << endl;
run_tests(queryManager);
cout << "\t END TESTS." << endl;
//time to disconnect.
//
cout << "disconnecting." << endl;
queryManager->destroy();
orb -> destroy();
}catch(const CORBA::SystemException& ex){
printSystemException(cerr,ex);
return 1;
}
return 0;
}
int TestTask::svc()
{
try {
// Get reference to Root POA
CORBA::Object_var obj = orb_->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow (obj.in ());
// Activate POA Manager
PortableServer::POAManager_var mgr = poa->the_POAManager ();
mgr->activate ();
// Find the Naming Service
obj = orb_->string_to_object (
"corbaloc:iiop:1.2@localhost:9932/NameService");
CosNaming::NamingContext_var rootB =
CosNaming::NamingContext::_narrow (obj.in ());
if (CORBA::is_nil (rootB.in ())) {
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Error, Nil Naming Context reference\n")));
return 1;
}
// Bind the example Naming Context, if necessary
CosNaming::NamingContext_var example_nc;
CosNaming::Name name;
name.length(1);
name[0].id = CORBA::string_dup( "example");
try
{
obj = rootB->resolve (name);
example_nc =
CosNaming::NamingContext::_narrow (obj.in ());
}
catch (const CosNaming::NamingContext::NotFound&)
{
example_nc = rootB->bind_new_context (name);
}
// Bind the Test object
name.length (2);
name[1].id = CORBA::string_dup ("Hello");
// Create an object
Hello servant (orb_.in ());
PortableServer::ObjectId_var oid = poa->activate_object (&servant);
obj = poa->id_to_reference (oid.in ());
rootB->rebind (name, obj.in ());
ACE_DEBUG ((LM_INFO,
ACE_TEXT ("Hello object bound in Naming Service B\n")));
name.length (1);
name[0].id = CORBA::string_dup ("nsB");
obj = orb_->string_to_object (
"corbaloc:iiop:1.2@localhost:9931/NameService");
CosNaming::NamingContext_var rootA =
CosNaming::NamingContext::_narrow (obj.in ());
rootA->bind_context (name, rootB.in ());
ACE_DEBUG ((LM_INFO,
ACE_TEXT ("Root context of NS B bound in Naming Service A ")
ACE_TEXT ("under name 'nsB'\n")));
CORBA::String_var ior =
orb_->object_to_string (obj.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,
ACE_TEXT ("Cannot open output file %s for writing ")
ACE_TEXT ("IOR: %C\n"),
ior_output_file,
ior.in ()),
1);
ACE_OS::fprintf (output_file, ACE_TEXT ("%s"), ior.in ());
ACE_OS::fclose (output_file);
ACE_DEBUG ((LM_INFO,
ACE_TEXT ("Wrote IOR file\n")));
// Normally we run the orb and the orb is shutdown by
// calling TestTask::end().
// Accept requests
orb_->run();
orb_->destroy();
return 0;
}
catch (CORBA::Exception& ex)
{
ex._tao_print_exception (ACE_TEXT ("CORBA exception: "));
}
return -1;
}
int
ACE_TMAIN (int argc,
ACE_TCHAR *argv[])
{
try
{
ACE_High_Res_Timer::global_scale_factor ();
// Initialize the ORB first.
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var obj
= orb->resolve_initial_references ("RootPOA");
// Get the POA_var object from Object_var.
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (obj.in ());
PortableServer::POAManager_var mgr
= root_poa->the_POAManager ();
mgr->activate ();
// Initialize the AVStreams components.
TAO_AV_CORE::instance ()->init (orb.in (),
root_poa.in ());
int result =
parse_args (argc,
argv);
if (result == -1)
return -1;
// Make sure we have a valid <output_file>
output_file = ACE_OS::fopen (output_file_name,
"w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_DEBUG,
"Cannot open output file %s\n",
output_file_name),
-1);
else
ACE_DEBUG ((LM_DEBUG,
"File Opened Successfully\n"));
Receiver receiver;
result =
receiver.init (argc,
argv);
if (result != 0)
return result;
while (!endstream)
{
orb->perform_work ();
}
// Hack for now....
ACE_OS::sleep (1);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("receiver::init");
return -1;
}
ACE_OS::fclose (output_file);
return 0;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
// Initialize the ORB first.
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
int result = parse_args (argc, argv);
if (result != 0)
return result;
// Obtain the RootPOA.
CORBA::Object_var obj =
orb->resolve_initial_references ("RootPOA");
// Get the POA_var object from Object_var.
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (obj.in ());
// Get the POAManager of the RootPOA.
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
Adapter_Activator adapter_activator (poa_manager.in (),
orb.in ());
root_poa->the_activator (&adapter_activator);
PortableServer::POA_var first_poa;
PortableServer::POA_var second_poa;
{
// Policies for the firstPOA to be created.
CORBA::PolicyList &policies = adapter_activator.first_poa_policies_;
policies.length (4);
// Id Assignment Policy
policies[0] =
root_poa->create_id_assignment_policy (PortableServer::SYSTEM_ID);
// Lifespan policy
policies[1] =
root_poa->create_lifespan_policy (PortableServer::PERSISTENT);
// Request Processing policy
policies[2] =
root_poa->create_request_processing_policy (PortableServer::USE_DEFAULT_SERVANT);
// Id Uniqueness
policies[3] =
root_poa->create_id_uniqueness_policy (PortableServer::MULTIPLE_ID);
// Create the firstPOA under the RootPOA.
first_poa = root_poa->create_POA ("firstPOA",
poa_manager.in (),
policies);
}
{
// Policies for the secondPOA to be created.
CORBA::PolicyList &policies = adapter_activator.second_poa_policies_;
policies.length (2);
// Id Assignment Policy
policies[0] =
root_poa->create_id_assignment_policy (PortableServer::USER_ID);
// Lifespan policy
policies[1] =
root_poa->create_lifespan_policy (PortableServer::PERSISTENT);
// Create the secondPOA under the firstPOA.
second_poa = first_poa->create_POA ("secondPOA",
poa_manager.in (),
policies);
}
// Create a servant.
reference_counted_test_i first_servant (orb.in (),
root_poa.in ());
PortableServer::ObjectId_var first_oid =
root_poa->activate_object (&first_servant);
// Get Object Reference for the first_servant object.
test_var first_test = first_servant._this ();
CORBA::Object_var second_test =
first_poa->create_reference ("IDL:test:1.0");
PortableServer::ObjectId_var third_oid =
PortableServer::string_to_ObjectId ("third test");
CORBA::Object_var third_test =
second_poa->create_reference_with_id (third_oid.in (),
"IDL:test:1.0");
// Stringyfy all the object references and print them out.
CORBA::String_var first_ior =
orb->object_to_string (first_test.in ());
CORBA::String_var second_ior =
orb->object_to_string (second_test.in ());
CORBA::String_var third_ior =
orb->object_to_string (third_test.in ());
ACE_DEBUG ((LM_DEBUG,
"%C\n%C\n%C\n",
first_ior.in (),
second_ior.in (),
third_ior.in ()));
int write_result = write_iors_to_file (first_ior.in (),
second_ior.in (),
third_ior.in ());
if (write_result != 0)
return write_result;
first_poa->destroy (1,
1);
poa_manager->activate ();
orb->run ();
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, "MY_TEST_ORB");
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var object =
orb->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (object.in ());
if (CORBA::is_nil (root_poa.in ()))
{
ACE_ERROR ((LM_ERROR,
"rootPOA is nil!\n"));
return -1;
}
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager();
// Run ORB Event loop.
poa_manager->activate ();
// Create task.
Task *task = 0;
ACE_NEW_RETURN (task,
Task (orb.in ()),
1);
IORTable::Locator_var owner_transfer (task);
// Resolve the IORTable and set the locator
CORBA::Object_var iorTableObj =
orb->resolve_initial_references("IORTable");
IORTable::Table_var local_ior_table =
IORTable::Table::_narrow (iorTableObj.in ());
local_ior_table->set_locator (task);
try
{
ACE_DEBUG ((LM_DEBUG,
"OK, now try to resolve a co-located "
"IORTable entry...\n"));
CORBA::Object_var clientObj = orb->string_to_object (testIOR);
simple::SimpleTest_T_var simpleTestClient =
simple::SimpleTest_T::_narrow (clientObj.in ());
if (CORBA::is_nil (simpleTestClient.in ()))
{
ACE_ERROR ((LM_ERROR,
"Simpe client is nil!\n"));
return 1;
}
ACE_DEBUG ((LM_DEBUG,
"We narrowed the object, now let's invoke it!\n"));
simpleTestClient->shutdown ();
}
catch(const CORBA::OBJ_ADAPTER &objAdapter)
{
objAdapter._tao_print_exception ("CAUGHT OBJ_ADAPTER!!!");
}
catch(const CORBA::OBJECT_NOT_EXIST &objNE)
{
objNE._tao_print_exception ("CAUGHT OBJECT NOT EXIST!!!");
}
ACE_DEBUG ((LM_DEBUG,
"Leaving!\n"));
}
catch (const CORBA::Exception &ex)
{
ex._tao_print_exception ("CAUGHT EXCEPTION: ");
return -1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
Fixed_Priority_Scheduler* scheduler=0;
RTScheduling::Current_var current;
long flags;
int sched_policy = ACE_SCHED_RR;
int sched_scope = ACE_SCOPE_THREAD;
if (sched_policy == ACE_SCHED_RR)
flags = THR_NEW_LWP | THR_BOUND | THR_JOINABLE | THR_SCHED_RR;
else
flags = THR_NEW_LWP | THR_BOUND | THR_JOINABLE | THR_SCHED_FIFO;
task_stats.init (100000);
try
{
RTScheduling::Scheduler_var sched_owner;
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;
if (enable_dynamic_scheduling)
{
CORBA::Object_var manager_obj =
orb->resolve_initial_references ("RTSchedulerManager");
TAO_RTScheduler_Manager_var manager =
TAO_RTScheduler_Manager::_narrow (manager_obj.in ());
Kokyu::DSRT_Dispatcher_Impl_t disp_impl_type;
if (enable_yield)
{
disp_impl_type = Kokyu::DSRT_CV_BASED;
}
else
{
disp_impl_type = Kokyu::DSRT_OS_BASED;
}
ACE_NEW_RETURN (scheduler,
Fixed_Priority_Scheduler (orb.in (),
disp_impl_type,
sched_policy,
sched_scope), -1);
sched_owner = scheduler;
manager->rtscheduler (scheduler);
CORBA::Object_var object =
orb->resolve_initial_references ("RTScheduler_Current");
current =
RTScheduling::Current::_narrow (object.in ());
}
Simple_Server_i server_impl (orb.in (),
current.in (),
task_stats,
enable_yield);
Simple_Server_var server =
server_impl._this ();
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 ();
Worker worker (orb.in ());
if (worker.activate (flags,
nthreads,
0,
ACE_Sched_Params::priority_max(sched_policy,
sched_scope)) != 0)
{
ACE_ERROR ((LM_ERROR,
"Cannot activate threads in RT class.",
"Trying to activate in non-RT class\n"));
flags = THR_NEW_LWP | THR_JOINABLE | THR_BOUND;
if (worker.activate (flags, nthreads) != 0)
{
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot activate server threads\n"),
1);
}
}
worker.wait ();
ACE_DEBUG ((LM_DEBUG, "event loop finished\n"));
ACE_DEBUG ((LM_DEBUG, "shutting down scheduler\n"));
scheduler->shutdown ();
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
ACE_DEBUG ((LM_DEBUG, "Exiting main...\n"));
task_stats.dump_samples (ACE_TEXT("timeline.txt"),
ACE_TEXT("Time\t\tGUID"));
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
int status = 0;
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;
Payload_Receiver *payload_receiver_impl;
ACE_NEW_RETURN (payload_receiver_impl,
Payload_Receiver (orb.in ()),
1);
PortableServer::ServantBase_var receiver_owner_transfer(payload_receiver_impl);
PortableServer::ObjectId_var id =
root_poa->activate_object (payload_receiver_impl);
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
Test::Payload_Receiver_var payload_receiver =
Test::Payload_Receiver::_narrow (object.in ());
CORBA::String_var ior =
orb->object_to_string (payload_receiver.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 ();
if (payload_receiver_impl->get_count () != 20)
{
ACE_ERROR ((LM_ERROR,
"ERROR: %d is not the correct "
"number of calls\n",
payload_receiver_impl->get_count ()));
++status;
}
root_poa->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
++status;
}
return status;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
if (parse_args (argc,
argv) == -1)
return -1;
try
{
ACE_Argv_Type_Converter satc (argc, argv);
CORBA::ORB_var sorb =
CORBA::ORB_init (satc.get_argc (),
satc.get_TCHAR_argv (),
server_orb.c_str ());
ACE_Manual_Event me;
Server_Task server_task (output,
sorb.in (),
me,
ACE_Thread_Manager::instance ());
if (server_task.activate (THR_NEW_LWP | THR_JOINABLE,
1,
1) == -1)
{
ACE_ERROR ((LM_ERROR, "Error activating server task\n"));
}
// Wait for the server thread to do some processing
me.wait ();
ACE_Argv_Type_Converter catc (argc, argv);
CORBA::ORB_var corb =
CORBA::ORB_init (catc.get_argc (),
catc.get_TCHAR_argv (),
client_orb.c_str ());
Client_Task client_task (input,
corb.in (),
ACE_Thread_Manager::instance (),
result);
if (client_task.activate (THR_NEW_LWP | THR_JOINABLE,
1,
1) == -1)
{
ACE_ERROR ((LM_ERROR, "Error activating client task\n"));
}
// Wait for the client and server to finish
ACE_Thread_Manager::instance ()->wait ();
// Now that all threads have completed we can destroy the ORB
sorb->destroy ();
if (server_orb != client_orb)
{
corb->destroy ();
}
}
catch (const CORBA::Exception&)
{
// Ignore exceptions..
}
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;
Visual_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 ());
Test_Interceptors::Visual_var server =
Test_Interceptors::Visual::_narrow (test_obj.in ());
CORBA::String_var ior =
orb->object_to_string (server.in ());
ACE_DEBUG ((LM_DEBUG,
"Test_Interceptors::Visual: <%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[])
{
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;
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 ());
OBV_FactoryTest::Test_var test =
OBV_FactoryTest::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 ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
poa_manager->activate ();
// create child poa with PERSISTENT policy
CORBA::PolicyList policies;
policies.length (2);
policies[0] =
root_poa->create_lifespan_policy(PortableServer::PERSISTENT);
policies[1] =
root_poa->create_implicit_activation_policy(PortableServer::IMPLICIT_ACTIVATION);
PortableServer::POA_var persistent_poa =
root_poa->create_POA("persistent",
poa_manager.in (),
policies);
policies[0]->destroy ();
policies[1]->destroy ();
poa_manager->activate ();
if (parse_args (argc, argv) != 0)
return 1;
PingObject_i *server_impl = 0;
ACE_NEW_RETURN (server_impl,
PingObject_i (orb.in (),
persistent_poa.in ()),
-1);
PortableServer::ServantBase_var owner_transfer(server_impl);
PortableServer::ObjectId_var id =
root_poa->activate_object (server_impl);
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
PingObject_var server =
PingObject::_narrow (object.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);
}
orb->run ();
ACE_DEBUG ((LM_DEBUG, "ping - event loop finished\n"));
persistent_poa->destroy (1, 1);
root_poa->destroy (1, 1);
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught in ping:");
return 1;
}
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
// Initialize the EC Factory so we can customize the EC
TAO_EC_Default_Factory::init_svcs ();
// Initialize the ORB.
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
const ACE_TCHAR* ecname = ACE_TEXT ("EventService");
const ACE_TCHAR* remote_ecname = 0;
const ACE_TCHAR* iorfile = 0;
for (int i = 0; argv[i] != 0; i++) {
if (ACE_OS::strcmp(argv[i], ACE_TEXT("-ecname")) == 0) {
if (argv[i+1] != 0) {
i++;
ecname = argv[i];
} else {
std::cerr << "Missing Event channel name" << std::endl;
}
}
if (ACE_OS::strcmp(argv[i], ACE_TEXT("-gateway")) == 0) {
if (argv[i+1] != 0) {
i++;
remote_ecname = argv[i];
} else {
std::cerr << "Missing Event channel name" << std::endl;
}
}
if (ACE_OS::strcmp(argv[i], ACE_TEXT("-iorfile")) == 0) {
if (argv[i+1] != 0) {
i++;
iorfile = argv[i];
}
}
}
// Get the POA
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 ();
// Spawn a thread for the orb
ACE_Thread_Manager *thread_mgr = ACE_Thread_Manager::instance();
thread_mgr->spawn(orb_thread, orb.in());
// Create a local event channel and register it with the RootPOA.
TAO_EC_Event_Channel_Attributes attributes (poa.in (), poa.in ());
PortableServer::Servant_var<TAO_EC_Event_Channel> ec_impl =
new TAO_EC_Event_Channel(attributes);
ec_impl->activate ();
PortableServer::ObjectId_var oid = poa->activate_object(ec_impl.in());
CORBA::Object_var ec_obj = poa->id_to_reference(oid.in());
RtecEventChannelAdmin::EventChannel_var ec =
RtecEventChannelAdmin::EventChannel::_narrow(ec_obj.in());
// Find the Naming Service.
object = orb->resolve_initial_references("NameService");
CosNaming::NamingContextExt_var root_context = CosNaming::NamingContextExt::_narrow(object.in());
CosNaming::Name_var name = root_context->to_name (ACE_TEXT_ALWAYS_CHAR (ecname));
root_context->rebind(name.in(), ec.in());
// Get a SupplierAdmin object from the EventChannel.
RtecEventChannelAdmin::SupplierAdmin_var admin = ec->for_suppliers();
// Get a ProxyPushConsumer from the SupplierAdmin.
RtecEventChannelAdmin::ProxyPushConsumer_var consumer =
admin->obtain_push_consumer();
// Instantiate an EchoEventSupplier_i servant.
PortableServer::Servant_var<EchoEventSupplier_i> servant =
new EchoEventSupplier_i(orb.in());
// Register it with the RootPOA.
oid = poa->activate_object(servant.in());
CORBA::Object_var supplier_obj = poa->id_to_reference(oid.in());
RtecEventComm::PushSupplier_var supplier =
RtecEventComm::PushSupplier::_narrow(supplier_obj.in());
// Publish the events the supplier provides.
ACE_SupplierQOS_Factory qos;
qos.insert (MY_SOURCE_ID, // Supplier's unique id
MY_EVENT_TYPE, // Event type
0, // handle to the rt_info structure
1); // number of calls
// Connect as a supplier of the published events.
consumer->connect_push_supplier (supplier.in (),
qos.get_SupplierQOS ());
// Create an event (just a string in this case).
const CORBA::String_var eventData = CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR (ecname));
// Create an event set for one event
RtecEventComm::EventSet event (1);
event.length (1);
// Initialize event header.
event[0].header.source = MY_SOURCE_ID;
event[0].header.ttl = 1;
event[0].header.type = MY_EVENT_TYPE;
// Initialize data fields in event.
event[0].data.any_value <<= eventData;
PortableServer::Servant_var<TAO_EC_Gateway_IIOP> gateway =
new TAO_EC_Gateway_IIOP;
int gateway_initialized = 0;
std::cout << "Supplier starting sending of events.\n";
while (1) {
consumer->push (event);
ACE_Time_Value tv(0, 1000 * EVENT_DELAY_MS);
orb->run(tv);
if ((remote_ecname != 0) && (!gateway_initialized)) {
try {
// Get the remote event channel object
CORBA::Object_var obj = root_context->resolve_str (ACE_TEXT_ALWAYS_CHAR (remote_ecname));
RtecEventChannelAdmin::EventChannel_var remote_ec =
RtecEventChannelAdmin::EventChannel::_narrow(obj.in());
int ok = 0;
if (!CORBA::is_nil(remote_ec.in())) {
// Now check if we can talk to it...
try {
RtecEventChannelAdmin::SupplierAdmin_var adm =
remote_ec->for_suppliers();
ok = 1;
} catch(const CORBA::UserException&) {
// What is the correct exception(s) to catch here?
}
}
// There is a good remote event channel so initialize the
// gateway.
if (ok) {
gateway->init(remote_ec.in(), ec.in());
PortableServer::ObjectId_var gateway_oid =
poa->activate_object(gateway.in());
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 =
ec->append_observer (obs.in ());
ACE_UNUSED_ARG (local_ec_obs_handle);
gateway_initialized = 1;
std::cout << "Gateway initialized\n";
if (iorfile != 0) {
CORBA::String_var str = orb->object_to_string( ec.in() );
std::ofstream iorFile( ACE_TEXT_ALWAYS_CHAR(iorfile) );
iorFile << str.in() << std::endl;
iorFile.close();
}
}
} catch(const CosNaming::NamingContext::NotFound&) {
// Try again later...
}
}
}
orb->destroy();
return 0;
}
catch(const CORBA::Exception& exc)
{
std::cerr << "Caught CORBA::Exception" << std::endl << exc << std::endl;
}
return 1;
}
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;
Simple_Server_i *server_impl = 0;
ACE_NEW_RETURN (server_impl,
Simple_Server_i (orb.in ()),
-1);
PortableServer::ServantBase_var owner_transfer(server_impl);
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 ());
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,
"(%P|%t) 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 ();
Worker worker (orb.in ());
if (worker.activate (THR_NEW_LWP | THR_JOINABLE,
nthreads) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) Cannot activate client threads\n"),
1);
SelfClient selfabuse (orb.in(), server.in(), niterations);
if (selfabuse.activate (THR_NEW_LWP | THR_JOINABLE,
nclient_threads) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) Cannot activate abusive threads\n"),
1);
selfabuse.thr_mgr()->wait();
worker.thr_mgr ()->wait ();
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) event loop finished\n"));
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
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, "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 ();
if (::parse_args (argc, argv) != 0)
return -1;
test_i *test_impl;
ACE_NEW_RETURN (test_impl, test_i (number, 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 ());
RTTest::test_var test =
RTTest::test::_narrow (object.in ());
CORBA::String_var ior =
orb->object_to_string (test.in ());
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);
poa_manager->activate ();
// 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);
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;
AMI_Test_i ami_test_i (orb.in ());
PortableServer::ObjectId_var id =
root_poa->activate_object (&ami_test_i);
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
A::AMI_Test_var ami_test_var =
A::AMI_Test::_narrow (object.in ());
CORBA::String_var ior =
orb->object_to_string (ami_test_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 ();
root_poa->destroy (1, // ethernalize objects
0 // wait for completion
);
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;
}
TAO_ECG_ConsumerEC_Control*
TAO_EC_Gateway_IIOP_Factory::create_consumerec_control (TAO_EC_Gateway_IIOP* gateway)
{
if (this->consumer_ec_control_ == 0)
return new TAO_ECG_ConsumerEC_Control ();
else if (this->consumer_ec_control_ == 1)
{
int argc = 0;
ACE_TCHAR **argv = 0;
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv, this->orbid_.c_str ());
ACE_Time_Value rate (0, this->consumer_ec_control_period_);
return new TAO_ECG_Reactive_ConsumerEC_Control (rate, consumer_ec_control_timeout_, gateway, orb.in ());
}
else if (this->consumer_ec_control_ == 2)
{
int argc = 0;
ACE_TCHAR **argv = 0;
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv, this->orbid_.c_str ());
ACE_Time_Value rate (0, this->consumer_ec_control_period_);
return new TAO_ECG_Reconnect_ConsumerEC_Control (rate, consumer_ec_control_timeout_, gateway, orb.in ());
}
return 0;
}