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);
}
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 naming_obj =
orb->resolve_initial_references ("NameService");
CosNaming::NamingContext_var naming_context =
CosNaming::NamingContext::_narrow(naming_obj.in());
CosNaming::Name name;
name.length (1);
name[0].id = CORBA::string_dup("MyEventChannel");
CORBA::Object_var ecObj = naming_context->resolve(name);
CosNotifyChannelAdmin::EventChannel_var ec =
CosNotifyChannelAdmin::EventChannel::_narrow(ecObj.in());
CosNotifyChannelAdmin::AdminID adminid;
CosNotifyChannelAdmin::InterFilterGroupOperator ifgop =
CosNotifyChannelAdmin::AND_OP;
CosNotifyChannelAdmin::ConsumerAdmin_var consumer_admin =
ec->new_for_consumers(ifgop,
adminid);
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
PortableServer::POA_var poa =
PortableServer::POA::_narrow (poa_object.in());
CORBA::Object_var rtorb_obj = orb->resolve_initial_references ("RTORB");
RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (rtorb_obj.in ());
// Create an RT POA with a lane at the given priority.
CORBA::Policy_var priority_model_policy =
rt_orb->create_priority_model_policy (RTCORBA::CLIENT_PROPAGATED,
DEFAULT_PRIORITY);
RTCORBA::ThreadpoolLanes lanes (2);
lanes.length (2);
lanes[0].lane_priority = LOW_PRIORITY;
lanes[0].static_threads = 2;
lanes[0].dynamic_threads = 0;
lanes[1].lane_priority = HIGH_PRIORITY;
lanes[1].static_threads = 2;
lanes[1].dynamic_threads = 0;
// Create a thread-pool.
CORBA::ULong stacksize = 0;
CORBA::Boolean allow_request_buffering = 0;
CORBA::ULong max_buffered_requests = 0;
CORBA::ULong max_request_buffer_size = 0;
CORBA::Boolean allow_borrowing = 0;
// Create the thread-pool.
RTCORBA::ThreadpoolId threadpool_id =
rt_orb->create_threadpool_with_lanes (stacksize,
lanes,
allow_borrowing,
allow_request_buffering,
max_buffered_requests,
max_request_buffer_size);
// Create a thread-pool policy.
CORBA::Policy_var lanes_policy =
rt_orb->create_threadpool_policy (threadpool_id);
CORBA::PolicyList poa_policy_list(2);
poa_policy_list.length (2);
poa_policy_list[0] = priority_model_policy;
poa_policy_list[1] = lanes_policy;
PortableServer::POAManager_var poa_manager = poa->the_POAManager ();
PortableServer::POA_var rt_poa = poa->create_POA ("RT POA",
poa_manager.in (),
poa_policy_list);
PortableServer::Servant_var<StructuredEventConsumer_i> servant =
new StructuredEventConsumer_i(orb.in());
PortableServer::ObjectId_var objectId =
rt_poa->activate_object (servant.in());
CORBA::Object_var consumer_obj =
rt_poa->id_to_reference (objectId.in ());
CosNotifyComm::StructuredPushConsumer_var consumer =
CosNotifyComm::StructuredPushConsumer::_narrow (consumer_obj.in ());
NotifyExt::ThreadPoolLanesParams tpl_params;
tpl_params.priority_model = NotifyExt::CLIENT_PROPAGATED;
tpl_params.server_priority = DEFAULT_PRIORITY;
tpl_params.stacksize = 0;
tpl_params.allow_borrowing = 0;
tpl_params.allow_request_buffering = 0;
tpl_params.max_buffered_requests = 0;
tpl_params.max_request_buffer_size = 0;
tpl_params.lanes.length (2);
tpl_params.lanes[0].lane_priority = LOW_PRIORITY;
tpl_params.lanes[0].static_threads = 2;
tpl_params.lanes[0].dynamic_threads = 0;
tpl_params.lanes[1].lane_priority = HIGH_PRIORITY;
tpl_params.lanes[1].static_threads = 2;
tpl_params.lanes[1].dynamic_threads = 0;
CosNotification::QoSProperties qos;
qos.length(1);
qos[0].name = CORBA::string_dup (NotifyExt::ThreadPoolLanes);
qos[0].value <<= tpl_params;
consumer_admin->set_qos(qos);
CORBA::Object_var current_obj =
orb->resolve_initial_references ("RTCurrent");
RTCORBA::Current_var current =
RTCORBA::Current::_narrow (current_obj.in ());
current->the_priority(HIGH_PRIORITY);
CosNotifyChannelAdmin::ProxyID consumeradmin_proxy_id;
CosNotifyChannelAdmin::ProxySupplier_var proxy_supplier =
consumer_admin->obtain_notification_push_supplier(
CosNotifyChannelAdmin::STRUCTURED_EVENT,
consumeradmin_proxy_id);
CosNotifyChannelAdmin::StructuredProxyPushSupplier_var supplier_proxy;
supplier_proxy = CosNotifyChannelAdmin::StructuredProxyPushSupplier::
_narrow(proxy_supplier.in());
supplier_proxy->connect_structured_push_consumer(consumer.in());
CosNotification::EventTypeSeq added (1);
CosNotification::EventTypeSeq removed (1);
added.length (1);
removed.length (1);
added[0].domain_name = CORBA::string_dup ("OCI_TAO");
added[0].type_name = CORBA::string_dup ("examples");
removed[0].domain_name = CORBA::string_dup ("*");
removed[0].type_name = CORBA::string_dup ("*");
supplier_proxy->subscription_change(added, removed);
poa_manager->activate();
// Write a file to let the run_test.pl script know we are ready.
std::ofstream iorFile( ACE_TEXT_ALWAYS_CHAR(output_file) );
iorFile << "Ready" << std::endl;
iorFile.close();
orb->run();
}
catch(const CORBA::Exception& ex)
{
std::cerr << "Caught exception: " << ex << std::endl;
return 1;
}
return 0;
}
int
Task::svc (void)
{
try
{
CORBA::Object_var object =
this->orb_->resolve_initial_references ("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
object =
this->orb_->resolve_initial_references ("RTORB");
RTCORBA::RTORB_var rt_orb =
RTCORBA::RTORB::_narrow (object.in ());
object =
this->orb_->resolve_initial_references ("RTCurrent");
RTCORBA::Current_var current =
RTCORBA::Current::_narrow (object.in ());
RTCORBA::Priority default_thread_priority =
get_implicit_thread_CORBA_priority (this->orb_.in ());
test_i servant (this->orb_.in (),
root_poa.in (),
nap_time);
PortableServer::ObjectId_var id =
root_poa->activate_object (&servant);
CORBA::Object_var object_act = root_poa->id_to_reference (id.in ());
test_var test =
test::_narrow (object_act.in ());
int result =
write_ior_to_file (this->orb_.in (),
test.in ());
if (result != 0)
return result;
poa_manager->activate ();
CORBA::ULong stacksize = 0;
CORBA::Boolean allow_request_buffering = false;
CORBA::ULong max_buffered_requests = 0;
CORBA::ULong max_request_buffer_size = 0;
RTCORBA::ThreadpoolId threadpool_id_1 =
rt_orb->create_threadpool (stacksize,
static_threads,
dynamic_threads,
default_thread_priority,
allow_request_buffering,
max_buffered_requests,
max_request_buffer_size);
CORBA::Policy_var threadpool_policy_1 =
rt_orb->create_threadpool_policy (threadpool_id_1);
CORBA::Boolean allow_borrowing = false;
RTCORBA::ThreadpoolLanes lanes (1);
lanes.length (1);
lanes[0].lane_priority = default_thread_priority;
lanes[0].static_threads = static_threads;
lanes[0].dynamic_threads = dynamic_threads;
RTCORBA::ThreadpoolId threadpool_id_2 =
rt_orb->create_threadpool_with_lanes (stacksize,
lanes,
allow_borrowing,
allow_request_buffering,
max_buffered_requests,
max_request_buffer_size);
CORBA::Policy_var threadpool_policy_2 =
rt_orb->create_threadpool_policy (threadpool_id_2);
result =
create_POA_and_register_servant (threadpool_policy_1.in (),
"first_poa",
poa_manager.in (),
root_poa.in (),
this->orb_.in (),
rt_orb.in ());
if (result != 0)
return result;
result =
create_POA_and_register_servant (threadpool_policy_2.in (),
"second_poa",
poa_manager.in (),
root_poa.in (),
this->orb_.in (),
rt_orb.in ());
if (result != 0)
return result;
this->orb_->run ();
this->orb_->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return -1;
}
return 0;
}
// Implementation skeleton constructor
StockDistributorHome_i::StockDistributorHome_i (CORBA::ORB_ptr orb)
: orb_ (CORBA::ORB::_duplicate (orb)),
rt_poa_ (RTPortableServer::POA::_nil ()),
dist_id_ (0)
{
// Register this class as a signal handler to catch keyboard interrupts.
if (orb_->orb_core ()->reactor ()->register_handler (SIGINT, this) == -1)
ACE_DEBUG ((LM_DEBUG, "ERROR: Failed to register as a signal handler: %p\n",
"register_handler\n"));
// Register the necessary factories and mappings with the specified
// <orb>. If we neglect to perform these registrations then the app
// will not execute.
Stock::StockNames_init *stockname_factory = new Stock::StockNames_init;
orb_->register_value_factory (stockname_factory->tao_repository_id (),
stockname_factory);
Stock::Cookie_init *cookie_factory = new Stock::Cookie_init;
this->orb_->register_value_factory (cookie_factory->tao_repository_id (),
cookie_factory);
Stock::Priority_Mapping::register_mapping (orb_.in ());
// Get a reference to the <RTORB>.
CORBA::Object_var obj = orb_->resolve_initial_references ("RTORB");
RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (obj.in ());
TAO::Utils::PolicyList_Destroyer policies (2);
policies.length (2);
// Create a <SERVER_DECLARED> priority model policy.
policies[0] =
rt_orb->create_priority_model_policy (RTCORBA::SERVER_DECLARED,
Stock::Priority_Mapping::VERY_LOW);
// Create a threadpool with lanes for the distributor. Since the brokers
// will have various priorities, create a lane for each priority.
RTCORBA::ThreadpoolLanes lanes (5); lanes.length (5);
for (CORBA::ULong i = 0; i < lanes.length (); ++i)
{
lanes[i].lane_priority = static_cast<RTCORBA::Priority> (i);
lanes[i].static_threads = 5;
lanes[i].dynamic_threads = 0;
}
RTCORBA::ThreadpoolId threadpool_id =
rt_orb->create_threadpool_with_lanes (1024*1024,
lanes,
false, false, 0, 0);
policies[1] = rt_orb->create_threadpool_policy (threadpool_id);
PortableServer::POA_var poa = this->_default_POA ();
PortableServer::POAManager_var poa_mgr = poa->the_POAManager ();
// Create a child POA with <SERVER_DECLARED> policies. The name of
// the POA will be <StockDistributor_POA>. Any instances of the
// StockDistributor_i created via the create() method will be
// activated under this POA.
PortableServer::POA_var child_poa =
poa->create_POA ("StockDistributor_POA",
poa_mgr.in (),
policies);
// Narrow the POA to a RT POA, and cache the reference
this->rt_poa_ = RTPortableServer::POA::_narrow (child_poa.in ());
// Create the initial distributor reference
this->create_distributor ();
}