void
Test_Idl_SharedIntf_i::do_upcall (void)
{
ACE_DEBUG((LM_DEBUG,"(%P|%t) Test_Idl_SharedIntf::do_upcall called\n"));
CORBA::Object_var obj =
orb_->resolve_initial_references ("ORBPolicyManager");
CORBA::PolicyManager_var policy_manager_ =
CORBA::PolicyManager::_narrow (obj.in ());
TimeBase::TimeT timeout = 10000 * 100;
CORBA::Any any_orb;
any_orb <<= timeout;
CORBA::PolicyList policy_list (1);
policy_list.length (1);
policy_list[0] =
orb_->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE,
any_orb);
policy_manager_->set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
obj = this->orb_->string_to_object (this->upper_ior.in());
Test_Idl::SharedIntf_var upper = Test_Idl::SharedIntf::_narrow (obj.in());
upper->ping ();
ACE_DEBUG((LM_DEBUG,"(%P|%t) Test_Idl_SharedIntf::do_upcall returning\n"));
}
PriorityBand_Setup::PriorityBand_Setup (CORBA::ORB_ptr orb,
const RTCORBA_Setup &rtcorba_setup)
{
CORBA::PolicyManager_var policy_manager =
RIR_Narrow<CORBA::PolicyManager>::resolve (orb, "ORBPolicyManager");
RTCORBA::RTORB_var rtorb =
RIR_Narrow<RTCORBA::RTORB>::resolve (orb, "RTORB");
const RTCORBA::ThreadpoolLanes &lanes = rtcorba_setup.lanes ();
RTCORBA::PriorityBands priority_bands (3); priority_bands.length (3);
for (CORBA::ULong i = 0; i != lanes.length (); ++i)
{
priority_bands[i].low = lanes[i].lane_priority;
priority_bands[i].high = lanes[i].lane_priority;
}
CORBA::PolicyList policy_list (1); policy_list.length (1);
policy_list[0] =
rtorb->create_priority_banded_connection_policy (priority_bands);
policy_manager->set_policy_overrides (policy_list,
CORBA::ADD_OVERRIDE);
policy_list[0]->destroy ();
}
int
insecure_invocation_test (CORBA::ORB_ptr orb,
CORBA::Object_ptr obj)
{
// 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 =
obj->_set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
Foo::Bar_var server =
Foo::Bar::_narrow (object.in ());
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR ((LM_ERROR,
"(%P|%t) ERROR: Object reference <%s> is "
"nil.\n",
ior));
return 1;
}
try
{
// This invocation should result in a CORBA::NO_PERMISSION
// exception.
server->baz ();
}
catch (const CORBA::NO_PERMISSION&)
{
ACE_DEBUG ((LM_INFO,
"(%P|%t) Received CORBA::NO_PERMISSION from "
"server, as expected.\n"));
return 0;
}
ACE_ERROR ((LM_ERROR,
"(%P|%t) ERROR: CORBA::NO_PERMISSION was not thrown.\n"
"(%P|%t) ERROR: It should have been thrown.\n"));
return 1;
}
void
TAO_Notify_Service_Driver::apply_timeout (CORBA::ORB_ptr orb)
{
#if defined (TAO_HAS_CORBA_MESSAGING) && TAO_HAS_CORBA_MESSAGING != 0
if (this->timeout_ != 0)
{
// convert from msec to "TimeT"
CORBA::Any timeout;
TimeBase::TimeT value = 10000 * this->timeout_;
timeout <<= value;
CORBA::Object_var object =
orb->resolve_initial_references ("ORBPolicyManager");
CORBA::PolicyManager_var policy_manager =
CORBA::PolicyManager::_narrow (object.in ());
if (CORBA::is_nil (policy_manager.in ()))
throw CORBA::INTERNAL ();
CORBA::PolicyList policy_list (1);
policy_list.length (1);
policy_list[0] = orb->create_policy (
Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE,
timeout);
policy_manager->set_policy_overrides (policy_list, CORBA::SET_OVERRIDE);
policy_list[0]->destroy ();
}
#else
ACE_UNUSED_ARG (orb);
#endif /* TAO_HAS_CORBA_MESSAGING != 0 */
}
void
prov_interface_2_exec_i::invoke_on_interface_2 (void)
{
ACE_DEBUG ((LM_DEBUG, "prov_interface_2_exec_i::invoke_on_interface_2 - "
"Call received -> invoking 'invoke_on_interface_1' on Component1\n"));
::CORBA::Object_var ccm_object =
this->ciao_context_->get_CCM_object();
::CORBA::ORB_var orb;
if (! ::CORBA::is_nil (ccm_object.in ()))
{
orb = ccm_object->_get_orb ();
}
CORBA::Object_var object =
orb->resolve_initial_references ("PolicyCurrent");
CORBA::PolicyCurrent_var policy_current =
CORBA::PolicyCurrent::_narrow (object.in ());
TimeBase::TimeT timeout_period = 100 * 100000;
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);
policy_list[0]->destroy();
::Threading::interface_1_var interface_1 =
this->ciao_context_->get_connection_use_interface_1 ();
bool except = false;
try
{
interface_1->invoke_on_interface_1 ();
}
catch (const CORBA::TIMEOUT&)
{
except = true;
ACE_DEBUG ((LM_DEBUG,
"invoke_on_interface_1 ping received an expected except.\n"));
}
if (!except)
{
ACE_DEBUG ((LM_DEBUG, "ERROR prov_interface_2_exec_i::invoke_on_interface_2 - "
"Is not blocking!!\n"));
}
}
void
TAO_Notify_POA_Helper::init_persistent (PortableServer::POA_ptr parent_poa, const char* poa_name)
{
CORBA::PolicyList policy_list (2);
this->set_persistent_policy (parent_poa, policy_list);
this->create_i (parent_poa, poa_name, policy_list);
}
bool
TAO_PG_ObjectGroupManager::ping (CORBA::ORB_ptr orb,
CORBA::Object_var& obj,
const TimeBase::TimeT& tt)
{
bool status = true;
if (CORBA::is_nil (obj.in ()))
throw CORBA::OBJECT_NOT_EXIST ();
// The ping() is used by LoadBalancer which may use RW strategy.
// The validate thread invokes the _non_existent call to members
// sequencially. We have to put a timeout on the call in case
// the client side is not processing ORB requests at this time.
// In the event that the timeout exception occurs, we will assume
// that the peer is still around. If we get any other exception
// we will say that the member is not available anymore.
TimeBase::TimeT timeout = tt;
CORBA::Any timeout_any;
timeout_any <<= timeout;
CORBA::PolicyList policy_list (1);
policy_list.length (1);
policy_list[0] = orb->
create_policy (
Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE,
timeout_any);
CORBA::Object_var rtt_obj =
obj->_set_policy_overrides (policy_list,
CORBA::ADD_OVERRIDE);
// Clean up the policy that was allocated in the try/catch
for (CORBA::ULong i = 0; i < policy_list.length (); i++)
policy_list[i]->destroy ();
try {
status = ! rtt_obj->_non_existent ();
}
catch (const CORBA::TIMEOUT& ex)
{
if (TAO_debug_level > 8)
{
ex._tao_print_exception ("TAO_PG_ObjectGroupManager::ping");
}
}
catch (const CORBA::Exception& ex)
{
if (TAO_debug_level > 8)
{
ex._tao_print_exception ("TAO_PG_ObjectGroupManager::ping");
}
status = false;
}
return status;
}
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;
}
bool
ClientTest::non_secure_invocation ()
{
ACE_DEBUG ((LM_DEBUG, "mixed_security/client: invoking via non-secured means\n"));
// 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 =
this->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 =
this->obj_->_set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
Foo::Bar_var server =
Foo::Bar::_narrow (object.in ());
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR ((LM_ERROR,
"(%P|%t) ERROR: Failed to narrow override reference to "
"Foo::Bar type.\n"));
throw CORBA::INTERNAL ();
}
bool invocation_succeeded = true;
try
{
// This invocation should result in a CORBA::NO_PERMISSION
// exception.
server->baz ();
ACE_DEBUG ((LM_DEBUG, "mixed_security/client: non-secured invocation succeeded\n"));
}
catch (const CORBA::NO_PERMISSION& )
{
ACE_DEBUG ((LM_DEBUG,
"ClientTest::non_secure_invocation: got NO_PERMISSION\n"));
invocation_succeeded = false;
}
return invocation_succeeded;
}
bool
Client::flood_connection (ACE_Time_Value& tv)
{
// Block flushing currently blocks even on SYNC_DELAYED_BUFFERING
// so we can't use it to flood connections.
// Set the policy value.
// SYNC_DELAYED_BUFFERING is used to ensure that the tcp buffer gets filled before
// buffering starts.
Messaging::SyncScope sync_scope = TAO::SYNC_DELAYED_BUFFERING;
//Messaging::SyncScope sync_scope = Messaging::SYNC_NONE;
CORBA::Any sync_scope_any;
sync_scope_any <<= sync_scope;
CORBA::PolicyList policy_list (1);
policy_list.length (1);
policy_list[0] = orb_->create_policy
(Messaging::SYNC_SCOPE_POLICY_TYPE, sync_scope_any);
// Apply the policy at the object level
CORBA::Object_var obj = test_obj_->_set_policy_overrides
(policy_list, CORBA::SET_OVERRIDE);
Test_var mod_test_obj = Test::_narrow (obj.in ());
policy_list[0]->destroy ();
policy_list.length(0);
ACE_Auto_Array_Ptr<char> tmp (new char [2000000]);
char* msg = tmp.get();
ACE_OS::memset (msg,'A',1999999);
msg[1999999] = 0;
test_obj_->sleep (static_cast<CORBA::Long>(tv.sec())
, static_cast<CORBA::Long>(tv.msec()));
/* BLOCK flush startegy always has SYNC_WITH_TRANSPORT semantics.
Trying to flood a BLOCKed flushing connection can lead to a TIMEOUT
exception being thrown. This will close out the connection and
the whole flooding attempt fails. Therefore in BLOCK flushing case
don't attempt to flood (unless BLOCK flush accepts SYNC_WITH_TRANSPORT
semantics).
*/
if (flush_strategy_ != BLOCKING)
{
mod_test_obj->dummy_one_way (msg);
// attempt again to flood connection.
ACE_Time_Value tv_tmp (2);
orb_->perform_work (tv_tmp);
}
return true;
}
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;
}
int
Client_Task::svc (void)
{
// ACE_DEBUG ((LM_DEBUG, "(%P|%t) Starting client task\n"));
try
{
CORBA::Object_var object =
this->orb_->resolve_initial_references ("PolicyCurrent");
CORBA::PolicyCurrent_var policy_current =
CORBA::PolicyCurrent::_narrow (object.in ());
TimeBase::TimeT timeout_period = 20 * 1000;
CORBA::Any timeout_as_any;
timeout_as_any <<= timeout_period;
CORBA::PolicyList policy_list (1);
policy_list.length (1);
policy_list[0] =
this->orb_->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE,
timeout_as_any);
policy_current->set_policy_overrides (policy_list,
CORBA::ADD_OVERRIDE);
policy_list[0]->destroy();
// Start 25 separate concurrent request streams
for (CORBA::Short i = 0; i != 25; ++i)
{
this->receiver_->sendc_short_sleep (this->handler_var_.in ());
}
ACE_Time_Value tv(10, 0);
orb_->run(tv);
}
catch (const CORBA::TIMEOUT&)
{
ACE_DEBUG ((LM_DEBUG,
"Client received an expected CORBA::TIMEOUT exception.\n"));
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("(%P|%t) Client_Task - caught exception:");
return -1;
}
return 0;
}
void
TAO_Notify_RT_POA_Helper::init (PortableServer::POA_ptr parent_poa, const char* poa_name
, const NotifyExt::ThreadPoolLanesParams& tpl_params)
{
CORBA::PolicyList policy_list (4);
this->set_policy (parent_poa, policy_list);
RTCORBA::RTORB_var rt_orb = TAO_Notify_RT_PROPERTIES::instance ()->rt_orb ();
RTCORBA::PriorityModel priority_model =
tpl_params.priority_model == NotifyExt::CLIENT_PROPAGATED ?
RTCORBA::CLIENT_PROPAGATED : RTCORBA::SERVER_DECLARED;
policy_list.length (3);
policy_list[2] =
rt_orb->create_priority_model_policy (priority_model,
tpl_params.server_priority);
// Populate RTCORBA Lanes.
RTCORBA::ThreadpoolLanes lanes (tpl_params.lanes.length ());
lanes.length (tpl_params.lanes.length ());
for (CORBA::ULong index = 0; index < tpl_params.lanes.length (); ++index)
{
if (TAO_debug_level > 0)
{
ORBSVCS_DEBUG ((LM_DEBUG, "Creating threadpool lane %d: priority = %d, static threads = %d\n",
index, tpl_params.lanes[index].lane_priority, tpl_params.lanes[index].static_threads));
}
lanes[index].lane_priority = tpl_params.lanes[index].lane_priority;
lanes[index].static_threads = tpl_params.lanes[index].static_threads;
lanes[index].dynamic_threads = tpl_params.lanes[index].dynamic_threads;
}
// Create the thread-pool.
RTCORBA::ThreadpoolId threadpool_id =
rt_orb->create_threadpool_with_lanes (tpl_params.stacksize,
lanes,
tpl_params.allow_borrowing,
tpl_params.allow_request_buffering,
tpl_params.max_buffered_requests,
tpl_params.max_request_buffer_size);
policy_list.length (4);
policy_list[3] =
rt_orb->create_threadpool_policy (threadpool_id);
this->create_i (parent_poa, poa_name, policy_list);
}
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 ();
}
void
TAO_Notify_RT_POA_Helper::init (PortableServer::POA_ptr parent_poa)
{
CORBA::PolicyList policy_list (1);
RTCORBA::RTORB_var rt_orb = TAO_Notify_RT_PROPERTIES::instance ()->rt_orb ();
policy_list.length (1);
policy_list[0] =
rt_orb->create_priority_model_policy (RTCORBA::CLIENT_PROPAGATED,
0);
ACE_CString child_poa_name = this->get_unique_id ();
this->create_i (parent_poa, child_poa_name.c_str (), policy_list);
}
void
TAO_Notify_RT_POA_Helper::init (PortableServer::POA_ptr parent_poa, const char* poa_name
, const NotifyExt::ThreadPoolParams& tp_params)
{
CORBA::PolicyList policy_list (4);
this->set_policy (parent_poa, policy_list);
RTCORBA::RTORB_var rt_orb = TAO_Notify_RT_PROPERTIES::instance ()->rt_orb ();
RTCORBA::PriorityModel priority_model =
tp_params.priority_model == NotifyExt::CLIENT_PROPAGATED ?
RTCORBA::CLIENT_PROPAGATED : RTCORBA::SERVER_DECLARED;
if (TAO_debug_level > 0)
ORBSVCS_DEBUG ((LM_DEBUG, "Priority Model = %d, Server prio = %d\n"
, tp_params.priority_model, tp_params.server_priority));
policy_list.length (3);
policy_list[2] =
rt_orb->create_priority_model_policy (priority_model,
tp_params.server_priority);
if (TAO_debug_level > 0)
ORBSVCS_DEBUG ((LM_DEBUG, "Creating threadpool: static threads = %d, def. prio = %d\n"
, tp_params.static_threads, tp_params.default_priority));
// Create the thread-pool.
RTCORBA::ThreadpoolId threadpool_id =
rt_orb->create_threadpool (tp_params.stacksize,
tp_params.static_threads,
tp_params.dynamic_threads,
tp_params.default_priority,
tp_params.allow_request_buffering,
tp_params.max_buffered_requests,
tp_params.max_request_buffer_size);
policy_list.length (4);
policy_list[3] =
rt_orb->create_threadpool_policy (threadpool_id);
this->create_i (parent_poa, poa_name, policy_list);
}
int AMI_Primary_Replication_Strategy::svc()
{
try{
int argc = 0;
char** argv = 0;
orb_ = CORBA::ORB_init (argc, argv);
root_poa_ = resolve_init<PortableServer::POA>(orb_.in(), "RootPOA");
// create POAManager
mgr_ = root_poa_->the_POAManager();
mgr_->activate();
PortableServer::IdUniquenessPolicy_var id_uniqueness_policy =
root_poa_->create_id_uniqueness_policy(PortableServer::MULTIPLE_ID);
TAO::Utils::PolicyList_Destroyer policy_list(3);
policy_list.length(1);
policy_list[0] = PortableServer::IdUniquenessPolicy::_duplicate(
id_uniqueness_policy.in()
);
poa_ = create_persistent_poa(root_poa_, mgr_, "AMI_Update", policy_list);
id_uniqueness_policy->destroy();
running_ = true;
while (running_) {
if (orb_->work_pending())
orb_->perform_work();
}
orb_->destroy();
}
catch (const CORBA::Exception& ex){
ex._tao_print_exception ("AMI_Primary_Replication_Strategy::svc");
running_ = false;
return -1;
}
running_ = false;
return 0;
}
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();
}
}
void
SyncScope_Setup::init (CORBA::ORB_ptr orb,
Messaging::SyncScope value)
{
CORBA::PolicyManager_var policy_manager =
RIR_Narrow<CORBA::PolicyManager>::resolve (orb,
"ORBPolicyManager");
CORBA::PolicyList policy_list (1);
policy_list.length (1);
CORBA::Any sync_scope;
sync_scope <<= value;
// @@ We need a helper class that automatically calls the
// destroy() method on each policy...
policy_list[0] =
orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE,
sync_scope);
policy_manager->set_policy_overrides (policy_list,
CORBA::ADD_OVERRIDE);
policy_list[0]->destroy ();
}
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 ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var object =
orb->string_to_object (ior);
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);
}
object =
orb->resolve_initial_references ("ORBPolicyManager");
CORBA::PolicyManager_var policy_manager =
CORBA::PolicyManager::_narrow (object.in ());
object =
orb->resolve_initial_references ("PolicyCurrent");
CORBA::PolicyCurrent_var policy_current =
CORBA::PolicyCurrent::_narrow (object.in ());
TimeBase::TimeT mid_value =
10000 * (min_timeout + max_timeout) / 2; // convert from msec to "TimeT" (0.1 usec units)
CORBA::Any any_orb;
any_orb <<= mid_value;
CORBA::Any any_thread;
any_thread <<= mid_value + 10000; // midvalue + 1 msec
CORBA::Any any_object;
any_object <<= mid_value + 20000; // midvalue + 2 msec
CORBA::PolicyList policy_list (1);
policy_list.length (1);
policy_list[0] =
orb->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE,
any_object);
object =
server->_set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
Simple_Server_var timeout_server =
Simple_Server::_narrow (object.in ());
policy_list[0]->destroy ();
policy_list[0] = CORBA::Policy::_nil ();
ACE_DEBUG ((LM_DEBUG,
"client (%P) testing from %d to %d milliseconds\n",
min_timeout, max_timeout));
for (CORBA::Long t = min_timeout; t < max_timeout; ++t)
{
ACE_DEBUG ((LM_DEBUG,
"\n================================\n"
"Trying with timeout = %d msec\n", t));
ACE_DEBUG ((LM_DEBUG,
"Cleanup ORB/Thread/Object policies\n"));
policy_list.length (0);
policy_manager->set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
policy_current->set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
send_echo (none, orb.in (), server.in (), t);
ACE_DEBUG ((LM_DEBUG,
"client(%P) Set the ORB policies\n"));
policy_list.length (1);
policy_list[0] =
orb->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE,
any_orb);
policy_manager->set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
send_echo (orb1, orb.in (), server.in (), t);
policy_list[0]->destroy ();
ACE_DEBUG ((LM_DEBUG,
"client(%P) Set the thread policies\n"));
policy_list.length (1);
policy_list[0] =
orb->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE,
any_thread);
policy_current->set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
send_echo (thread1, orb.in (), server.in (), t);
policy_list[0]->destroy ();
ACE_DEBUG ((LM_DEBUG,
"client(%P) Use the object policies\n"));
send_echo (object1, orb.in (), timeout_server.in (), t);
}
ACE_DEBUG ((LM_DEBUG,
"\n\n\nclient(%P) Test completed, "
"resynch with server\n"));
policy_list.length (0);
policy_manager->set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
policy_current->set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
send_echo (none, orb.in (), server.in (), 0);
server->shutdown ();
int timeout_count_total = 0;
int in_time_count_total = 0;
for (int i = 0; i < 4; i++) {
timeout_count_total += timeout_count[i];
in_time_count_total += in_time_count[i];
ACE_DEBUG ((LM_DEBUG, "in_time_count[%C]= %d timeout_count[%C]= %d\n",
to_type_names[i], in_time_count[i],
to_type_names[i], timeout_count[i]));
}
if (timeout_count_total == 0)
ACE_ERROR ((LM_ERROR,
"ERROR: No messages timed out\n"));
//FUZZ: disable check_for_lack_ACE_OS
if (in_time_count_total == 0)
ACE_ERROR ((LM_ERROR,
"ERROR: No messages on time (within time limit)\n"));
//FUZZ: enable check_for_lack_ACE_OS
ACE_DEBUG ((LM_DEBUG, "in_time_count_total = %d, timeout_count_total = %d\n",
in_time_count_total, timeout_count_total));
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;
}
bool
Client::init (int argc, ACE_TCHAR* argv[])
{
try {
orb_ = CORBA::ORB_init (argc, argv, "Client");
if (CORBA::is_nil (orb_.in())) {
ACE_ERROR ((LM_ERROR, "Client::init> ORB initialization failed.\n"));
return false;
}
if (!this->parse_args (argc, argv)) {
return false;
}
// Timeout
TimeBase::TimeT timeout = 5 * 1000000; // 5 seconds
CORBA::Any any_object;
any_object <<= timeout;
CORBA::PolicyList policy_list (2);
policy_list.length (2);
policy_list[0] =
orb_->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE,
any_object);
// Timeout with SYNC_SCOPE SYNC_WITH_TRANSPORT
Messaging::SyncScope sync_with_transport = Messaging::SYNC_WITH_TRANSPORT;
CORBA::Any sync_with_transport_any;
sync_with_transport_any <<= sync_with_transport;
policy_list[1] = orb_->create_policy
(Messaging::SYNC_SCOPE_POLICY_TYPE, sync_with_transport_any);
CORBA::Object_var obj = test_obj_->_set_policy_overrides
(policy_list, CORBA::SET_OVERRIDE);
test_obj_transport_timeout_ = Test::_narrow (obj.in ());
policy_list[1]->destroy ();
// Timeout with SYNC_SCOPE SYNC_NONE
Messaging::SyncScope sync_none = Messaging::SYNC_NONE;
CORBA::Any sync_none_any;
sync_none_any <<= sync_none;
policy_list[1] = orb_->create_policy
(Messaging::SYNC_SCOPE_POLICY_TYPE, sync_none_any);
// Apply the policy at the object level
obj = test_obj_->_set_policy_overrides
(policy_list, CORBA::SET_OVERRIDE);
test_obj_none_timeout_ = Test::_narrow (obj.in ());
policy_list[1]->destroy ();
// Timeout with TAO specific SYNC_SCOPE SYNC_EAGER_BUFFERING
//Messaging::SyncScope eager_buffering = TAO::SYNC_EAGER_BUFFERING;
Messaging::SyncScope eager_buffering = Messaging::SYNC_NONE;
CORBA::Any eager_any;
eager_any <<= eager_buffering;
policy_list[1] = orb_->create_policy
(Messaging::SYNC_SCOPE_POLICY_TYPE, eager_any);
obj = test_obj_->_set_policy_overrides
(policy_list, CORBA::SET_OVERRIDE);
test_obj_eager_timeout_ = Test::_narrow (obj.in ());
policy_list[1]->destroy ();
// Timeout with TAO specific SYNC_SCOPE SYNC_DELAYED_BUFFERING
Messaging::SyncScope delayed_buffering = TAO::SYNC_DELAYED_BUFFERING;
CORBA::Any delayed_any;
delayed_any <<= delayed_buffering;
policy_list[1] = orb_->create_policy
(Messaging::SYNC_SCOPE_POLICY_TYPE, delayed_any);
obj = test_obj_->_set_policy_overrides
(policy_list, CORBA::SET_OVERRIDE);
test_obj_delayed_timeout_ = Test::_narrow (obj.in ());
policy_list[1]->destroy ();
// Timeout with default SYNC_SCOPE SYNC_WITH_SERVER
Messaging::SyncScope sync_with_server = Messaging::SYNC_WITH_SERVER;
CORBA::Any sync_with_server_any;
sync_with_server_any <<= sync_with_server;
policy_list[1] = orb_->create_policy
(Messaging::SYNC_SCOPE_POLICY_TYPE, sync_with_server_any);
obj = test_obj_->_set_policy_overrides
(policy_list, CORBA::SET_OVERRIDE);
test_obj_server_timeout_ = Test::_narrow (obj.in ());
policy_list[1]->destroy ();
// Timeout with default SYNC_SCOPE (SYNC_WITH_TARGET)
Messaging::SyncScope sync_with_target = Messaging::SYNC_WITH_TARGET;
CORBA::Any sync_with_target_any;
sync_with_target_any <<= sync_with_target;
policy_list[1] = orb_->create_policy
(Messaging::SYNC_SCOPE_POLICY_TYPE, sync_with_target_any);
// Apply the policy at the object level
obj = test_obj_->_set_policy_overrides
(policy_list, CORBA::SET_OVERRIDE);
test_obj_target_timeout_ = Test::_narrow (obj.in ());
policy_list[0]->destroy ();
policy_list[1]->destroy ();
policy_list.length(0);
}
catch( CORBA::Exception& ex) {
ACE_ERROR ((LM_ERROR, "(%P|%t) Client::Init> Caught CORBA::Exception %s"
, ex._info().c_str()));
return false;
}
return true;
}
FtRtecEventChannelAdmin::EventChannel_ptr
TAO_FTEC_Event_Channel::activate(TAO_FTEC_Event_Channel::MEMBERSHIP membership)
{
FTRTEC::Fault_Detector_Loader* detector_loader =
ACE_Dynamic_Service<FTRTEC::Fault_Detector_Loader>::instance("FTRTEC_Fault_Detector");
detector_loader->init(0, 0);
if (FTRTEC::Identification_Service::instance() == 0)
ORBSVCS_ERROR_RETURN((LM_ERROR, "No Identification\n"), 0);
// initialize naming_contex
CosNaming::NamingContext_var naming_context
= resolve_init<CosNaming::NamingContext>(orb_.in(), "NameService");
// initialize group info publisher
GroupInfoPublisher::instance()->set_naming_context(naming_context);
if (FTRTEC::Replication_Service::instance()->init(0,0) == -1)
return 0;
GroupInfoPublisher::instance()->subscribe(FTRTEC::Replication_Service::instance());
Request_Context_Repository().init(orb_.in());
// get POAManager
PortableServer::POAManager_var mgr = poa_->the_POAManager();
TAO::Utils::PolicyList_Destroyer policy_list(2);
persistent_poa_ =
create_persistent_poa(poa_, mgr, "FTEC_Persistant_POA", policy_list);
// Activate the Event channel implementation
TAO_EC_Event_Channel_Attributes attr (persistent_poa_.in (),
persistent_poa_.in ());
TAO_FTEC_Event_Channel_Impl* ec = 0;
ACE_NEW_THROW_EX (ec,
TAO_FTEC_Event_Channel_Impl (attr),
CORBA::NO_MEMORY());
this->ec_impl_ = ec;
const FtRtecEventComm::ObjectId& object_id
= FTRTEC::Identification_Service::instance()->object_id();
FtRtecEventComm::ObjectId consumer_admin_object_id(object_id);
consumer_admin_object_id[9]++;
FtRtecEventComm::ObjectId supplier_admin_object_id(consumer_admin_object_id);
supplier_admin_object_id[9]++;
ec->activate_object(orb_,
supplier_admin_object_id,
consumer_admin_object_id);
FtRtecEventChannelAdmin::EventChannel_var result;
activate_object_with_id(result.out(), persistent_poa_.in(), this, object_id);
setup_object_group(this,
naming_context.in(),
membership,
result.in());
return result._retn();
}
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 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;
}
void
TimeoutClient::send (CORBA::Boolean async,
unsigned long local_timeout,
unsigned long remote_sleep)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) Invoking "));
if (async)
ACE_DEBUG ((LM_DEBUG,
"asynch "));
else
ACE_DEBUG ((LM_DEBUG,
"synch "));
ACE_DEBUG ((LM_DEBUG,
"local: %dms remote: %dms ... ",
local_timeout,
remote_sleep));
CORBA::PolicyList policy_list (1);
try
{
if (local_timeout != 0)
{
TimeBase::TimeT timeout = 10000 * local_timeout;
CORBA::Any any_orb;
any_orb <<= timeout;
policy_list.length (1);
policy_list[0] =
orb_->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE,
any_orb);
policy_manager_->set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
}
else
{
policy_list.length (0);
policy_manager_->set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
}
// Start time measurement at the reply handler
timeoutHandler_i_->start ();
if (async)
{
timeoutObject_->sendc_sendTimeToWait (replyHandlerObject_.in (),
remote_sleep);
}
else // synch
{
timeoutObject_->sendTimeToWait (remote_sleep);
}
}
catch (const CORBA::TIMEOUT& )
{
local_reply_excep_counter_++;
// Trap this exception and continue...
ACE_DEBUG ((LM_DEBUG,
" timeout "));
}
// get rid of the policy, you created before.
try
{
if (local_timeout != 0)
{
policy_list[0]->destroy ();
}
}
catch (const CORBA::Exception&)
{
ACE_DEBUG ((LM_DEBUG,
"Error: Unexpected exception\n\n"));
}
// wait for responses
ACE_Time_Value tv (0, (local_timeout + remote_sleep)*2000 + 4000);
ACE_OS::sleep (tv);
ACE_Time_Value &elapsed_time = timeoutHandler_i_->elapsed_time ();
if (async)
ACE_DEBUG ((LM_DEBUG,
" .. needed %dms\n",
elapsed_time.msec()));
else
ACE_DEBUG ((LM_DEBUG,
" .. done\n"));
}
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 {
// 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
main (int argc, char *argv[])
{
try
{
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;
poa_manager->activate();
Hello *hello_impl;
ACE_NEW_RETURN (hello_impl,
Hello (shutdown_handler),
1);
PortableServer::ServantBase_var owner_transfer(hello_impl);
Test::Hello_var hello =
hello_impl->_this ();
ACE_DEBUG ((LM_DEBUG, "getting proxy reference\n"));
CORBA::Object_var obj =
orb->string_to_object (lorica_ior);
#if 0
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).
obj =
obj->_set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
#endif
ACE_DEBUG ((LM_DEBUG, "narrowing proxy reference\n"));
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);
#if 1
obj = register_with_proxy (hello.in());
#else
obj = mapper->as_server (hello.in(),"Hello",
Lorica::ServerAgent::_nil());
#endif
ACE_DEBUG ((LM_DEBUG,"register_with_proxy() returned\n"));
if (CORBA::is_nil (obj.in()))
ACE_ERROR_RETURN ((LM_ERROR,
"Lorica reference mapper returned a nil "
"mapped reference.\n"),1);
mapped_hello = Test::Hello::_narrow(obj.in());
if (CORBA::is_nil(mapped_hello.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 (hello.in ());
CORBA::String_var mapped_ior =
orb->object_to_string (mapped_hello.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);
if (linger)
orb->run();
else
shutdown_handler();
// No need to run the ORB the test only requires modifying an IOR
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
