void
Consumer::connect (RtecEventChannelAdmin::ConsumerAdmin_ptr consumer_admin)
{
this->proxy_ =
consumer_admin->obtain_push_supplier ();
RtecEventComm::PushConsumer_var me =
this->_this ();
// Simple subscription, but usually the helper classes in
// $TAO_ROOT/orbsvcs/Event_Utils.h are a better way to do this.
RtecEventChannelAdmin::ConsumerQOS qos;
qos.is_gateway = 0;
qos.dependencies.length (2);
RtecEventComm::EventHeader& h0 =
qos.dependencies[0].event.header;
h0.type = ACE_ES_DISJUNCTION_DESIGNATOR;
h0.source = 1; // The disjunction has one element
RtecEventComm::EventHeader& h1 =
qos.dependencies[1].event.header;
h1.type = ACE_ES_EVENT_UNDEFINED; // first free event type
h1.source = ACE_ES_EVENT_SOURCE_ANY; // Any source is OK
this->proxy_->connect_push_consumer (me.in (), qos);
}
void
Consumer::connect (RtecEventChannelAdmin::EventChannel_ptr ec)
{
RtecEventChannelAdmin::ConsumerAdmin_var consumer_admin =
ec->for_consumers ();
{
ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, this->mutex_);
if (!CORBA::is_nil (this->proxy_supplier_.in ()))
return;
this->proxy_supplier_ =
consumer_admin->obtain_push_supplier ();
}
RtecEventComm::PushConsumer_var consumer =
this->_this ();
RtecEventChannelAdmin::ConsumerQOS consumer_qos;
consumer_qos.is_gateway = 0;
consumer_qos.dependencies.length (2);
RtecEventComm::EventHeader& h0 =
consumer_qos.dependencies[0].event.header;
h0.type = ACE_ES_DISJUNCTION_DESIGNATOR;
h0.source = 1;
RtecEventComm::EventHeader& h1 =
consumer_qos.dependencies[1].event.header;
h1.type = this->event_type_;
h1.source = this->experiment_id_;
this->proxy_supplier_->connect_push_consumer (consumer.in (),
consumer_qos);
}
void
EC_Counting_Supplier::activate (RtecEventChannelAdmin::ConsumerAdmin_ptr consumer_admin,
int milliseconds)
{
RtecEventComm::PushConsumer_var consumer =
this->consumer_adapter_._this ();
this->supplier_proxy_ =
consumer_admin->obtain_push_supplier ();
// Let's say that the execution time for event 2 is 1
// milliseconds...
ACE_Time_Value tv (0, milliseconds * 1000);
TimeBase::TimeT time;
ORBSVCS_Time::Time_Value_to_TimeT (time, tv);
ACE_ConsumerQOS_Factory consumer_qos;
consumer_qos.start_disjunction_group (1);
consumer_qos.insert_time (ACE_ES_EVENT_INTERVAL_TIMEOUT,
time,
0);
this->supplier_proxy_->connect_push_consumer (consumer.in (),
consumer_qos.get_ConsumerQOS ());
}
void
TAO_EC_ProxyPushSupplier::shutdown (void)
{
// Save the consumer we where connected to, we need to send a
// disconnect message to it.
RtecEventComm::PushConsumer_var consumer;
{
ACE_GUARD_THROW_EX (
ACE_Lock, ace_mon, *this->lock_,
RtecEventChannelAdmin::EventChannel::SYNCHRONIZATION_ERROR ());
bool const connected = this->is_connected_i ();
consumer = this->consumer_._retn ();
if (connected)
this->cleanup_i ();
}
this->deactivate ();
if (CORBA::is_nil (consumer.in ()))
return;
try
{
consumer->disconnect_push_consumer ();
}
catch (const CORBA::Exception&)
{
// Ignore exceptions, we must isolate other clients from
// problems on this one.
}
}
void
TAO_Rtec_LogConsumer::connect (RtecEventChannelAdmin::ConsumerAdmin_ptr consumer_admin)
{
RtecEventComm::PushConsumer_var myself = this->_this ();
this->supplier_proxy_ = consumer_admin->obtain_push_supplier ();
ACE_ConsumerQOS_Factory qos;
qos.start_disjunction_group (1);
qos.insert_type (ACE_ES_EVENT_ANY,
0);
this->supplier_proxy_->connect_push_consumer (myself.in(), qos.get_ConsumerQOS ());
}
void
EC_Counting_Consumer::connect (RtecEventChannelAdmin::ConsumerAdmin_ptr consumer_admin,
const RtecEventChannelAdmin::ConsumerQOS &qos)
{
// The canonical protocol to connect to the EC
RtecEventComm::PushConsumer_var consumer =
this->_this ();
if (CORBA::is_nil (this->supplier_proxy_.in ()))
{
this->supplier_proxy_ =
consumer_admin->obtain_push_supplier ();
}
this->supplier_proxy_->connect_push_consumer (consumer.in (),
qos);
}
void
TAO_EC_ProxyPushSupplier::push (const RtecEventComm::EventSet& event,
TAO_EC_QOS_Info& qos_info)
{
// The mutex is already held by the caller (usually the filter()
// method)
if (!this->is_connected_i ())
return; // TAO_THROW (RtecEventComm::Disconnected ());????
if (this->suspended_)
return;
TAO_ESF_RefCount_Guard<CORBA::ULong> ace_mon (this->refcount_);
// The guard will decrement the reference count, notice that the
// reference count can become 0, but this is not the right spot to
// check for that and destroy the object.
// If we did so then we would destroy the object, and consequently
// the mutex, but the mutex is used later when the stack unwinds and
// the filter() method tries to destroy the mutex (that originally
// acquired the mutex in the first place).
// So the correct thing to do is to just decrement the reference
// count and let the filter() method do the destruction.
RtecEventComm::PushConsumer_var consumer =
RtecEventComm::PushConsumer::_duplicate (this->consumer_.in ());
this->pre_dispatch_hook (const_cast<RtecEventComm::EventSet&> (event));
{
// We have to release the lock to avoid dead-locks.
TAO_EC_Unlock reverse_lock (*this->lock_);
ACE_GUARD_THROW_EX (TAO_EC_Unlock, ace_mon, reverse_lock,
RtecEventChannelAdmin::EventChannel::SYNCHRONIZATION_ERROR ());
this->event_channel_->dispatching ()->push (this,
consumer.in (),
event,
qos_info);
}
if (this->child_ != 0)
this->child_->clear ();
}
void
Test_Consumer::connect (RtecScheduler::Scheduler_ptr scheduler,
const char* name,
int type_start,
int type_count,
RtecEventChannelAdmin::EventChannel_ptr ec)
{
RtecScheduler::handle_t rt_info =
scheduler->create (name);
// The worst case execution time is far less than 2
// milliseconds, but that is a safe estimate....
ACE_Time_Value tv (0, 2000);
TimeBase::TimeT time;
ORBSVCS_Time::Time_Value_to_TimeT (time, tv);
scheduler->set (rt_info,
RtecScheduler::VERY_HIGH_CRITICALITY,
time, time, time,
0,
RtecScheduler::VERY_LOW_IMPORTANCE,
time,
0,
RtecScheduler::OPERATION);
ACE_ConsumerQOS_Factory qos;
qos.start_disjunction_group ();
qos.insert_type (ACE_ES_EVENT_SHUTDOWN, rt_info);
for (int i = 0; i != type_count; ++i)
{
qos.insert_type (type_start + i, rt_info);
}
// = Connect as a consumer.
RtecEventChannelAdmin::ConsumerAdmin_var consumer_admin =
ec->for_consumers ();
this->supplier_proxy_ =
consumer_admin->obtain_push_supplier ();
RtecEventComm::PushConsumer_var objref = this->_this ();
this->supplier_proxy_->connect_push_consumer (objref.in (),
qos.get_ConsumerQOS ());
}
int
Consumer::run (int argc, ACE_TCHAR* argv[])
{
try
{
// ORB initialization boiler plate...
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
// Do *NOT* make a copy because we don't want the ORB to outlive
// the run() method.
this->orb_ = orb.in ();
CORBA::Object_var object =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa =
PortableServer::POA::_narrow (object.in ());
PortableServer::POAManager_var poa_manager =
poa->the_POAManager ();
poa_manager->activate ();
// Obtain the event channel from the naming service
CORBA::Object_var naming_obj =
orb->resolve_initial_references ("NameService");
if (CORBA::is_nil (naming_obj.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to get the Naming Service.\n"),
1);
CosNaming::NamingContext_var naming_context =
CosNaming::NamingContext::_narrow (naming_obj.in ());
CosNaming::Name name (1);
name.length (1);
name[0].id = CORBA::string_dup ("EventService");
CORBA::Object_var ec_obj =
naming_context->resolve (name);
RtecEventChannelAdmin::EventChannel_var event_channel =
RtecEventChannelAdmin::EventChannel::_narrow (ec_obj.in ());
// The canonical protocol to connect to the EC
RtecEventChannelAdmin::ConsumerAdmin_var consumer_admin =
event_channel->for_consumers ();
RtecEventChannelAdmin::ProxyPushSupplier_var supplier =
consumer_admin->obtain_push_supplier ();
RtecEventComm::PushConsumer_var consumer =
this->_this ();
// Simple subscription, but usually the helper classes in
// $TAO_ROOT/orbsvcs/Event_Utils.h are a better way to do this.
RtecEventChannelAdmin::ConsumerQOS qos;
qos.dependencies.length (2);
RtecEventComm::EventHeader& h0 =
qos.dependencies[0].event.header;
h0.type = ACE_ES_DISJUNCTION_DESIGNATOR;
h0.source = ACE_ES_EVENT_SOURCE_ANY;
RtecEventComm::EventHeader& h1 =
qos.dependencies[1].event.header;
h1.type = ACE_ES_EVENT_UNDEFINED; // first free event type
h1.source = ACE_ES_EVENT_SOURCE_ANY;
supplier->connect_push_consumer (consumer.in (), qos);
// Wait for events, using work_pending()/perform_work() may help
// or using another thread, this example is too simple for that.
orb->run ();
// We don't do any cleanup, it is hard to do it after shutdown,
// and would complicate the example; plus it is almost
// impossible to do cleanup after ORB->run() because the POA is
// in the holding state. Applications should use
// work_pending()/perform_work() to do more interesting stuff.
// Check the supplier for the proper way to do cleanup.
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Consumer::run");
return 1;
}
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
// Initialize the ORB.
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
const ACE_TCHAR *ecname = ACE_TEXT ("EventService");
for (int i = 0; argv[i] != 0; i++) {
if (ACE_OS::strcmp(argv[i], ACE_TEXT("-ecname")) == 0) {
if (argv[i+1] != 0) {
ecname = argv[i+1];
} else {
std::cerr << "Missing Event channel name" << std::endl;
}
}
}
// Find the Naming Service.
CORBA::Object_var obj = orb->resolve_initial_references("NameService");
CosNaming::NamingContextExt_var root_context
= CosNaming::NamingContextExt::_narrow(obj.in());
// Find the EchoEventChannel.
obj = root_context->resolve_str (ACE_TEXT_ALWAYS_CHAR (ecname));
// Downcast the object reference to an EventChannel reference.
RtecEventChannelAdmin::EventChannel_var ec =
RtecEventChannelAdmin::EventChannel::_narrow(obj.in());
if (CORBA::is_nil(ec.in())) {
std::cerr << "Could not narrow EchoEventChannel." << std::endl;
return 1;
}
std::cout << "EchoEventConsumerMain.cpp: Found the EchoEventChannel." << std::endl;
// Obtain a reference to the consumer administration object.
RtecEventChannelAdmin::ConsumerAdmin_var admin = ec->for_consumers();
// Obtain a reference to the push supplier proxy.
RtecEventChannelAdmin::ProxyPushSupplier_var supplier =
admin->obtain_push_supplier();
// Get the RootPOA.
obj = orb->resolve_initial_references("RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow(obj.in());
// Instantiate an EchoEventConsumer_i servant and register it
// with the RootPOA
PortableServer::Servant_var<EchoEventConsumer_i> servant =
new EchoEventConsumer_i(orb.in(), supplier.in(), EVENT_LIMIT);
PortableServer::ObjectId_var oid = poa->activate_object(servant.in());
CORBA::Object_var consumer_obj = poa->id_to_reference(oid.in());
RtecEventComm::PushConsumer_var consumer =
RtecEventComm::PushConsumer::_narrow(consumer_obj.in());
// Connect as a consumer.
ACE_ConsumerQOS_Factory qos;
qos.start_disjunction_group ();
qos.insert (MY_SOURCE_ID, // Source ID
MY_EVENT_TYPE, // Event Type
0); // handle to the rt_info
supplier->connect_push_consumer (consumer.in (),
qos.get_ConsumerQOS ());
// Activate the POA via its POAManager.
PortableServer::POAManager_var poa_manager = poa->the_POAManager();
poa_manager->activate();
std::cout << "EchoEventConsumerMain.cpp: Ready to receive events..." << std::endl;
// Enter the ORB event loop.
orb->run();
// If we have reached this, we must be shutting down...
// Disconnect the ProxyPushSupplier.
orb->destroy();
std::cout << "Test completed." << std::endl;
return 0;
}
catch(const CORBA::Exception& exc)
{
std::cerr << "Caught CORBA::Exception" << std::endl << exc << std::endl;
}
return 1;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
TAO_EC_Default_Factory::init_svcs ();
try
{
// ORB initialization boiler plate...
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) == -1)
{
ACE_ERROR ((LM_ERROR,
"Usage: Service [-o IOR_file_name]\n"));
return 1;
}
CORBA::Object_var object =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa =
PortableServer::POA::_narrow (object.in ());
PortableServer::POAManager_var poa_manager =
poa->the_POAManager ();
poa_manager->activate ();
// ****************************************************************
#if 0
// Obtain a reference to the naming service...
CORBA::Object_var naming_obj =
orb->resolve_initial_references ("NameService");
CosNaming::NamingContext_var naming_context =
CosNaming::NamingContext::_narrow (naming_obj.in ());
#endif /* 0 */
// ****************************************************************
// Create an scheduling service
POA_RtecScheduler::Scheduler* sched_impl = 0;
if (config_run)
{
ACE_NEW_RETURN (sched_impl,
RECONFIG_SCHED_TYPE,
1);
}
else
{
ACE_NEW_RETURN (sched_impl,
RECONFIG_SCHED_TYPE (configs_size,
configs,
infos_size,
infos,
0, 0,
0),
1);
}
RtecScheduler::Scheduler_var scheduler =
sched_impl->_this ();
#if 0
// Bind the scheduler with the naming service so clients
// (consumers and suppliers) can resolve it, some (old)
// implementations of the EC will try to do the same thing
// (yikes!)
CosNaming::Name schedule_name (1);
schedule_name.length (1);
schedule_name[0].id = CORBA::string_dup ("ScheduleService");
// Register the servant with the Naming Context....
naming_context->rebind (schedule_name, scheduler.in ());
#endif /* 0 */
// ****************************************************************
TAO_EC_Event_Channel_Attributes attributes (poa.in (),
poa.in ());
attributes.scheduler = scheduler.in (); // no need to dup
TAO_EC_Event_Channel ec_impl (attributes);
ACE_DEBUG ((LM_DEBUG, "activating EC\n"));
ec_impl.activate ();
ACE_DEBUG ((LM_DEBUG, "EC activated\n"));
RtecEventChannelAdmin::EventChannel_var event_channel =
ec_impl._this ();
// ****************************************************************
// Create a consumer, intialize its RT_Info structures, and
// connnect to the event channel....
Consumer consumer_impl;
RtecScheduler::handle_t consumer_rt_info1 =
scheduler->create ("consumer_event_1");
// Let's say that the execution time for event 1 is 2
// milliseconds...
ACE_Time_Value tv (0, 2000);
TimeBase::TimeT time;
ORBSVCS_Time::Time_Value_to_TimeT (time, tv);
scheduler->set (consumer_rt_info1,
RtecScheduler::VERY_HIGH_CRITICALITY,
time, time, time,
0,
RtecScheduler::VERY_LOW_IMPORTANCE,
time,
0,
RtecScheduler::OPERATION);
RtecScheduler::handle_t consumer_rt_info2 =
scheduler->create ("consumer_event_2");
// Let's say that the execution time for event 2 is 1
// milliseconds...
tv.set (0, 1000);
ORBSVCS_Time::Time_Value_to_TimeT (time, tv);
scheduler->set (consumer_rt_info2,
RtecScheduler::VERY_LOW_CRITICALITY,
time, time, time,
0,
RtecScheduler::VERY_LOW_IMPORTANCE,
time,
0,
RtecScheduler::OPERATION);
ACE_ConsumerQOS_Factory consumer_qos;
consumer_qos.start_disjunction_group ();
// The types int the range [0,ACE_ES_EVENT_UNDEFINED) are
// reserved for the EC...
consumer_qos.insert_type (ACE_ES_EVENT_UNDEFINED,
consumer_rt_info1);
consumer_qos.insert_type (ACE_ES_EVENT_UNDEFINED + 1,
consumer_rt_info2);
// The canonical protocol to connect to the EC
RtecEventChannelAdmin::ConsumerAdmin_var consumer_admin =
event_channel->for_consumers ();
RtecEventChannelAdmin::ProxyPushSupplier_var supplier_proxy =
consumer_admin->obtain_push_supplier ();
RtecEventComm::PushConsumer_var consumer =
consumer_impl._this ();
ACE_DEBUG ((LM_DEBUG, "connecting consumer\n"));
supplier_proxy->connect_push_consumer (consumer.in (),
consumer_qos.get_ConsumerQOS ());
ACE_DEBUG ((LM_DEBUG, "consumer connected\n"));
// ****************************************************************
Supplier supplier_impl;
RtecScheduler::handle_t supplier_rt_info1 =
scheduler->create ("supplier_event_1");
// The execution times are set to reasonable values, but
// actually they are changed on the real execution, i.e. we
// lie to the scheduler to obtain right priorities; but we
// don't care if the set is schedulable.
tv.set (0, 10000);
TimeBase::TimeT tmp;
ORBSVCS_Time::Time_Value_to_TimeT (tmp, tv);
RtecScheduler::Period_t rate = ACE_U64_TO_U32(tmp);
scheduler->set (supplier_rt_info1,
RtecScheduler::VERY_HIGH_CRITICALITY,
0, 0, 0,
rate,
RtecScheduler::VERY_LOW_IMPORTANCE,
0,
1,
RtecScheduler::OPERATION);
RtecScheduler::handle_t supplier_rt_info2 =
scheduler->create ("supplier_event_2");
// The execution times are set to reasonable values, but
// actually they are changed on the real execution, i.e. we
// lie to the scheduler to obtain right priorities; but we
// don't care if the set is schedulable.
tv.set (0, 20000);
ORBSVCS_Time::Time_Value_to_TimeT (tmp, tv);
rate = ACE_U64_TO_U32(tmp);
scheduler->set (supplier_rt_info2,
RtecScheduler::VERY_HIGH_CRITICALITY,
0, 0, 0,
rate,
RtecScheduler::VERY_LOW_IMPORTANCE,
0,
1,
RtecScheduler::OPERATION);
RtecEventComm::EventSourceID supplier_id = 1;
ACE_SupplierQOS_Factory supplier_qos;
supplier_qos.insert (supplier_id,
ACE_ES_EVENT_UNDEFINED,
supplier_rt_info1,
1 /* number of calls, but what does that mean? */);
supplier_qos.insert (supplier_id,
ACE_ES_EVENT_UNDEFINED + 1,
supplier_rt_info2,
1 /* number of calls, but what does that mean? */);
// The canonical protocol to connect to the EC
RtecEventChannelAdmin::SupplierAdmin_var supplier_admin =
event_channel->for_suppliers ();
RtecEventChannelAdmin::ProxyPushConsumer_var consumer_proxy =
supplier_admin->obtain_push_consumer ();
RtecEventComm::PushSupplier_var supplier =
supplier_impl._this ();
ACE_DEBUG ((LM_DEBUG, "connecting supplier\n"));
consumer_proxy->connect_push_supplier (supplier.in (),
supplier_qos.get_SupplierQOS ());
ACE_DEBUG ((LM_DEBUG, "supplier connected\n"));
// ****************************************************************
// At this point the consumer and supplier are connected to the
// EC, they have provided their QoS info to the Scheduling
// Service and the EC has informed the Scheduler about the
// dependencies between them.
// We can now compute the schedule for this configuration...
// The schedule is returned in this variables....
if (config_run)
{
ACE_DEBUG ((LM_DEBUG, "Computing schedule\n"));
RtecScheduler::RT_Info_Set_var infos;
RtecScheduler::Dependency_Set_var deps;
RtecScheduler::Config_Info_Set_var configs;
RtecScheduler::Scheduling_Anomaly_Set_var anomalies;
// Obtain the range of valid priorities in the current
// platform, the scheduler hard-code this values in the
// generated file, but in the future we may just use the
// "logical" priorities and define the mapping to OS
// priorities at run-time.
int min_os_priority =
ACE_Sched_Params::priority_min (ACE_SCHED_FIFO,
ACE_SCOPE_THREAD);
int max_os_priority =
ACE_Sched_Params::priority_max (ACE_SCHED_FIFO,
ACE_SCOPE_THREAD);
scheduler->compute_scheduling (min_os_priority,
max_os_priority,
infos.out (),
deps.out (),
configs.out (),
anomalies.out ());
// Dump the schedule to a file..
ACE_Scheduler_Factory::dump_schedule (infos.in (),
deps.in (),
configs.in (),
anomalies.in (),
ACE_TEXT("schedule.out"));
}
// ****************************************************************
ACE_DEBUG ((LM_DEBUG, "Pushing events\n"));
// Generate a few events....
RtecEventComm::EventSet event1 (1);
event1.length (1);
event1[0].header.type = ACE_ES_EVENT_UNDEFINED;
event1[0].header.source = supplier_id;
event1[0].header.ttl = 1;
RtecEventComm::EventSet event2 (1);
event2.length (1);
event2[0].header.type = ACE_ES_EVENT_UNDEFINED + 1;
event2[0].header.source = supplier_id;
event2[0].header.ttl = 1;
for (int i = 0; i != 200; ++i)
{
if (i % 2 == 0)
{
consumer_proxy->push (event1);
}
else
{
consumer_proxy->push (event2);
}
ACE_Time_Value rate (0, 10000);
ACE_OS::sleep (rate);
}
// ****************************************************************
// We should do a lot of cleanup (disconnect from the EC,
// deactivate all the objects with the POA, etc.) but this is
// just a simple demo so we are going to be lazy.
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Service");
return 1;
}
return 0;
}
int
Consumer::run (int argc, ACE_TCHAR* argv[])
{
try
{
// First parse our command line options
if (this->parse_args(argc, argv) != 0)
{
return -1;
}
// ORB initialization boiler plate...
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
// Do *NOT* make a copy because we don't want the ORB to outlive
// the run() method.
this->orb_ = orb.in ();
CORBA::Object_var object =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa =
PortableServer::POA::_narrow (object.in ());
PortableServer::POAManager_var poa_manager =
poa->the_POAManager ();
poa_manager->activate ();
// Obtain the event channel from the naming service
CORBA::Object_var naming_obj =
orb->resolve_initial_references ("NameService");
if (CORBA::is_nil (naming_obj.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to get the Naming Service.\n"),
1);
CosNaming::NamingContext_var naming_context =
CosNaming::NamingContext::_narrow (naming_obj.in ());
CosNaming::Name name (1);
name.length (1);
name[0].id = CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR(ecname));
CORBA::Object_var ec_obj =
naming_context->resolve (name);
RtecEventChannelAdmin::EventChannel_var event_channel =
RtecEventChannelAdmin::EventChannel::_narrow (ec_obj.in ());
if (CORBA::is_nil (event_channel.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to get Event Channel.\n"),
1);
// The canonical protocol to connect to the EC
RtecEventChannelAdmin::ConsumerAdmin_var consumer_admin =
event_channel->for_consumers ();
RtecEventChannelAdmin::ProxyPushSupplier_var supplier =
consumer_admin->obtain_push_supplier ();
RtecEventComm::PushConsumer_var consumer =
this->_this ();
ACE_ConsumerQOS_Factory qos;
qos.start_disjunction_group ();
qos.insert (MY_SOURCE_ID, // Source ID
MY_EVENT_TYPE, // Event Type
0); // handle to the rt_info
for (int i = 0; i < 10; i++)
{
qos.insert (MY_SOURCE_ID + i, // Source ID
MY_EVENT_TYPE + i, // Event Type
0); // handle to the rt_info
}
supplier->connect_push_consumer (consumer.in (), qos);
// Wait for events, using work_pending()/perform_work() may help
// or using another thread, this example is too simple for that.
orb->run ();
// We don't do any cleanup, it is hard to do it after shutdown,
// and would complicate the example; plus it is almost
// impossible to do cleanup after ORB->run() because the POA is
// in the holding state. Applications should use
// work_pending()/perform_work() to do more interesting stuff.
// Check the supplier for the proper way to do cleanup.
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Consumer::run");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
// Initialize ORB and POA, POA Manager, parse args.
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) == -1)
return 1;
CORBA::Object_var obj =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa =
PortableServer::POA::_narrow (obj.in ());
if (check_for_nil (poa.in (), "POA") == -1)
return 1;
PortableServer::POAManager_var manager =
poa->the_POAManager ();
// Obtain reference to EC.
obj = orb->resolve_initial_references ("Event_Service");
RtecEventChannelAdmin::EventChannel_var ec =
RtecEventChannelAdmin::EventChannel::_narrow (obj.in ());
if (check_for_nil (ec.in (), "EC") == -1)
return 1;
// Create the consumer and register it with POA.
PortableServer::Servant_var<EC_Consumer> consumer_impl =
new EC_Consumer (orb, ec);
if (!consumer_impl.in ())
return -1;
RtecEventComm::PushConsumer_var consumer;
TAO_EC_Object_Deactivator consumer_deactivator;
activate (consumer,
poa.in (),
consumer_impl.in (),
consumer_deactivator);
consumer_deactivator.disallow_deactivation ();
// Obtain reference to ConsumerAdmin.
RtecEventChannelAdmin::ConsumerAdmin_var consumer_admin =
ec->for_consumers ();
// Obtain ProxyPushSupplier and connect this consumer.
RtecEventChannelAdmin::ProxyPushSupplier_var supplier =
consumer_admin->obtain_push_supplier ();
ACE_ConsumerQOS_Factory qos;
qos.start_disjunction_group (3);
qos.insert_type (A_EVENT_TYPE, 0);
qos.insert_type (B_EVENT_TYPE, 0);
qos.insert_type (C_EVENT_TYPE, 0);
supplier->connect_push_consumer (consumer.in (),
qos.get_ConsumerQOS ());
// Allow processing of CORBA requests.
manager->activate ();
// Receive events from EC.
orb->run ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception in Consumer:");
return 1;
}
return 0;
}
int
Consumer::run (int argc, ACE_TCHAR* argv[])
{
try
{
// ORB initialization boiler plate...
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
// Do *NOT* make a copy because we don't want the ORB to outlive
// the run() method.
this->orb_ = orb.in ();
/*
if (argc <= 1)
{
ACE_ERROR ((LM_ERROR,
"Usage: Consumer <event_channel_ior>\n"));
return 1;
}
*/
CORBA::Object_var object =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa =
PortableServer::POA::_narrow (object.in ());
PortableServer::POAManager_var poa_manager =
poa->the_POAManager ();
poa_manager->activate ();
// Obtain the event channel, we could use a naming service, a
// command line argument or resolve_initial_references(), but
// this is simpler...
/* object =
orb->string_to_object (argv[1]);
RtecEventChannelAdmin::EventChannel_var event_channel =
RtecEventChannelAdmin::EventChannel::_narrow (object.in ());
*/
// Obtain the event channel
CORBA::Object_var naming_obj =
this->orb_->resolve_initial_references (NAMING_SERVICE_NAME);
// Need to check return value for errors.
if (CORBA::is_nil (naming_obj.in ()))
throw CORBA::UNKNOWN ();
this->naming_context_ =
CosNaming::NamingContext::_narrow (naming_obj.in ());
CosNaming::Name name (1);
name.length (1);
name[0].id = CORBA::string_dup (EVENT_TLS_LOG_FACTORY_NAME);
CORBA::Object_var obj =
this->naming_context_->resolve (name);
this->event_log_factory_ =
RTEventLogAdmin::EventLogFactory::_narrow (obj.in ());
// The canonical protocol to connect to the EC
this->supplier_ =
this->event_log_factory_->obtain_push_supplier ();
RtecEventComm::PushConsumer_var consumer =
this->_this ();
// Simple subscription, but usually the helper classes in
// $TAO_ROOT/orbsvcs/Event_Utils.h are a better way to do this.
RtecEventChannelAdmin::ConsumerQOS qos;
qos.dependencies.length (2);
RtecEventComm::EventHeader& h0 =
qos.dependencies[0].event.header;
h0.type = ACE_ES_DISJUNCTION_DESIGNATOR;
h0.source = ACE_ES_EVENT_SOURCE_ANY;
RtecEventComm::EventHeader& h1 =
qos.dependencies[1].event.header;
h1.type = ACE_ES_EVENT_UNDEFINED; // first free event type
h1.source = ACE_ES_EVENT_SOURCE_ANY;
this->supplier_->connect_push_consumer (consumer.in (), qos);
// Wait for events, using work_pending()/perform_work() may help
// or using another thread, this example is too simple for that.
orb->run ();
// We don't do any cleanup, it is hard to do it after shutdown,
// and would complicate the example; plus it is almost
// impossible to do cleanup after ORB->run() because the POA is
// in the holding state. Applications should use
// work_pending()/perform_work() to do more interesting stuff.
// Check the supplier for the proper way to do cleanup.
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Consumer::run");
return 1;
}
return 0;
}