int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
PortableInterceptor::ORBInitializer_ptr temp_initializer;
ACE_NEW_RETURN (temp_initializer,
Client_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 object =
orb->string_to_object (ior);
Test_Interceptors::Visual_var server =
Test_Interceptors::Visual::_narrow (object.in ());
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%s> is nil.\n",
ior),
1);
}
ACE_hthread_t threadHandle;
if ( ACE_Thread::spawn(run_test,
static_cast<void*>(server.in()),
THR_NEW_LWP | THR_JOINABLE ,
0,
& threadHandle) == -1 )
{
ACE_ERROR_RETURN ((LM_ERROR,"Cannot start thread"), 1);
}
ACE_Thread::join (threadHandle);
server->shutdown ();
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught exception in client:");
return 1;
}
return 0;
}
int
TAO_LB_ClientComponent::register_orb_initializer (void)
{
try
{
// Register the LB_ClientComponent ORB initializer.
PortableInterceptor::ORBInitializer_ptr tmp;
ACE_NEW_THROW_EX (tmp,
TAO_LB_ClientORBInitializer,
CORBA::NO_MEMORY (
CORBA::SystemException::_tao_minor_code (
TAO::VMCID,
ENOMEM),
CORBA::COMPLETED_NO));
PortableInterceptor::ORBInitializer_var initializer = tmp;
PortableInterceptor::register_orb_initializer (initializer.in ());
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception (
"Unable to register LB_ClientComponent ORB ""initializer.");
return -1;
}
return 0;
}
int
TAO_LB_Component::register_orb_initializer (
const CORBA::StringSeq & object_groups,
const CORBA::StringSeq & repository_ids,
const char * location)
{
try
{
// Register the LB_Component ORB initializer.
PortableInterceptor::ORBInitializer_ptr tmp;
ACE_NEW_THROW_EX (tmp,
TAO_LB_ORBInitializer (object_groups,
repository_ids,
location),
CORBA::NO_MEMORY (
CORBA::SystemException::_tao_minor_code (
TAO::VMCID,
ENOMEM),
CORBA::COMPLETED_NO));
PortableInterceptor::ORBInitializer_var initializer = tmp;
PortableInterceptor::register_orb_initializer (initializer.in ());
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception (
"Unable to register LB_Component ORB ""initializer.");
return -1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
PortableInterceptor::ORBInitializer_ptr temp_initializer;
ACE_NEW_RETURN (temp_initializer,
Client_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 object =
orb->string_to_object (ior);
Interop::CDR_Out_Arg_var server =
Interop::CDR_Out_Arg::_narrow (object.in ());
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%s> is nil.\n",
ior),
1);
}
CORBA::Long lv;
CORBA::Long_out arg (lv);
server->get_out (arg);
ACE_DEBUG ((LM_DEBUG, "first call passed\n"));
server->get_out (arg);
ACE_DEBUG ((LM_DEBUG, "second call passed\n"));
server->shutdown ();
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught exception in client:");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
PortableInterceptor::ORBInitializer_ptr temp_initializer;
ACE_NEW_RETURN (temp_initializer,
Client_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 object =
orb->string_to_object (ior);
Test_Interceptors::Visual_var server =
Test_Interceptors::Visual::_narrow (object.in ());
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%s> is nil.\n",
ior),
1);
}
run_test (server.in ());
server->shutdown ();
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught exception in client:");
return 1;
}
return 0;
}
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 occurred!\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[])
{
int interceptor_type;
get_interceptor_type (argc, argv, interceptor_type);
try
{
PortableInterceptor::ORBInitializer_ptr temp_initializer;
ACE_NEW_RETURN (temp_initializer,
Server_ORBInitializer (interceptor_type),
-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");
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 ();
Secure_Vault_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::Secure_Vault_var server =
Test_Interceptors::Secure_Vault::_narrow (test_obj.in ());
CORBA::String_var ior =
orb->object_to_string (server.in ());
ACE_DEBUG ((LM_DEBUG,
"Test_Interceptors::Secure_Vault: <%s>\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);
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught exception:");
return 1;
}
return 0;
}
int
TAO::SSLIOP::Protocol_Factory::register_orb_initializer (
CSIIOP::AssociationOptions csiv2_target_supports,
CSIIOP::AssociationOptions csiv2_target_requires)
{
try
{
// @todo: This hard-coding should be fixed once SECIOP is
// supported.
// Register the Security ORB initializer.
PortableInterceptor::ORBInitializer_ptr tmp;
ACE_NEW_THROW_EX (tmp,
TAO::Security::ORBInitializer,
CORBA::NO_MEMORY (
CORBA::SystemException::_tao_minor_code (
TAO::VMCID,
ENOMEM),
CORBA::COMPLETED_NO));
PortableInterceptor::ORBInitializer_var initializer = tmp;
PortableInterceptor::ORBInitializer_ptr temp_dll_initializer =
PortableInterceptor::ORBInitializer::_nil ();
ACE_NEW_THROW_EX (temp_dll_initializer,
PortableInterceptor::DLL_Resident_ORB_Initializer(
initializer.in (),
ACE_TEXT ("TAO_Security")),
CORBA::NO_MEMORY (
CORBA::SystemException::_tao_minor_code (
TAO::VMCID,
ENOMEM),
CORBA::COMPLETED_NO));
PortableInterceptor::ORBInitializer_var dll_initializer
= temp_dll_initializer;
PortableInterceptor::register_orb_initializer (dll_initializer.in ());
// Register the SSLIOP ORB initializer.
ACE_NEW_THROW_EX (tmp,
TAO::SSLIOP::ORBInitializer (this->qop_,
csiv2_target_supports,
csiv2_target_requires),
CORBA::NO_MEMORY (
CORBA::SystemException::_tao_minor_code (
TAO::VMCID,
ENOMEM),
CORBA::COMPLETED_NO));
initializer = tmp;
temp_dll_initializer = PortableInterceptor::ORBInitializer::_nil ();
ACE_NEW_THROW_EX (temp_dll_initializer,
PortableInterceptor::DLL_Resident_ORB_Initializer(
initializer.in (),
ACE_TEXT ("TAO_SSLIOP")),
CORBA::NO_MEMORY (
CORBA::SystemException::_tao_minor_code (
TAO::VMCID,
ENOMEM),
CORBA::COMPLETED_NO));
dll_initializer = temp_dll_initializer;
PortableInterceptor::register_orb_initializer (dll_initializer.in ());
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception (
"Unable to register SSLIOP ORB initializer.");
return -1;
}
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[])
{
if (parse_args (argc, argv) == -1)
return -1;
server_orb.set ("server_orb");
client_orb.set ("client_orb");
try
{
PortableInterceptor::ORBInitializer_ptr temp_initializer;
ACE_NEW_RETURN (temp_initializer,
Collocated_ORBInitializer,
-1); // No exceptions yet!
PortableInterceptor::ORBInitializer_var initializer =
temp_initializer;
PortableInterceptor::register_orb_initializer (initializer.in ());
CORBA::ORB_var sorb =
CORBA::ORB_init (argc, 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 ();
CORBA::ORB_var corb =
CORBA::ORB_init (argc, argv, client_orb.c_str ());
Client_Task client_task (input,
corb.in (),
ACE_Thread_Manager::instance ());
if (client_task.activate (THR_NEW_LWP | THR_JOINABLE,
1,
1) == -1)
{
ACE_ERROR ((LM_ERROR, "Error activating client task\n"));
}
ACE_Thread_Manager::instance ()->wait ();
}
catch (const CORBA::Exception&)
{
// Ignore exceptions..
}
return 0;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
int result = 0;
try
{
// Register the interceptors to check for the RTCORBA
// service contexts in the reply messages.
PortableInterceptor::ORBInitializer_ptr temp_initializer;
ACE_NEW_RETURN (temp_initializer,
Client_ORBInitializer,
-1); // No exceptions yet!
PortableInterceptor::ORBInitializer_var initializer =
temp_initializer;
PortableInterceptor::register_orb_initializer (initializer.in ());
// Initialize and obtain reference to the Test object.
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return -1;
// Make sure we can support multiple priorities that are required
// for this test.
if (!check_supported_priorities (orb.in ()))
return 2;
// Thread Manager for managing task.
ACE_Thread_Manager thread_manager;
// Create task.
Task task (thread_manager,
orb.in ());
// Task activation flags.
long flags =
THR_NEW_LWP |
THR_JOINABLE |
orb->orb_core ()->orb_params ()->thread_creation_flags ();
// Activate task.
result =
task.activate (flags);
if (result == -1)
{
if (errno == EPERM)
{
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot create thread with scheduling policy %s\n"
"because the user does not have the appropriate privileges, terminating program....\n"
"Check svc.conf options and/or run as root\n",
sched_policy_name (orb->orb_core ()->orb_params ()->ace_sched_policy ())),
2);
}
else
// Unexpected error.
ACE_ERROR_RETURN ((LM_ERROR,
"ERROR: Cannot create thread. errno = %d\n",
ACE_ERRNO_GET),
-1);
}
// Wait for task to exit.
result =
thread_manager.wait ();
}
catch (const CORBA::Exception & ae)
{
ae._tao_print_exception (
"Caught exception:");
return -1;
}
return result;
}
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;
// 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,
"client (%P|%t): user is not superuser, "
"test runs in time-shared class\n"));
}
else
ACE_ERROR ((LM_ERROR,
"client (%P|%t): sched_params failed\n"));
}
int interceptor_type;
get_interceptor_type (argc, argv, interceptor_type);
try
{
PortableInterceptor::ORBInitializer_ptr temp_initializer;
ACE_NEW_RETURN (temp_initializer,
Client_ORBInitializer (interceptor_type),
-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 object =
orb->string_to_object (ior);
Test_Interceptors::Secure_Vault_var server =
Test_Interceptors::Secure_Vault::_narrow (object.in ());
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%s> is nil.\n",
ior),
1);
}
ACE_DEBUG ((LM_DEBUG, "\nFunctionality test begins now...\n"));
// This test is useful for benchmarking the differences when
// the same method is intercepted by different interceptors
// wanting to achieve different functionality.
run_test (server.in ());
server->shutdown ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught exception:");
return 1;
}
return 0;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
{
PortableInterceptor::ORBInitializer_var initializer (
new Client_ORBInitializer);
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 ();
CORBA::Object_var tmp =
orb->string_to_object (ior);
Test::Echo_var echo =
Test::Echo::_narrow (tmp.in ());
poa_manager->activate ();
if (CORBA::is_nil (echo.in ()))
{
ACE_ERROR_RETURN ((LM_DEBUG,
"Nil Test::Echo reference <%s>\n",
ior),
1);
}
test_synchronous (echo.in ());
test_ami (orb.in (),
echo.in ());
echo->shutdown ();
orb->destroy ();
unsigned long request_count =
Echo_Client_Request_Interceptor::request_count;
unsigned long response_count =
Echo_Client_Request_Interceptor::reply_count
+ Echo_Client_Request_Interceptor::other_count
+ Echo_Client_Request_Interceptor::exception_count;
if (request_count != response_count)
{
ACE_ERROR ((LM_ERROR,
"ERROR: Mismatched count of requests and responses "
" (request = %d, response = %d)\n",
request_count, response_count));
}
if (request_count == 0)
{
ACE_ERROR ((LM_ERROR,
"ERROR: No requests handled "));
}
if (response_count == 0)
{
ACE_ERROR ((LM_ERROR,
"ERROR: No response handled "));
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return exit_status;
}
int
main (int argc, char *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, "");
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;
}
// Create the interceptor.
ForwardTest_Request_Interceptor * server_interceptor =
temp_initializer->server_interceptor();
// getting the original oject
Forward_Test_i *final_impl = new Forward_Test_i(orb.in ());
PortableServer::ServantBase_var servant = final_impl;
Forward::Test_var target = final_impl->_this ();
server_interceptor->forward_reference (target.in());
Forward_Test_i *server_impl = new Forward_Test_i (orb.in());
servant = server_impl;
Forward::Test_var server = server_impl->_this ();
// getting the mapper object
CORBA::Object_var obj =
orb->string_to_object (lorica_ior);
Lorica::ReferenceMapper_var mapper =
Lorica::ReferenceMapper::_narrow(obj.in());
if (CORBA::is_nil(mapper.in()))
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot get reference to Lorica "
"reference mapper\n"),1);
// getting the mapped object
obj = mapper->as_server(server.in(),"ForwardTest",
Lorica::ServerAgent::_nil());
if (CORBA::is_nil (obj.in()))
ACE_ERROR_RETURN ((LM_ERROR,
"Lorica reference mapper returned a nil "
"mapped reference.\n"),1);
// narrowing the mapped object
Forward::Test_var h2 = Forward::Test::_narrow(obj.in());
if (CORBA::is_nil(h2.in()))
ACE_ERROR_RETURN ((LM_ERROR,
"Lorica reference mapper returned an "
"incorrectly typed reference\n"),1);
CORBA::String_var orig_ior =
orb->object_to_string (server.in ());
CORBA::String_var mapped_ior =
orb->object_to_string (h2.in());
if (ACE_OS::strcmp (orig_ior.in(), mapped_ior.in()) == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Lorica reference mapper returned "
"the original reference unmapped.\n"),1);
ACE_DEBUG ((LM_DEBUG,"writing original IOR to file %s\n",orig_file));
ACE_DEBUG ((LM_DEBUG,"writing mapped IOR to file %s\n",mapped_file));
ACE_DEBUG ((LM_DEBUG,"Size of orig IOR = %d, size of mapped = %d\n",
ACE_OS::strlen(orig_ior.in()),
ACE_OS::strlen(mapped_ior.in())));
FILE *output_file= ACE_OS::fopen (mapped_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s\n",
mapped_file),
1);
ACE_OS::fprintf (output_file, "%s", mapped_ior.in());
ACE_OS::fclose (output_file);
output_file= ACE_OS::fopen (orig_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s\n",
orig_file),
1);
ACE_OS::fprintf (output_file, "%s", orig_ior.in());
ACE_OS::fclose (output_file);
poa_manager->activate ();
orb->run ();
ACE_DEBUG ((LM_DEBUG, "event loop finished\n"));
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Server: exception caught - ");
return 1;
}
return 0;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
int server_num = 0;
int die_on_ping = 1;
int ping_count = 0;
for (int i = 1; i < argc; i++)
{
ACE_TCHAR *c = argv[i];
if (ACE_OS::strcasecmp (ACE_TEXT ("-n"), c) == 0)
{
server_num = ACE_OS::atoi (argv[++i]);
}
else if (ACE_OS::strcasecmp (ACE_TEXT ("-?"),c) == 0)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("usage: %C ")
ACE_TEXT ("-n Number of the server\n"),
argv[0]));
return 1;
}
}
Server_ORBInitializer * temp_initializer;
ACE_NEW_RETURN (temp_initializer,
Server_ORBInitializer (&ping_count),
-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);
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_base = ACE_CString("TestObject_") + toStr (server_num);
PortableServer::POA_var test_poa;
test_poa = createPOA(root_poa.in (), true, poa_name_base.c_str ());
temp_initializer->set_poa (test_poa.in());
mgr->activate();
PortableServer::Servant_var<Test_i> test_servant =
new Test_i(server_num);
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_base.c_str (), test_ior.in());
ACE_DEBUG ((LM_DEBUG, "Started Server %s \n",
poa_name_base.c_str()));
{
ACE_CString status_file = poa_name_base + ACE_CString(".status");
ofstream out(status_file.c_str ());
out << "started" << endl;
}
while (ping_count < die_on_ping)
{
orb->perform_work ();
}
root_poa->destroy(1,1);
orb->destroy();
}
catch(const CORBA::Exception& ex) {
ex._tao_print_exception ("Server main()");
return 1;
}
return 0;
}