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 ();
// 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 child_poa =
root_poa->create_POA ("childPOA", poa_manager.in (), policies);
// Creation of childPOA is over. Destroy the Policy objects.
for (CORBA::ULong i = 0; i < policies.length (); ++i)
{
policies[i]->destroy ();
}
poa_manager->activate ();
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var object = orb->string_to_object (ior);
Simple_Server_var server = Simple_Server::_narrow (object.in ());
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%C> is nil\n",
ior),
1);
}
Callback_i callback_impl (orb.in ());
PortableServer::ObjectId_var id =
PortableServer::string_to_ObjectId ("client_callback");
child_poa->activate_object_with_id (id.in (), &callback_impl);
CORBA::Object_var callback_object =
child_poa->id_to_reference (id.in ());
Callback_var callback = Callback::_narrow (callback_object.in ());
CORBA::String_var ior = orb->object_to_string (callback.in ());
ACE_DEBUG ((LM_DEBUG, "(%P|%t) Client callback activated as <%C>\n",
ior.in ()));
// Send the calback object to the server
server->callback_object (callback.in ());
int pre_call_connections =
orb->orb_core ()->lane_resources ().transport_cache ().current_size ();
// A method to kickstart callbacks from the server
CORBA::Long r = server->test_method (1);
if (r != 0)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) unexpected result = %d ",
r));
}
orb->run ();
int cur_connections =
orb->orb_core ()->lane_resources ().transport_cache ().current_size ();
if (cur_connections > pre_call_connections)
{
ACE_ERROR ((LM_ERROR,
"(%P|%t) Expected %d "
"connections in the transport cache, but found "
"%d instead. Aborting.\n",
pre_call_connections,
cur_connections));
ACE_OS::abort ();
}
root_poa->destroy (1, 1);
}
catch (CORBA::Exception &excep)
{
excep._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 ();
// 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 child_poa =
root_poa->create_POA ("childPOA",
poa_manager.in (),
policies);
// Creation of childPOA is over. Destroy the Policy objects.
for (CORBA::ULong i = 0;
i < policies.length ();
++i)
{
policies[i]->destroy ();
}
poa_manager->activate ();
if (parse_args (argc, argv) != 0)
return 1;
Simple_Server_i server_impl (orb.in (),
no_iterations);
PortableServer::ObjectId_var id =
PortableServer::string_to_ObjectId ("simple_server");
child_poa->activate_object_with_id (id.in (),
&server_impl);
CORBA::Object_var obj =
child_poa->id_to_reference (id.in ());
CORBA::String_var ior =
orb->object_to_string (obj.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);
}
int retval = 0;
while (retval == 0)
{
// Just process one upcall. We know that we would get the
// clients IOR in that call.
CORBA::Boolean pending =
orb->work_pending();
if (pending)
{
orb->perform_work();
}
// Now that hopefully we have the clients IOR, just start
// making remote calls to the client.
retval = server_impl.call_client ();
}
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
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;
CORBA::Object_var obj = orb->resolve_initial_references("Test");
if (CORBA::is_nil(obj.in()))
{
ACE_DEBUG ((LM_DEBUG, "Client could not RIR Test\n"));
return 1;
}
Test_var test = Test::_narrow( obj.in() );
if (CORBA::is_nil(test.in()))
{
ACE_DEBUG ((LM_DEBUG, "Client could not narrow Test\n"));
return 1;
}
test->_stubobj()->reset_profiles();
test->foo ();
CORBA::Any a;
a <<= Messaging::SYNC_WITH_SERVER;
CORBA::PolicyList policy_list (1);
policy_list.length (1);
policy_list[0] =
orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE, a);
obj = test->_set_policy_overrides (policy_list, CORBA::ADD_OVERRIDE);
test = Test::_narrow ( obj.in());
test->_stubobj()->reset_profiles();
test->foo ();
CORBA::Short n = test->get_call_count();
ACE_DEBUG ((LM_DEBUG,
"Got call count of %d\n",
n));
return n != 1;
}
catch(const CORBA::Exception& ex) {
ex._tao_print_exception ("client:");
}
return -1;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
int retval = 1;
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);
CORBA::Object_var object =
orb->resolve_initial_references ("PolicyCurrent");
CORBA::PolicyCurrent_var policy_current =
CORBA::PolicyCurrent::_narrow (object.in ());
CORBA::Any timeout_as_any;
timeout_as_any <<= timeout_period;
CORBA::PolicyList policy_list (1);
policy_list.length (1);
policy_list[0] =
orb->create_policy (TAO::CONNECTION_TIMEOUT_POLICY_TYPE,
timeout_as_any);
policy_current->set_policy_overrides (policy_list,
CORBA::ADD_OVERRIDE);
for (CORBA::ULong l = 0;
l != policy_list.length ();
++l)
{
policy_list[l]->destroy ();
}
retval = test_timeout (tmp.in ());
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return retval;
}
void
Echo_Client_ORBInitializer::post_init (
PortableInterceptor::ORBInitInfo_ptr info)
{
// TAO-Specific way to get to the ORB Core (and thus, the ORB).
TAO_ORBInitInfo_var tao_info =
TAO_ORBInitInfo::_narrow (info);
CORBA::ORB_var orb = CORBA::ORB::_duplicate(tao_info->orb_core()->orb());
if (CORBA::is_nil(orb.in()))
{
throw CORBA::INTERNAL ();
}
PortableInterceptor::ORBInitInfo_3_1_var info_3_1 =
PortableInterceptor::ORBInitInfo_3_1::_narrow(info);
if (CORBA::is_nil(info_3_1.in()))
{
throw CORBA::INTERNAL ();
}
PortableInterceptor::ClientRequestInterceptor_ptr interceptor =
PortableInterceptor::ClientRequestInterceptor::_nil ();
// Install the Echo client request interceptor
ACE_NEW_THROW_EX (interceptor,
Echo_Client_Request_Interceptor,
CORBA::NO_MEMORY ());
PortableInterceptor::ClientRequestInterceptor_var
client_interceptor = interceptor;
CORBA::Any client_proc_mode_as_any;
client_proc_mode_as_any <<= this->processing_mode_;
CORBA::PolicyList policy_list (1);
policy_list.length (1);
policy_list[0] =
orb->create_policy (PortableInterceptor::PROCESSING_MODE_POLICY_TYPE,
client_proc_mode_as_any);
info_3_1->add_client_request_interceptor_with_policy (
client_interceptor.in (),
policy_list);
policy_list[0]->destroy ();
policy_list[0] = CORBA::Policy::_nil ();
}
CORBA::Object_ptr register_with_proxy (CORBA::Object_ptr native)
{
// Disable protection for this insecure invocation test.
Security::QOP qop = Security::SecQOPNoProtection;
CORBA::Any no_protection;
no_protection <<= qop;
// Create the Security::QOPPolicy.
CORBA::Policy_var policy =
orb->create_policy (Security::SecQOPPolicy,
no_protection);
CORBA::PolicyList policy_list (1);
policy_list.length (1);
policy_list[0] = CORBA::Policy::_duplicate (policy.in ());
// Create an object reference that uses plain IIOP (i.e. no
// protection).
CORBA::Object_var object =
mapper->_set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
ACE_DEBUG ((LM_DEBUG,"Trying to narrow an insecure reference\n"));
Lorica::ReferenceMapper_var open_mapper =
Lorica::ReferenceMapper::_narrow(object.in());
ACE_DEBUG ((LM_DEBUG,"Using open mapper for registering\n"));
try
{
return open_mapper->as_server(native,"Hello",
Lorica::ServerAgent::_nil());
}
catch (CORBA::Exception &ex)
{
ACE_DEBUG ((LM_DEBUG,"open_mapper->as_server raised %s\n",ex._name()));
return CORBA::Object::_nil();
}
}
CORBA::Object_ptr
set_timeout_policy (CORBA::Object_ptr obj, const ACE_Time_Value& to)
{
CORBA::Object_var ret;
try
{
TimeBase::TimeT timeout;
ORBSVCS_Time::Time_Value_to_TimeT (timeout, to);
CORBA::Any tmp;
tmp <<= timeout;
CORBA::PolicyList policies (1);
policies.length (1);
policies[0] = orb->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE,
tmp);
ret = obj->_set_policy_overrides (policies, CORBA::ADD_OVERRIDE);
policies[0]->destroy ();
if (CORBA::is_nil (ret.in ()))
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Unable to set timeout policy.\n")));
ret = CORBA::Object::_duplicate (obj);
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception (ACE_TEXT ("set_timeout_policy ()"));
ret = CORBA::Object::_duplicate (obj);
}
return ret._retn ();
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
// Initialize orb
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
// Get reference to Root POA.
CORBA::Object_var obj =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var rootpoa =
PortableServer::POA::_narrow (obj.in ());
// Activate POA manager
PortableServer::POAManager_var mgr =
rootpoa->the_POAManager ();
mgr->activate ();
PortableServer::POA_var poa;
TAO::Utils::PolicyList_Destroyer PolicyList (3);
PolicyList.length (3);
PolicyList [0] =
rootpoa->create_lifespan_policy (PortableServer::PERSISTENT);
PolicyList [1] =
rootpoa->create_id_assignment_policy (PortableServer::USER_ID);
CORBA::Any CallbackPolicy;
CallbackPolicy <<= BiDirPolicy::BOTH;
const char* sServerPoaName = "TelemetryServer";
PolicyList [2] =
orb->create_policy (BiDirPolicy::BIDIRECTIONAL_POLICY_TYPE,
CallbackPolicy);
poa = rootpoa->create_POA (sServerPoaName,
mgr.in(),
PolicyList);
PortableServer::ObjectId_var ServerId =
PortableServer::string_to_ObjectId ("TimeServer");
// Create an object
Time_impl *time_servant = new Time_impl;
PortableServer::ServantBase_var self_manage (time_servant);
poa->activate_object_with_id (ServerId.in (),
time_servant);
// Get a reference after activating the object
CORBA::Object_var object = poa->id_to_reference (ServerId.in ());
TimeModule::Time_var tm = TimeModule::Time::_narrow (object.in ());
// Get reference to initial naming context
CORBA::Object_var name_obj =
orb->resolve_initial_references ("NameService");
CosNaming::NamingContext_var inc =
CosNaming::NamingContext::_narrow (name_obj.in ());
if (CORBA::is_nil (inc.in ()))
{
ACE_ERROR ((LM_ERROR,
"(%P|%t) Error fetching naming context\n"));
}
CosNaming::Name service_name;
service_name.length(1);
service_name[0].id =
CORBA::string_dup ("Time");
inc->rebind (service_name,
tm.in ());
// Run the event loop for fun
ACE_Time_Value tv (3, 0);
// Accept requests
orb->run (&tv);
rootpoa->destroy (0 , 0);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught an exception\n");
return -1;
}
return 0;
}
int
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);
// 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 manager_object =
orb->resolve_initial_references ("ORBPolicyManager");
CORBA::PolicyManager_var policy_manager =
CORBA::PolicyManager::_narrow (manager_object.in ());
CORBA::Any sync_scope;
sync_scope <<= Messaging::SYNC_WITH_TARGET;
CORBA::PolicyList policy_list (1);
policy_list.length (1);
policy_list[0] =
orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE,
sync_scope);
policy_manager->set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
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;
Server_i server_i;
Test::Server_var server = server_i._this ();
CORBA::String_var str =
orb->object_to_string (server.in ());
if (ior_file_name != 0)
{
FILE *output_file = ACE_OS::fopen (ior_file_name, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s",
ior_file_name),
1);
ACE_OS::fprintf (output_file, "%s", str.in ());
ACE_OS::fclose (output_file);
}
while (!server_i.done ())
{
ACE_Time_Value tv (1, 0);
orb->run (tv);
}
PortableServer::ObjectId_var id =
root_poa->servant_to_id (&server_i);
root_poa->deactivate_object (id.in ());
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception (argv[0]);
}
return 0;
}
int
main( int argc, char *argv[] )
{
try {
// Initialize orb
CORBA::ORB_var orb = CORBA::ORB_init( argc, argv );
// Destringify ior
CORBA::Object_var obj = orb->string_to_object( "file://IOR" );
if( CORBA::is_nil( obj.in() ) ) {
cerr << "Nil reference" << endl;
throw 0;
}
// Narrow
CallbackServer_var cb_server = CallbackServer::_narrow( obj.in() );
if( CORBA::is_nil( cb_server.in() ) ) {
cerr << "Argument is not a CallbackServer reference" << endl;
throw 0;
}
//Get reference to Root POA
obj = orb->resolve_initial_references( "RootPOA" );
PortableServer::POA_var poa = PortableServer::POA::_narrow( obj.in() );
// Policies for the childPOA to be created.
CORBA::PolicyList policies (4);
policies.length (4);
CORBA::Any pol;
pol <<= BiDirPolicy::BOTH;
policies[0] =
orb->create_policy (BiDirPolicy::BIDIRECTIONAL_POLICY_TYPE,
pol);
policies[1] =
poa->create_id_assignment_policy(PortableServer::SYSTEM_ID);
policies[2] =
poa->create_implicit_activation_policy( PortableServer::IMPLICIT_ACTIVATION );
policies[3] =
poa->create_lifespan_policy(PortableServer::TRANSIENT);
PortableServer::POAManager_var mgr = poa->the_POAManager();
// 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 child_poa =
poa->create_POA ("childPOA",
mgr.in(),
policies);
// Creation of childPOA is over. Destroy the Policy objects.
for (CORBA::ULong i = 0;
i < policies.length ();
++i)
{
policies[i]->destroy ();
}
// Activate POA Manager
mgr->activate();
// Create an object
ClientCallback_i servant;
// Register the servant with the RootPOA, obtain its object
// reference, stringify it, and write it to a file.
obj = child_poa->servant_to_reference( &servant );
//ClientCallback_var ccb = ClientCallback::_narrow( obj.in() );
cb_server->callback_hello( ClientCallback::_narrow( obj.in() ),
CORBA::string_dup( "Greetings earthling" ));
}
catch( const CORBA::Exception &ex ) {
cerr << "Uncaught CORBA exception: " << ex << endl;
return 1;
}
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
int ret_val = 0;
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
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_WITH_SERVER;
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;
CORBA::Object_var tmp =
orb->string_to_object(ior);
Test::Peer_var peer =
Test::Peer::_narrow(tmp.in ());
if (CORBA::is_nil (peer.in ()))
{
ACE_ERROR_RETURN ((LM_DEBUG,
"Nil Test::Peer reference <%s>\n",
ior),
1);
}
while(1)
{
peer->noop ();
}
/* Warning with TRU 64 builds
ACE_DEBUG ((LM_DEBUG, "(%P|%t) scavenger - event loop finished\n"));
orb->destroy ();
*/
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
ret_val = 1;
}
return ret_val;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
CORBA::ORB_var orb = CORBA::ORB::_nil();
PortableServer::POA_var root_poa = PortableServer::POA::_nil();
Callback_i *servant = 0;
try
{
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 ();
// 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 child_poa =
root_poa->create_POA ("childPOA",
poa_manager.in (),
policies);
// Creation of childPOA is over. Destroy the Policy objects.
for (CORBA::ULong i = 0;
i < policies.length ();
++i)
{
policies[i]->destroy ();
}
poa_manager->activate ();
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var object =
orb->string_to_object (ior);
Simple_Server_var server =
Simple_Server::_narrow (object.in ());
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%s> is nil\n",
ior),
1);
}
servant = new Callback_i (orb.in ());
Callback_var callback =
servant->_this ();
// Send the calback object to the server
server->callback_object (callback.in ());
// A method to kickstart callbacks from the server
CORBA::Long r =
server->test_method (1);
if (r != 0)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) unexpected result = %d ",
r));
}
orb->run ();
root_poa->destroy (1, 1);
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught exception:");
return 1;
}
if (!CORBA::is_nil(root_poa.in()))
root_poa->destroy (1,1);
delete servant;
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 ();
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;
// Get the sender reference..
CORBA::Object_var tmp =
orb->string_to_object(ior);
Test::Sender_var sender =
Test::Sender::_narrow(tmp.in ());
if (CORBA::is_nil (sender.in ()))
{
ACE_ERROR_RETURN ((LM_DEBUG,
"Nil coordinator reference <%s>\n",
ior),
1);
}
Client_Task client_task (orb.in(),
sender.in (),
ACE_Thread_Manager::instance (),
number_of_oneways);
Server_Task server_task (orb.in (),
ACE_Thread_Manager::instance ());
// Before creating threads we will let the sender know that we
// will have two threads that would make invocations..
// this is the first oneway we do, so after this we would have a queue
// on one of the transports
sender->active_objects ((CORBA::Short) number_of_client_tasks);
TAO::Transport_Cache_Manager& manager = orb->orb_core()->lane_resources ().transport_cache ();
TAO::Transport_Cache_Manager::HASH_MAP& cachemap = manager.map();
TAO::Transport_Cache_Manager::HASH_MAP_ITER end_iter = cachemap.end ();
bool tranportwithqueue = false;
for (TAO::Transport_Cache_Manager::HASH_MAP_ITER iter = cachemap.begin ();
iter != end_iter;
++iter)
{
TAO_Transport* transport = (*iter).int_id_.transport ();
if (transport->queue_is_empty() == 0 && transport->is_connected() == false)
{
tranportwithqueue = true;
break;
}
}
if (!tranportwithqueue)
{
ACE_ERROR ((LM_ERROR, "(%P|%t) Error: expect a not connected transport with a queue\n"));
}
else
{
ACE_DEBUG((LM_DEBUG, "(%P|%t) Found not connected transport with a queue\n"));
}
if (server_task.activate (THR_NEW_LWP | THR_JOINABLE, 2,1) == -1)
{
ACE_ERROR ((LM_ERROR, "Error activating server task\n"));
}
if (client_task.activate (THR_NEW_LWP | THR_JOINABLE, number_of_client_tasks, 1) == -1)
{
ACE_ERROR ((LM_ERROR, "Error activating client task\n"));
}
ACE_Thread_Manager::instance ()->wait ();
ACE_DEBUG ((LM_DEBUG,
"Event Loop finished\n"));
orb->destroy ();
if (tranportwithqueue == false)
{
return 1;
}
}
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[])
{
CORBA::ORB_var orb;
CORBA::Object_var obj;
PortableServer::POA_var root_poa;
PortableServer::POAManagerFactory_var poa_manager_factory;
if (parse_args (argc, argv) != 0)
return 1;
ACE_TCHAR *extra[4];
#ifdef ACE_USES_WCHAR
extra[0] = CORBA::wstring_dup (ACE_TEXT ("-ORBEndpoint"));
extra[1] =CORBA::wstring_alloc (100);
#else
extra[0] = CORBA::string_dup ("-ORBEndpoint");
extra[1] = CORBA::string_alloc (100);
#endif
ACE_OS::sprintf (extra[1],
ACE_TEXT ("iiop://localhost:%d/ssl_port=%d"),
endpoint_port, endpoint_port+1);
#ifdef ACE_USES_WCHAR
extra[2] = CORBA::wstring_dup (ACE_TEXT ("-ORBEndpoint"));
extra[3] = CORBA::wstring_alloc (100);
#else
extra[2] = CORBA::string_dup ("-ORBEndpoint");
extra[3] = CORBA::string_alloc (100);
#endif
ACE_OS::sprintf (extra[3],
ACE_TEXT ("iiop://localhost:%d/ssl_port=%d"),
endpoint_port+10, endpoint_port+11);
ACE_TCHAR **largv = new ACE_TCHAR *[argc+4];
int i = 0;
for (i = 0; i < argc; i++)
largv[i] = argv[i];
for (i = 0; i < 4; i++)
largv[argc+i] = extra[i];
argc += 4;
try
{
orb =
CORBA::ORB_init (argc, largv, "EndpointPolicy");
obj =
orb->resolve_initial_references("RootPOA");
root_poa =
PortableServer::POA::_narrow (obj.in ());
if (CORBA::is_nil (root_poa.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Panic: nil RootPOA\n"),
1);
poa_manager_factory
= root_poa->the_POAManagerFactory ();
}
catch (CORBA::Exception &ex)
{
ex._tao_print_exception("initialization error ");
return 1;
}
for (i = 0; i < 4; i++)
#ifdef ACE_USES_WCHAR
CORBA::wstring_free (extra[i]);
#else
CORBA::string_free (extra[i]);
#endif
delete [] largv;
//-----------------------------------------------------------------------
// Create two valid endpoint policies. One to match each of the generated
// endpoint arguments supplied to ORB_init().
PortableServer::POAManager_var good_pm;
PortableServer::POAManager_var bad_pm;
CORBA::PolicyList policies;
policies.length (1);
EndpointPolicy::EndpointList list;
list.length (1);
list[0] = new IIOPEndpointValue_i("localhost", endpoint_port);
try
{
CORBA::Any policy_value;
policy_value <<= list;
policies[0] = orb->create_policy (EndpointPolicy::ENDPOINT_POLICY_TYPE,
policy_value);
good_pm = poa_manager_factory->create_POAManager ("goodPOAManager",
policies);
}
catch (CORBA::Exception &ex)
{
ex._tao_print_exception ("Failed to create reachable POA manager");
return 1;
}
try
{
PortableServer::ObjectId_var oid;
CORBA::Object_var o = CORBA::Object::_nil();
FILE *output_file= 0;
// Create poas assiciated with the each the good poa manager and the
// bad poa manager.
policies.length(0);
PortableServer::POA_var good_poa =
root_poa->create_POA ("goodPOA",
good_pm.in (),
policies);
ACE_DEBUG ((LM_DEBUG, "Creating IOR from good poa\n"));
o = good_poa->create_reference ("IDL:JustATest:1.0");
CORBA::String_var good_ior =
orb->object_to_string (o.in ());
output_file= ACE_OS::fopen (ior_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s",
ior_file),
1);
ACE_OS::fprintf (output_file, "%s", good_ior.in ());
ACE_OS::fclose (output_file);
}
catch (CORBA::Exception &ex)
{
ex._tao_print_exception ("cannot run server");
}
root_poa->destroy (1, 1);
orb->destroy ();
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 obj =
orb->string_to_object( ior );
Messenger_var messenger =
Messenger::_narrow( obj.in() );
CORBA::String_var message =
CORBA::string_dup( "Terminating messenger service!" );
messenger->send_message( "Chief of Security",
"New Directive",
message.inout() );
messenger->shutdown("Chief of Security");
Security::QOP qop =
Security::SecQOPIntegrityAndConfidentiality;
CORBA::Any want_protection;
want_protection <<= qop;
CORBA::Policy_var policy =
orb->create_policy (Security::SecQOPPolicy,
want_protection);
Security::EstablishTrust establish_trust;
establish_trust.trust_in_client = 0;
establish_trust.trust_in_target = 1;
CORBA::Any want_trust;
want_trust <<= establish_trust;
CORBA::Policy_var policy2 =
orb->create_policy (Security::SecEstablishTrustPolicy,
want_trust);
CORBA::PolicyList policy_list (2);
policy_list.length (1);
policy_list[0] =
CORBA::Policy::_duplicate (policy.in ());
policy_list.length (2);
policy_list[1] =
CORBA::Policy::_duplicate (policy2.in ());
CORBA::Object_var object =
obj->_set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
Messenger_var messenger2 =
Messenger::_narrow( object.in() );
message =
CORBA::string_dup( "Terminating messenger service!" );
messenger2->send_message( "Chief of Security",
"New Directive",
message.inout() );
messenger2->shutdown("Chief of Security");
orb->destroy();
}
catch(const CORBA::Exception& ex)
{
ex._tao_print_exception("Client: main block");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
if (parse_args(argc, argv) != 0) {
return 1;
}
// Create a bidirectional POA
CORBA::Object_var obj = orb->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa = PortableServer::POA::_narrow(obj.in());
PortableServer::POAManager_var poa_manager = root_poa->the_POAManager();
// Policies for the childPOA to be created.
CORBA::PolicyList policies(1);
policies.length(1);
CORBA::Any pol;
pol <<= BiDirPolicy::BOTH;
policies[0] =
orb->create_policy(BiDirPolicy::BIDIRECTIONAL_POLICY_TYPE, pol);
// Create POA as child of RootPOA with the above policies. This POA
// will receive request in the same connection in which it sent
// the request
PortableServer::POA_var poa = root_poa->create_POA("bidirPOA", poa_manager.in(), policies);
// Creation of bidirPOA is over. Destroy the Policy objects.
for (CORBA::ULong i = 0; i < policies.length (); ++i) {
policies[i]->destroy ();
}
poa_manager->activate ();
PortableServer::Servant_var<Simple_i> svt = new Simple_i(orb.in(), callback_count);
// Register and activate Simple servant
PortableServer::ObjectId_var id = poa->activate_object(svt.in());
obj = poa->id_to_reference(id.in());
Simple_var server = Simple::_narrow(obj.in());
CORBA::String_var ior = orb->object_to_string(server.in());
if (ior_output_file != ACE_TEXT("")) {
std::ofstream outfile(ACE_TEXT_ALWAYS_CHAR(ior_output_file.c_str()));
outfile << ior.in();
}
std::cout << "Activated as " << ior.in() << std::endl;
// Our own special orb->run() that knows how to callback clients
while (true) {
// returns 1 as soon as it has successfully called back.
if (svt->call_client()) {
break;
}
// We don't want to check for work pending, because we really want
// to simulate a normal orb->run() while adding the ability to call
// our routine which calls back to the client.
orb->perform_work();
}
std::cout << "Event loop finished." << std::endl;
CORBA::Boolean etherealize = true, wait = true;
poa->destroy(etherealize, wait);
orb->destroy();
return 0;
}
catch(const CORBA::Exception& ex) {
std::cerr << "Caught CORBA::Exception: " << std::endl << ex << std::endl;
}
return 1;
}
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[])
{
int retval = 0;
try
{
// Initialise ORB
CORBA::ORB_var Orb = CORBA::ORB_init(argc, argv);
// Set round-trip timeout
const int timeout_secs = 5;
CORBA::Object_var obj = Orb->resolve_initial_references ("ORBPolicyManager");
CORBA::PolicyManager_var policy_manager =
CORBA::PolicyManager::_narrow (obj.in());
CORBA::PolicyList policy_list;
policy_list.length(0);
policy_manager->set_policy_overrides(policy_list, CORBA::SET_OVERRIDE);
TimeBase::TimeT timeout = timeout_secs * 10000000;
CORBA::Any orb_timeout;
orb_timeout <<= timeout;
policy_list.length(1);
policy_list[0] = Orb->create_policy(
Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE, orb_timeout);
policy_manager->set_policy_overrides(policy_list, CORBA::SET_OVERRIDE);
// Now try to contact a server.
// Use a remote machine that is unreachable on the network.
const char * obj_ref = "corbaloc:iiop:[email protected]:4567/NameService";
obj = Orb->string_to_object(obj_ref);
CosNaming::NamingContext_var inc;
if(!CORBA::is_nil(obj.in ()))
{
ACE_DEBUG(( LM_INFO, "Attempting to contact %C\n", obj_ref ));
try
{
inc = CosNaming::NamingContext::_narrow(obj.in());
ACE_DEBUG(( LM_INFO, "OK\n" ));
}
catch(const CORBA::TRANSIENT &)
{
ACE_ERROR ((LM_ERROR, "Error, caught transient exception\n"));
retval = 1;
}
catch(const CORBA::TIMEOUT &)
{
ACE_DEBUG ((LM_DEBUG, "Caught correct timeout\n"));
}
}
}
catch (const ::CORBA::Exception &ex)
{
ex._tao_print_exception("ERROR : unexpected CORBA exception caugth :");
++retval;
}
return retval;
}
int
initORB(int threadID)
{
try
{
char ORBid[10];
ACE_OS::sprintf (ORBid, "ORB_%d", threadID);
ACE_DEBUG ((LM_DEBUG, "Initializing ORB \"%C\"\n", ORBid));
if ( g_registerORBinitializer )
{
ACE_DEBUG ((LM_DEBUG, "Creating ORB initializer\n"));
PortableInterceptor::ORBInitializer_var rCOI(
new MyORBinitializer( ORBid ) );
PortableInterceptor::register_orb_initializer( rCOI.in() );
}
ACE_DEBUG ((LM_DEBUG, "Creating TAO_ORB_Manager\n"));
TAO_ORB_Manager* pORBmgr = new TAO_ORB_Manager;
if ( -1 == pORBmgr->init( g_argc, g_argv, ORBid ) )
{
ACE_DEBUG ((LM_DEBUG, "Failed to initialize ORB \"%C\"\n", ORBid));
throw CORBA::INTERNAL();
}
ACE_DEBUG ((LM_DEBUG, "ORB \"%C\" initialized\n", ORBid));
if ( g_setTimeout )
{
ACE_DEBUG ((LM_DEBUG,
"Setting connection timeout policy for ORB \"%C\"\n",
ORBid));
CORBA::PolicyList policyList;
CORBA::ORB_var orb = pORBmgr->orb();
TimeBase::TimeT connectionTimeout = 100*10000;
CORBA::Any any;
any <<= connectionTimeout;
CORBA::ULong l( policyList.length() );
policyList.length( l+1 );
policyList[l] = orb->create_policy(
TAO::CONNECTION_TIMEOUT_POLICY_TYPE,
any );
ACE_DEBUG ((LM_DEBUG, "Connection timeout policy set for ORB \"%C\"\n",
ORBid));
}
pORBmgr->fini();
delete pORBmgr;
}
catch (const CORBA::Exception& ex)
{
ACE_ERROR ((LM_ERROR, "Caught exception: %C\n", ex._info().c_str()));
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;
CORBA::Object_var tmp =
orb->string_to_object(ior);
Test::Service_var service =
Test::Service::_narrow(tmp.in ());
if (CORBA::is_nil (service.in ()))
{
ACE_ERROR_RETURN ((LM_DEBUG,
"Nil service reference <%s>\n",
ior),
1);
}
Callback *callback_impl;
ACE_NEW_RETURN (callback_impl,
Callback(orb.in ()),
1);
PortableServer::ServantBase_var owner_transfer(callback_impl);
PortableServer::ObjectId_var id =
root_poa->activate_object (callback_impl);
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
Test::Callback_var callback =
Test::Callback::_narrow (object.in ());
poa_manager->activate ();
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) client - starting test\n"));
service->run_test (callback.in ());
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) client - running ORB\n"));
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
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();
Publisher_impl publisher(orb.in ());
PortableServer::ObjectId_var id = root_poa->activate_object (&publisher);
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
Publisher_var publisher_var = Publisher::_narrow (object.in ());
CORBA::String_var ior = orb->object_to_string(publisher_var.in());
ACE_DEBUG ((LM_DEBUG, "Activated as <%C>\n", ior.in()));
// output the ior
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();
const CORBA::Object_var pmobj (orb->resolve_initial_references("ORBPolicyManager" ) );
CORBA::PolicyManager_var policy_manager = CORBA::PolicyManager::_narrow(pmobj.in() );
CORBA::Any orb_level;
orb_level <<= Messaging::SYNC_NONE;
CORBA::PolicyList policy_list;
policy_list.length(1);
policy_list[0] = orb->create_policy(Messaging::SYNC_SCOPE_POLICY_TYPE,
orb_level);
policy_manager->set_policy_overrides(policy_list,
CORBA::SET_OVERRIDE);
ThreadPool pool (orb.in ());
if (pool.activate(THR_NEW_LWP | THR_JOINABLE, 5) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot activate client threads\n"),
1);
pool.thr_mgr ()->wait ();
ACE_DEBUG ((LM_DEBUG, "event loop finished\n"));
}
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;
// Primary server
CORBA::Object_var object_primary =
orb->string_to_object (ior);
//Secondary server
CORBA::Object_var object_secondary =
orb->string_to_object (name);
// Get an object reference for the ORBs IORManipultion object!
CORBA::Object_var IORM =
orb->resolve_initial_references (TAO_OBJID_IORMANIPULATION, 0);
TAO_IOP::TAO_IOR_Manipulation_var iorm =
TAO_IOP::TAO_IOR_Manipulation::_narrow (IORM.in ());
TAO_IOP::TAO_IOR_Manipulation::IORList iors (2);
iors.length(2);
iors [0] = object_primary;
iors [1] = object_secondary;
CORBA::Object_var merged = iorm->merge_iors (iors);
CORBA::Object_var object =
orb->resolve_initial_references ("PolicyCurrent");
CORBA::PolicyCurrent_var policy_current =
CORBA::PolicyCurrent::_narrow (object.in ());
CORBA::Any timeout_as_any;
timeout_as_any <<= timeout_period;
CORBA::PolicyList policy_list (1);
policy_list.length (1);
policy_list[0] =
orb->create_policy (TAO::CONNECTION_TIMEOUT_POLICY_TYPE,
timeout_as_any);
policy_current->set_policy_overrides (policy_list,
CORBA::ADD_OVERRIDE);
for (CORBA::ULong l = 0;
l != policy_list.length ();
++l)
{
policy_list[l]->destroy ();
}
// Combined IOR stuff
Simple_Server_var server =
Simple_Server::_narrow (merged.in ());
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%s> is nil.\n",
ior),
1);
}
CORBA::ULongLong freq =
run_test (server.in ());
if (freq != 919263)
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P|%t) ERROR in the test\n")));
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Shutting server down\n")));
server->shutdown ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught an exception\n");
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 ();
// 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 child_poa =
root_poa->create_POA ("childPOA",
poa_manager.in (),
policies);
// Creation of childPOA is over. Destroy the Policy objects.
for (CORBA::ULong i = 0;
i < policies.length ();
++i)
{
policies[i]->destroy ();
}
poa_manager->activate ();
CORBA::Object_var object =
orb->string_to_object (ior);
Sender_var sender =
Sender::_narrow (object.in ());
if (CORBA::is_nil (sender.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%s> is nil.\n",
ior),
1);
}
Receiver_i *receiver;
ACE_NEW_RETURN (receiver,
Receiver_i (),
-1);
PortableServer::ServantBase_var owner_transfer (receiver);
PortableServer::ObjectId_var id =
root_poa->activate_object (receiver);
CORBA::Object_var object_act = root_poa->id_to_reference (id.in ());
Receiver_var receiver_obj =
Receiver::_narrow (object_act.in ());
// Send the calback object to the server
sender->receiver_object (receiver_obj.in ());
// Threads that will handle the call backs
Client_Task client_task (orb.in (),
ACE_Thread_Manager::instance ());
if (client_task.activate (THR_NEW_LWP | THR_JOINABLE, 4, 1) == -1)
{
ACE_ERROR ((LM_ERROR, "Error activating client task\n"));
}
ACE_Thread_Manager::instance ()->wait ();
CORBA::Long count =
receiver->get_event_count ();
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) Number of events received.. [%d]\n",
count));
root_poa->destroy (1,
1);
}
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_WITH_TRANSPORT;
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> impl;
{
Echo * 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 (orb.in (), 100),
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_var echo =
Test::Echo::_narrow (object_act.in ());
CORBA::Object_var tmp =
orb->string_to_object(ior);
Test::Echo_Caller_var server =
Test::Echo_Caller::_narrow(tmp.in ());
if (CORBA::is_nil (echo.in ()))
{
ACE_ERROR_RETURN ((LM_DEBUG,
"Nil Test::Echo_Caller reference <%s>\n",
ior),
1);
}
poa_manager->activate ();
Client_Task ctask (orb.in ());
server->start_task (echo.in());
if (ctask.activate (THR_NEW_LWP | THR_JOINABLE,
4,
1) == -1)
{
ACE_ERROR ((LM_ERROR,
"Error activating client task\n"));
return 1;
}
ACE_Thread_Manager::instance ()->wait ();
ACE_DEBUG ((LM_DEBUG, "(%P|%t) client - event loop finished\n"));
// Actually the code here should never be reached.
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 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 ();
CORBA::Object_var object =
orb->resolve_initial_references ("PolicyCurrent");
CORBA::PolicyCurrent_var policy_current =
CORBA::PolicyCurrent::_narrow (object.in ());
TimeBase::TimeT timeout_period = 10 * 1000;
CORBA::Any timeout_as_any;
timeout_as_any <<= timeout_period;
CORBA::PolicyList policy_list (1);
policy_list.length (1);
policy_list[0] =
orb->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE,
timeout_as_any);
policy_current->set_policy_overrides (policy_list,
CORBA::ADD_OVERRIDE);
// 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,
8) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot activate client threads\n"),
1);
client.thr_mgr ()->wait ();
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 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
TAO_EC_Default_Factory::init_svcs ();
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);
// 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);
#if (TAO_HAS_CORBA_MESSAGING == 1)
CORBA::Object_var manager_object =
orb->resolve_initial_references ("ORBPolicyManager");
CORBA::PolicyManager_var policy_manager =
CORBA::PolicyManager::_narrow (manager_object.in ());
CORBA::Any sync_scope;
sync_scope <<= Messaging::SYNC_WITH_TARGET;
CORBA::PolicyList policy_list (1);
policy_list.length (1);
policy_list[0] =
orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE,
sync_scope);
policy_manager->set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
#else
ACE_DEBUG ((LM_DEBUG,
"CORBA Messaging disabled in this configuration,"
" test may not be optimally configured\n"));
#endif /* TAO_HAS_MESSAGING */
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;
TAO_EC_Event_Channel_Attributes attr (root_poa.in (),
root_poa.in ());
TAO_EC_Event_Channel ec_impl (attr);
ec_impl.activate ();
RtecEventChannelAdmin::EventChannel_var ec =
ec_impl._this ();
CORBA::String_var str =
orb->object_to_string (ec.in ());
if (ior_file_name != 0)
{
FILE *output_file= ACE_OS::fopen (ior_file_name, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s",
ior_file_name),
1);
ACE_OS::fprintf (output_file, "%s", str.in ());
ACE_OS::fclose (output_file);
}
orb->run ();
PortableServer::ObjectId_var id =
root_poa->servant_to_id (&ec_impl);
root_poa->deactivate_object (id.in ());
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception (argv[0]);
}
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
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;
CORBA::Object_var obj;
//Specify the relative round trip policy
if (rt_timeout_msecs > 0)
{
// Timeout specified in hundreds of nanoseconds which is
// 10000 milliseconds.
TimeBase::TimeT relative_rt_timeout = rt_timeout_msecs * 10000;
CORBA::Any relative_rt_timeout_as_any;
relative_rt_timeout_as_any <<= relative_rt_timeout;
CORBA::PolicyList policy_list(1);
policy_list.length(1);
policy_list[0] =
orb->create_policy(Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE,
relative_rt_timeout_as_any);
// Apply the policy at the ORB level.
obj = orb->resolve_initial_references("ORBPolicyManager");
CORBA::PolicyManager_var policy_manager =
CORBA::PolicyManager::_narrow(obj.in());
policy_manager->set_policy_overrides (policy_list, CORBA::ADD_OVERRIDE);
// Destroy the Policy objects.
for (CORBA::ULong i = 0; i < policy_list.length(); ++i) {
policy_list[i]->destroy ();
}
policy_list.length(0);
}
///// Get object reference /////
obj = orb->resolve_initial_references("Test");
ACE_ASSERT (!CORBA::is_nil(obj.in()));
Test_var test = Test::_narrow( obj.in() );
ACE_ASSERT (!CORBA::is_nil(test.in()));
if (max_tries > 1)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) Maximum number of tries = %d\n",
max_tries));
}
CORBA::Short n = 0;
for (int i = 0; i < max_tries; ++i)
{
try
{
n = test->get_num_requests (request_delay_secs);
}
catch (const CORBA::TIMEOUT &ex)
{
ex._tao_print_exception ("timeout exception:");
if (i == max_tries - 1)
throw;
}
}
if (n == 0)
{
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) ERROR: Expected number of requests from "
"server to be > 0\n"),
-1);
}
else
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) Client got back <%d>\n",
n));
}
// In a per client situation the client has to shutdown the server
if (shutdown_server)
{
test->shutdown();
}
orb->destroy ();
return 0;
}
catch(const CORBA::Exception& ex) {
ex._tao_print_exception ("Client:");
}
return -1;
}
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 ("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 ();
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;
Server *server_impl = 0;
ACE_NEW_RETURN (server_impl,
Server (orb.in ()),
1);
PortableServer::ServantBase_var owner_transfer(server_impl);
PortableServer::ObjectId_var id =
root_poa->activate_object (server_impl);
object = root_poa->id_to_reference (id.in ());
Test::Server_var test_server = Test::Server::_narrow (object.in ());
CORBA::String_var ior = orb->object_to_string (test_server.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 ();
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;
}