void
Supplier::perform_push (void)
{
try
{
// The event type and source must match our publications
++event_count_;
ACE_DEBUG ((LM_DEBUG, "Sending event %d\n", event_count_));
RtecEventComm::EventSet event (1);
event.length (1);
event[0].header.type = ACE_ES_EVENT_UNDEFINED;
event[0].header.source = event_count_;
// Avoid loops throught the event channel federations
event[0].header.ttl = 1;
if (this->valuetype_)
{
OBV_Hello::ValueTypeData * test_data = 0;
ACE_NEW (test_data, OBV_Hello::ValueTypeData ());
test_data->data ("ACE/TAO/CIAO");
insert_into_any (event[0].data.any_value, test_data);
}
else
{
event[0].data.any_value <<= CORBA::string_dup( "ACE/TAO/CIAO");
}
this->proxy_->push (event);
}
catch (const CORBA::Exception&)
{
}
}
void
TAO_CosEC_ProxyPushConsumer_i::push (const CORBA::Any &data)
{
RtecEventComm::Event buffer[1];
// Create an event set that does not own the buffer....
RtecEventComm::EventSet events (1, 1, buffer, 0);
events.length (1);
RtecEventComm::Event &e = events[0];
RtecEventComm::Event eqos =
qos_.publications[0].event;
// @@ what if i initialize the entire <EventSet> with corresponding
// publications entries.
// NOTE: we initialize the <EventHeader> field using the 1st
// <publications> from the <SupplierQOS>.so we assume that
// publications[0] is initialized.
e.header.source = eqos.header.source;
e.header.ttl = eqos.header.ttl;
e.header.type = eqos.header.type;
ACE_hrtime_t t = ACE_OS::gethrtime ();
ORBSVCS_Time::hrtime_to_TimeT (e.header.creation_time,
t);
#if !defined(TAO_LACKS_EVENT_CHANNEL_TIMESTAMPS)
e.header.ec_recv_time = ORBSVCS_Time::zero ();
e.header.ec_send_time = ORBSVCS_Time::zero ();
#endif /* TAO_LACKS_EVENT_CHANNEL_TIMESTAMPS */
e.data.any_value = data;
this->proxypushconsumer_->push (events);
}
int PushSupplier_impl::handle_timeout (const ACE_Time_Value ¤t_time,
const void *act)
{
ACE_UNUSED_ARG(act);
ACE_UNUSED_ARG(current_time);
try {
RtecEventComm::EventSet event (1);
event.length (1);
event[0].header.type = ACE_ES_EVENT_UNDEFINED;
event[0].header.source = 1;
event[0].header.ttl = 1;
ACE_Time_Value time_val = ACE_OS::gettimeofday ();
event[0].header.ec_send_time = time_val.sec () * 10000000 + time_val.usec ()* 10;
event[0].data.any_value <<= seq_no_;
consumer_->push(event);
ACE_DEBUG((LM_DEBUG, "sending data %d\n", seq_no_));
++seq_no_;
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("A CORBA Exception occurred.");
}
return 0;
}
int
TAO_EC_Type_Filter::filter_set (const RtecEventComm::EventSet& event,
TAO_EC_QOS_Info& qos_info)
{
CORBA::ULong maximum = event.length ();
if (event.maximum () == 0)
return 0;
RtecEventComm::EventSet matched (maximum);
CORBA::ULong next_slot = 0;
for (CORBA::ULong i = 0; i != maximum; ++i)
{
if (!this->can_match (event[i].header))
continue;
matched.length (next_slot + 1);
matched[next_slot] = event[i];
next_slot++;
}
if (matched.length () == 0)
return 0;
this->push (matched, qos_info);
return 1;
}
void
Loopback_Supplier::push (const RtecEventComm::EventSet &source)
{
// ACE_DEBUG ((LM_DEBUG, "Loopback_Supplier pushing\n"));
RtecEventChannelAdmin::ProxyPushConsumer_var proxy;
{
ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, this->mutex_);
if (CORBA::is_nil (this->proxy_consumer_.in ()))
return;
proxy = this->proxy_consumer_;
#if 0
this->counter_ += source.length ();
if ((this->counter_ + 1) % 1000 == 0)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) - Loopback (%d) sending %d messages\n",
this->response_type_, this->counter_ + 1));
}
#endif /* 0 */
}
// ACE_DEBUG ((LM_DEBUG, "Loopback_Supplier::push (%P|%t)\n"));
RtecEventComm::EventSet events (source);
for (CORBA::ULong i = 0; i != events.length (); ++i)
{
events[i].header.ttl = 1;
events[i].header.type = this->response_type_;
events[i].header.source = this->experiment_id_;
}
proxy->push (events);
}
void
EC_Counting_Supplier::push (const RtecEventComm::EventSet&)
{
if (CORBA::is_nil (this->consumer_proxy_.in ()))
return;
RtecEventComm::EventSet event (1);
event.length (1);
event[0].header.source = this->event_source_;
event[0].header.type = this->event_type_;
event[0].header.ttl = 1;
this->consumer_proxy_->push (event);
this->event_count++;
}
void
EC_Supplier::send_event (const RtecEventComm::EventSet& event)
{
ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, this->lock_);
if (this->push_count_ == 0)
this->throughput_start_ = ACE_OS::gethrtime ();
this->push_count_ += event.length ();
if (TAO_debug_level > 0
&& this->push_count_ % 100 == 0)
{
ACE_DEBUG ((LM_DEBUG,
"EC_Consumer (%P|%t): %d events received\n",
this->push_count_));
}
ACE_hrtime_t start = ACE_OS::gethrtime ();
this->consumer_proxy_->push (event);
ACE_hrtime_t end = ACE_OS::gethrtime ();
this->throughput_.sample (end - this->throughput_start_,
end - start);
}
void
EC_Consumer::push (const RtecEventComm::EventSet &events)
{
for (CORBA::ULong i = 0; i < events.length (); ++i)
{
switch (events[i].header.type)
{
case A_EVENT_TYPE:
++this->a_events_;
ACE_DEBUG ((LM_DEBUG, " Received event A\n"));
break;
case B_EVENT_TYPE:
++this->b_events_;
ACE_DEBUG ((LM_DEBUG, " Received event B\n"));
break;
case C_EVENT_TYPE:
++this->c_events_;
ACE_DEBUG ((LM_DEBUG, " Received event C\n"));
break;
default:
ACE_DEBUG ((LM_DEBUG, " Received event of UNKNOWN event type\n"));
}
}
if (this->a_events_ >= 100
&& this->b_events_ >= 100
&& this->c_events_ >= 100)
this->disconnect ();
}
void
Consumer::push (const RtecEventComm::EventSet& events)
{
if (events.length () == 0)
{
ACE_DEBUG ((LM_DEBUG,
"Consumer (%P|%t) no events\n"));
return;
}
this->event_count_ += events.length ();
if (this->event_count_ % 10000 == 0)
{
ACE_DEBUG ((LM_DEBUG,
"Consumer (%P|%t): %d events received\n",
this->event_count_));
}
}
void
Supplier::perform_push (void)
{
try
{
// The event type and source must match our publications
RtecEventComm::EventSet event (1);
event.length (1);
event[0].header.type = ACE_ES_EVENT_UNDEFINED;
event[0].header.source = 1;
// Avoid loops throught the event channel federations
event[0].header.ttl = 1;
this->proxy_->push (event);
}
catch (const CORBA::Exception&)
{
}
}
void
EC_Consumer::push (const RtecEventComm::EventSet& events)
{
this->driver_->consumer_push (this->cookie_, events);
if (events.length () == 0)
{
ACE_DEBUG ((LM_DEBUG,
"EC_Consumer (%P|%t) no events\n"));
return;
}
ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, this->lock_);
if (this->push_count_ == 0)
this->throughput_start_ = ACE_OS::gethrtime ();
this->push_count_ += events.length ();
if (TAO_debug_level > 0
&& this->push_count_ % 100 == 0)
{
ACE_DEBUG ((LM_DEBUG,
"EC_Consumer (%P|%t): %d events received\n",
this->push_count_));
}
for (u_int i = 0; i < events.length (); ++i)
{
const RtecEventComm::Event& e = events[i];
ACE_hrtime_t creation;
ORBSVCS_Time::TimeT_to_hrtime (creation,
e.header.creation_time);
const ACE_hrtime_t now = ACE_OS::gethrtime ();
this->throughput_.sample (now - this->throughput_start_,
now - creation);
if (e.header.type == this->shutdown_event_type_)
this->driver_->consumer_shutdown (this->cookie_);
}
}
void
Supplier::timeout_occured (void)
{
RtecEventComm::EventSet event (1);
if (id_ == 1)
{
event.length (1);
event[0].header.type = ACE_ES_EVENT_UNDEFINED;
event[0].header.source = id_;
event[0].header.ttl = 1;
}
else
{
event.length (1);
event[0].header.type = ACE_ES_EVENT_UNDEFINED + 1;
event[0].header.source = id_;
event[0].header.ttl = 1;
}
consumer_proxy_->push (event);
}
int
TAO_EC_Bitmask_Filter::filter_nocopy (RtecEventComm::EventSet& event,
TAO_EC_QOS_Info& qos_info)
{
if (event.length () != 1)
return 0;
if ((event[0].header.type & this->type_mask_) == 0
|| (event[0].header.source & this->source_mask_) == 0)
return 0;
return this->child_->filter_nocopy (event, qos_info);
}
void
Timeout_Consumer::push (const RtecEventComm::EventSet& events)
{
if (events.length () == 0)
{
ACE_DEBUG ((LM_DEBUG,
"TimeoutConsumer (%t) no events\n"));
return;
}
ACE_DEBUG ((LM_DEBUG, "(%t) Timeout Event received\n"));
supplier_impl_->timeout_occured ();
}
int
Heartbeat_Application::handle_timeout (const ACE_Time_Value&,
const void*)
{
try
{
if (this->n_timeouts_++ < HEARTBEATS_TO_SEND)
{
RtecEventComm::EventSet events (1);
events.length (1);
// Events travelling through gateways must have a ttl count of at
// least 1!
events[0].header.ttl = 1;
events[0].header.type = HEARTBEAT;
events[0].header.source = SOURCE_ID;
// Store our hostname and process id in the data portion of
// the event.
events[0].data.payload.replace (MAXHOSTNAMELEN+11,
MAXHOSTNAMELEN+11,
(u_char *)this->hostname_and_pid_,
0);
this->consumer_->push (events);
}
else
// We already sent the required number of heartbeats. Time to
// shutdown this app.
{
this->shutdown ();
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception (
"Suppressed the following exception in ""Heartbeat_Application::handle_timeout:\n");
}
return 0;
}
int
TAO_EC_Type_Filter::filter_nocopy (RtecEventComm::EventSet& event,
TAO_EC_QOS_Info& qos_info)
{
if (event.length () != 1)
return this->filter_set (event, qos_info);
if (this->can_match (event[0].header))
{
this->push_nocopy (event, qos_info);
return 1;
}
return 0;
}
void
EC_Supplier::send_event (int event_number)
{
if (CORBA::is_nil (this->consumer_proxy_.in ()))
return;
// Create the event...
RtecEventComm::EventSet event (1);
event.length (1);
event[0].header.ttl = 1;
ACE_hrtime_t t = ACE_OS::gethrtime ();
ORBSVCS_Time::hrtime_to_TimeT (event[0].header.creation_time, t);
// We use replace to minimize the copies, this should result
// in just one memory allocation:
event[0].data.payload.length (this->payload_size_);
this->event_type (event_number, event[0]);
this->send_event (event);
}
void
TAO_EC_Null_Scheduling::schedule_event (const RtecEventComm::EventSet &event,
TAO_EC_ProxyPushConsumer *,
TAO_EC_Supplier_Filter *filter)
{
for (CORBA::ULong j = 0; j < event.length (); ++j)
{
const RtecEventComm::Event& e = event[j];
RtecEventComm::Event* buffer =
const_cast<RtecEventComm::Event*> (&e);
RtecEventComm::EventSet single_event (1, 1, buffer, 0);
TAO_EC_QOS_Info event_info;
filter->push_scheduled_event (single_event, event_info);
}
}
void
TAO_CosEC_PushConsumerWrapper::push (const RtecEventComm::EventSet& set)
{
for (CORBA::ULong i = 0;
i < set.length ();
++i)
{
try
{
this->consumer_->push (set[i].data.any_value);
}
catch (const CORBA::Exception&)
{
// Ignore the exception...
}
}
}
void
Heartbeat_Application::push (const RtecEventComm::EventSet &events)
{
for (CORBA::ULong i = 0; i < events.length (); ++i)
{
// Figure out heartbeat source.
const u_char * buffer = events[i].data.payload.get_buffer ();
pid_t pid = *((pid_t*) buffer);
char * host = (char*) buffer + sizeof (pid);
// Update heartbeat database.
int found = 0;
size_t size = this->heartbeats_.size ();
for (size_t j = 0; j < size; ++j)
{
if (this->heartbeats_[j].pid == pid
&& ACE_OS::strcmp (this->heartbeats_[j].hostname, host)
== 0)
{
this->heartbeats_[j].total++;
found = 1;
break;
}
}
// Make new entry in the database.
if (!found)
{
if (this->heartbeats_.size (size + 1)
== -1)
{
ACE_ERROR ((LM_ERROR,
"Unable to add new entry "
"to heartbeat database\n"));
break;
}
this->heartbeats_[size].pid = pid;
this->heartbeats_[size].total = 1;
ACE_OS::memcpy (this->heartbeats_[size].hostname,
host,
ACE_OS::strlen (host) + 1);
}
}
}
void
EC_Counting_Consumer::push (const RtecEventComm::EventSet& events)
{
if (events.length () == 0)
{
ACE_DEBUG ((LM_DEBUG,
"%s (%P|%t) no events\n", this->name_));
return;
}
this->event_count ++;
#if 0
if (this->event_count % 10 == 0)
{
ACE_DEBUG ((LM_DEBUG,
"%s (%P|%t): %d events received\n",
this->name_,
this->event_count));
}
#endif /* 0 */
}
void
TAO_EC_Kokyu_Scheduling::schedule_event (const RtecEventComm::EventSet &event,
TAO_EC_ProxyPushConsumer *consumer,
TAO_EC_Supplier_Filter *filter)
{
RtecEventChannelAdmin::SupplierQOS qos =
consumer->publications ();
for (CORBA::ULong j = 0; j != event.length (); ++j)
{
const RtecEventComm::Event& e = event[j];
RtecEventComm::Event* buffer =
const_cast<RtecEventComm::Event*> (&e);
RtecEventComm::EventSet single_event (1, 1, buffer, 0);
TAO_EC_QOS_Info qos_info;
for (CORBA::ULong i = 0; i != qos.publications.length (); ++i)
{
const RtecEventComm::EventHeader &qos_header =
qos.publications[i].event.header;
if (TAO_EC_Filter::matches (e.header, qos_header) == 0)
continue;
qos_info.rt_info = qos.publications[i].dependency_info.rt_info;
RtecScheduler::OS_Priority os_priority;
RtecScheduler::Preemption_Subpriority_t p_subpriority;
RtecScheduler::Preemption_Priority_t p_priority;
this->scheduler_->priority (qos_info.rt_info,
os_priority,
p_subpriority,
p_priority);
qos_info.preemption_priority = p_priority;
}
filter->push_scheduled_event (single_event, qos_info);
}
}
int main (int argc, char* argv[])
{
try
{
// Initialize the ORB.
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
// Find the Naming Service.
CORBA::Object_var obj = orb->resolve_initial_references("NameService");
CosNaming::NamingContextExt_var naming_client = CosNaming::NamingContextExt::_narrow(obj.in());
// Get the Event Channel using Naming Services
obj = naming_client->resolve_str("EventService");
// Downcast the object reference to an EventChannel reference.
RtecEventChannelAdmin::EventChannel_var ec =
RtecEventChannelAdmin::EventChannel::_narrow(obj.in());
if (CORBA::is_nil(ec.in())) {
cerr << "Could not resolve EchoEventChannel." << endl;
return 1;
}
// Get a SupplierAdmin object from the EventChannel.
RtecEventChannelAdmin::SupplierAdmin_var admin = ec->for_suppliers();
// Get a ProxyPushConsumer from the SupplierAdmin.
RtecEventChannelAdmin::ProxyPushConsumer_var consumer =
admin->obtain_push_consumer();
// Get the RootPOA.
obj = orb->resolve_initial_references("RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow(obj.in());
// Instantiate an EchoEventConsumer_i servant.
EchoEventSupplier_i servant(orb.in());
// Register it with the RootPOA.
PortableServer::ObjectId_var oid = poa->activate_object(&servant);
CORBA::Object_var supplier_obj = poa->id_to_reference(oid.in());
RtecEventComm::PushSupplier_var supplier =
RtecEventComm::PushSupplier::_narrow(supplier_obj.in());
// Publish the events the supplier provides.
ACE_SupplierQOS_Factory qos;
qos.insert (MY_SOURCE_ID, // Supplier's unique id
MY_EVENT_TYPE, // Event type
0, // handle to the rt_info structure
1); // number of calls
// Connect as a supplier of the published events.
consumer->connect_push_supplier (supplier.in (),
qos.get_SupplierQOS ());
// Activate the POA via its POAManager.
PortableServer::POAManager_var poa_manager = poa->the_POAManager();
poa_manager->activate();
// Create an event (just a string in this case).
const CORBA::String_var eventData = CORBA::string_dup("Hello, world.");
// Create an event set for one event
RtecEventComm::EventSet events (1);
events.length (1);
// Initialize event header.
events[0].header.source = MY_SOURCE_ID;
events[0].header.type = MY_EVENT_TYPE;
// Initialize data fields in event.
events[0].data.any_value <<= eventData;
cout << "Supplier starting sending of events" << endl;
while (1) {
consumer->push (events);
ACE_Time_Value tv(0, 1000 * EVENT_DELAY_MS);
orb->run(tv);
}
orb->destroy();
return 0;
}
catch (CORBA::Exception& ex)
{
cerr << "Supplier::main() Caught CORBA::Exception" << endl << ex << endl;
}
return 1;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
// Initialize the EC Factory so we can customize the EC
TAO_EC_Default_Factory::init_svcs ();
// Initialize the ORB.
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
const ACE_TCHAR* ecname = ACE_TEXT ("EventService");
const ACE_TCHAR* remote_ecname = 0;
const ACE_TCHAR* iorfile = 0;
for (int i = 0; argv[i] != 0; i++) {
if (ACE_OS::strcmp(argv[i], ACE_TEXT("-ecname")) == 0) {
if (argv[i+1] != 0) {
i++;
ecname = argv[i];
} else {
std::cerr << "Missing Event channel name" << std::endl;
}
}
if (ACE_OS::strcmp(argv[i], ACE_TEXT("-gateway")) == 0) {
if (argv[i+1] != 0) {
i++;
remote_ecname = argv[i];
} else {
std::cerr << "Missing Event channel name" << std::endl;
}
}
if (ACE_OS::strcmp(argv[i], ACE_TEXT("-iorfile")) == 0) {
if (argv[i+1] != 0) {
i++;
iorfile = argv[i];
}
}
}
// Get the POA
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 ();
// Spawn a thread for the orb
ACE_Thread_Manager *thread_mgr = ACE_Thread_Manager::instance();
thread_mgr->spawn(orb_thread, orb.in());
// Create a local event channel and register it with the RootPOA.
TAO_EC_Event_Channel_Attributes attributes (poa.in (), poa.in ());
PortableServer::Servant_var<TAO_EC_Event_Channel> ec_impl =
new TAO_EC_Event_Channel(attributes);
ec_impl->activate ();
PortableServer::ObjectId_var oid = poa->activate_object(ec_impl.in());
CORBA::Object_var ec_obj = poa->id_to_reference(oid.in());
RtecEventChannelAdmin::EventChannel_var ec =
RtecEventChannelAdmin::EventChannel::_narrow(ec_obj.in());
// Find the Naming Service.
object = orb->resolve_initial_references("NameService");
CosNaming::NamingContextExt_var root_context = CosNaming::NamingContextExt::_narrow(object.in());
CosNaming::Name_var name = root_context->to_name (ACE_TEXT_ALWAYS_CHAR (ecname));
root_context->rebind(name.in(), ec.in());
// Get a SupplierAdmin object from the EventChannel.
RtecEventChannelAdmin::SupplierAdmin_var admin = ec->for_suppliers();
// Get a ProxyPushConsumer from the SupplierAdmin.
RtecEventChannelAdmin::ProxyPushConsumer_var consumer =
admin->obtain_push_consumer();
// Instantiate an EchoEventSupplier_i servant.
PortableServer::Servant_var<EchoEventSupplier_i> servant =
new EchoEventSupplier_i(orb.in());
// Register it with the RootPOA.
oid = poa->activate_object(servant.in());
CORBA::Object_var supplier_obj = poa->id_to_reference(oid.in());
RtecEventComm::PushSupplier_var supplier =
RtecEventComm::PushSupplier::_narrow(supplier_obj.in());
// Publish the events the supplier provides.
ACE_SupplierQOS_Factory qos;
qos.insert (MY_SOURCE_ID, // Supplier's unique id
MY_EVENT_TYPE, // Event type
0, // handle to the rt_info structure
1); // number of calls
// Connect as a supplier of the published events.
consumer->connect_push_supplier (supplier.in (),
qos.get_SupplierQOS ());
// Create an event (just a string in this case).
const CORBA::String_var eventData = CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR (ecname));
// Create an event set for one event
RtecEventComm::EventSet event (1);
event.length (1);
// Initialize event header.
event[0].header.source = MY_SOURCE_ID;
event[0].header.ttl = 1;
event[0].header.type = MY_EVENT_TYPE;
// Initialize data fields in event.
event[0].data.any_value <<= eventData;
PortableServer::Servant_var<TAO_EC_Gateway_IIOP> gateway =
new TAO_EC_Gateway_IIOP;
int gateway_initialized = 0;
std::cout << "Supplier starting sending of events.\n";
while (1) {
consumer->push (event);
ACE_Time_Value tv(0, 1000 * EVENT_DELAY_MS);
orb->run(tv);
if ((remote_ecname != 0) && (!gateway_initialized)) {
try {
// Get the remote event channel object
CORBA::Object_var obj = root_context->resolve_str (ACE_TEXT_ALWAYS_CHAR (remote_ecname));
RtecEventChannelAdmin::EventChannel_var remote_ec =
RtecEventChannelAdmin::EventChannel::_narrow(obj.in());
int ok = 0;
if (!CORBA::is_nil(remote_ec.in())) {
// Now check if we can talk to it...
try {
RtecEventChannelAdmin::SupplierAdmin_var adm =
remote_ec->for_suppliers();
ok = 1;
} catch(const CORBA::UserException&) {
// What is the correct exception(s) to catch here?
}
}
// There is a good remote event channel so initialize the
// gateway.
if (ok) {
gateway->init(remote_ec.in(), ec.in());
PortableServer::ObjectId_var gateway_oid =
poa->activate_object(gateway.in());
CORBA::Object_var gateway_obj =
poa->id_to_reference(gateway_oid.in());
RtecEventChannelAdmin::Observer_var obs =
RtecEventChannelAdmin::Observer::_narrow(gateway_obj.in());
RtecEventChannelAdmin::Observer_Handle local_ec_obs_handle =
ec->append_observer (obs.in ());
ACE_UNUSED_ARG (local_ec_obs_handle);
gateway_initialized = 1;
std::cout << "Gateway initialized\n";
if (iorfile != 0) {
CORBA::String_var str = orb->object_to_string( ec.in() );
std::ofstream iorFile( ACE_TEXT_ALWAYS_CHAR(iorfile) );
iorFile << str.in() << std::endl;
iorFile.close();
}
}
} catch(const CosNaming::NamingContext::NotFound&) {
// Try again later...
}
}
}
orb->destroy();
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[])
{
try
{
// Initialize the EC Factory so we can customize the EC
TAO_EC_Default_Factory::init_svcs ();
// Initialize the ORB.
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
const ACE_TCHAR *ecname = ACE_TEXT ("EventService");
const ACE_TCHAR *address = ACE_TEXT ("localhost");
const ACE_TCHAR *iorfile = 0;
u_short port = 12345;
u_short listenport = 12345;
int mcast = 1;
for (int i = 0; argv[i] != 0; i++)
{
if (ACE_OS::strcasecmp(argv[i], ACE_TEXT ("-ecname")) == 0)
{
if (argv[i+1] != 0)
ecname = argv[++i];
else
ACE_ERROR_RETURN ((LM_ERROR, "Missing Event channel name\n"),0);
}
else if (ACE_OS::strcasecmp(argv[i], ACE_TEXT ("-address")) == 0)
{
if (argv[i+1] != 0)
address = argv[++i];
else
ACE_ERROR_RETURN ((LM_ERROR, "Missing address\n"),0);
}
else if (ACE_OS::strcasecmp(argv[i], ACE_TEXT ("-port")) == 0)
{
if (argv[i+1] != 0)
port = ACE_OS::atoi(argv[++i]);
else
ACE_ERROR_RETURN ((LM_ERROR, "Missing port\n"),0);
}
else if (ACE_OS::strcasecmp(argv[i], ACE_TEXT ("-listenport")) == 0)
{
if (argv[i+1] != 0)
listenport = ACE_OS::atoi(argv[++i]);
else
ACE_ERROR_RETURN ((LM_ERROR, "Missing port\n"), 0);
}
else if (ACE_OS::strcasecmp(argv[i], ACE_TEXT ("-iorfile")) == 0)
{
if (argv[i+1] != 0)
iorfile = argv[++i];
else
ACE_ERROR_RETURN ((LM_ERROR, "Missing ior file\n"), 0);
}
else if (ACE_OS::strcasecmp(argv[i], ACE_TEXT ("-udp")) == 0)
mcast = 0;
}
// Get the POA
CORBA::Object_var tmpobj = orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow (tmpobj.in ());
PortableServer::POAManager_var poa_manager = poa->the_POAManager ();
poa_manager->activate ();
// Create a local event channel and register it
TAO_EC_Event_Channel_Attributes attributes (poa.in (), poa.in ());
TAO_EC_Event_Channel ec_impl (attributes);
ec_impl.activate ();
PortableServer::ObjectId_var oid = poa->activate_object(&ec_impl);
tmpobj = poa->id_to_reference(oid.in());
RtecEventChannelAdmin::EventChannel_var ec =
RtecEventChannelAdmin::EventChannel::_narrow(tmpobj.in());
// Find the Naming Service.
tmpobj = orb->resolve_initial_references("NameService");
CosNaming::NamingContextExt_var root_context =
CosNaming::NamingContextExt::_narrow(tmpobj.in());
// Bind the Event Channel using Naming Services
CosNaming::Name_var name =
root_context->to_name (ACE_TEXT_ALWAYS_CHAR (ecname));
root_context->rebind(name.in(), ec.in());
// Get a proxy push consumer from the EventChannel.
RtecEventChannelAdmin::SupplierAdmin_var admin = ec->for_suppliers();
RtecEventChannelAdmin::ProxyPushConsumer_var consumer =
admin->obtain_push_consumer();
// Instantiate an EchoEventSupplier_i servant.
EchoEventSupplier_i servant(orb.in());
// Register it with the RootPOA.
oid = poa->activate_object(&servant);
tmpobj = poa->id_to_reference(oid.in());
RtecEventComm::PushSupplier_var supplier =
RtecEventComm::PushSupplier::_narrow(tmpobj.in());
// Connect to the EC.
ACE_SupplierQOS_Factory qos;
qos.insert (MY_SOURCE_ID, MY_EVENT_TYPE, 0, 1);
consumer->connect_push_supplier (supplier.in (), qos.get_SupplierQOS ());
// Initialize the address server with the desired address. This will
// be used by the sender object and the multicast receiver only if
// one is not otherwise available via the naming service.
ACE_INET_Addr send_addr (port, address);
SimpleAddressServer addr_srv_impl (send_addr);
// Create an instance of the addr server for local use
PortableServer::ObjectId_var addr_srv_oid =
poa->activate_object(&addr_srv_impl);
tmpobj =
poa->id_to_reference(addr_srv_oid.in());
RtecUDPAdmin::AddrServer_var addr_srv =
RtecUDPAdmin::AddrServer::_narrow(tmpobj.in());
// Create and initialize the sender object
PortableServer::Servant_var<TAO_ECG_UDP_Sender> sender =
TAO_ECG_UDP_Sender::create();
TAO_ECG_UDP_Out_Endpoint endpoint;
// need to be explicit about the address type when built with
// IPv6 support, otherwise SOCK_DGram::open defaults to ipv6 when
// given a sap_any address. This causes trouble on at least solaris
// and windows, or at most on not-linux.
if (endpoint.dgram ().open (ACE_Addr::sap_any,
send_addr.get_type()) == -1)
{
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open send endpoint\n"),
1);
}
// TAO_ECG_UDP_Sender::init() takes a TAO_ECG_Refcounted_Endpoint.
// If we don't clone our endpoint and pass &endpoint, the sender will
// attempt to delete endpoint during shutdown.
TAO_ECG_Refcounted_Endpoint clone (new TAO_ECG_UDP_Out_Endpoint (endpoint));
sender->init (ec.in (), addr_srv.in (), clone);
// Setup the subscription and connect to the EC
ACE_ConsumerQOS_Factory cons_qos_fact;
cons_qos_fact.start_disjunction_group ();
cons_qos_fact.insert (ACE_ES_EVENT_SOURCE_ANY, ACE_ES_EVENT_ANY, 0);
RtecEventChannelAdmin::ConsumerQOS sub = cons_qos_fact.get_ConsumerQOS ();
sender->connect (sub);
// Create and initialize the receiver
PortableServer::Servant_var<TAO_ECG_UDP_Receiver> receiver =
TAO_ECG_UDP_Receiver::create();
// TAO_ECG_UDP_Receiver::init() takes a TAO_ECG_Refcounted_Endpoint.
// If we don't clone our endpoint and pass &endpoint, the receiver will
// attempt to delete endpoint during shutdown.
TAO_ECG_Refcounted_Endpoint clone2 (new TAO_ECG_UDP_Out_Endpoint (endpoint));
receiver->init (ec.in (), clone2, addr_srv.in ());
// Setup the registration and connect to the event channel
ACE_SupplierQOS_Factory supp_qos_fact;
supp_qos_fact.insert (MY_SOURCE_ID, MY_EVENT_TYPE, 0, 1);
RtecEventChannelAdmin::SupplierQOS pub = supp_qos_fact.get_SupplierQOS ();
receiver->connect (pub);
// Create the appropriate event handler and register it with the reactor
auto_ptr<ACE_Event_Handler> eh;
if (mcast) {
auto_ptr<TAO_ECG_Mcast_EH> mcast_eh(new TAO_ECG_Mcast_EH (receiver.in()));
mcast_eh->reactor (orb->orb_core ()->reactor ());
mcast_eh->open (ec.in());
ACE_auto_ptr_reset(eh,mcast_eh.release());
//eh.reset(mcast_eh.release());
} else {
auto_ptr<TAO_ECG_UDP_EH> udp_eh (new TAO_ECG_UDP_EH (receiver.in()));
udp_eh->reactor (orb->orb_core ()->reactor ());
ACE_INET_Addr local_addr (listenport);
if (udp_eh->open (local_addr) == -1)
ACE_ERROR ((LM_ERROR,"Cannot open EH\n"));
ACE_auto_ptr_reset(eh,udp_eh.release());
//eh.reset(udp_eh.release());
}
// Create an event (just a string in this case).
// Create an event set for one event
RtecEventComm::EventSet event (1);
event.length (1);
// Initialize event header.
event[0].header.source = MY_SOURCE_ID;
event[0].header.ttl = 1;
event[0].header.type = MY_EVENT_TYPE;
#if !defined (TAO_LACKS_EVENT_CHANNEL_ANY)
// Initialize data fields in event.
const CORBA::String_var eventData =
CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR (ecname));
event[0].data.any_value <<= eventData;
#else
// Use the octet sequence payload instead
char *tmpstr = const_cast<char *>(ACE_TEXT_ALWAYS_CHAR (ecname));
size_t len = ACE_OS::strlen(tmpstr) +1;
event[0].data.payload.replace (
len,
len,
reinterpret_cast<CORBA::Octet *> (tmpstr));
#endif /* !TAO_LACKS_EVENT_CHANNEL_ANY */
if (iorfile != 0) {
CORBA::String_var str = orb->object_to_string( ec.in() );
std::ofstream iorFile( ACE_TEXT_ALWAYS_CHAR(iorfile) );
iorFile << str.in() << std::endl;
iorFile.close();
}
ACE_DEBUG ((LM_DEBUG,
"Starting main loop\n"));
const int EVENT_DELAY_MS = 1000;
while (1) {
consumer->push (event);
ACE_Time_Value tv(0, 1000 * EVENT_DELAY_MS);
orb->run(tv);
}
orb->destroy();
return 0;
}
catch (const CORBA::Exception& exc)
{
ACE_ERROR ((LM_ERROR,
"Caught CORBA::Exception\n%C (%C)\n",
exc._name (),
exc._rep_id () ));
}
return 1;
}
int
EC_Supplier_Task::svc (void)
{
// Initialize a time value to pace the test
ACE_Time_Value tv (0, this->burst_pause_);
RtecEventComm::EventSet event (1);
event.length (1);
event[0].header.ttl = 1;
ACE_hrtime_t t = ACE_OS::gethrtime ();
ORBSVCS_Time::hrtime_to_TimeT (event[0].header.creation_time, t);
// We use replace to minimize the copies, this should result
// in just one memory allocation;
event[0].data.payload.length (this->payload_size_);
for (int i = 0; i < this->burst_count_; ++i)
{
for (int j = 0; j < this->burst_size_; ++j)
{
try
{
this->supplier_->event_type (j, event[0]);
ACE_hrtime_t now = ACE_OS::gethrtime ();
ORBSVCS_Time::hrtime_to_TimeT (event[0].header.creation_time,
now);
// ACE_DEBUG ((LM_DEBUG, "(%t) supplier push event\n"));
this->supplier_->send_event (event);
}
catch (const CORBA::SystemException& sys_ex)
{
sys_ex._tao_print_exception ("SYS_EX");
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("SYS_EX");
}
}
ACE_OS::sleep (tv);
}
try
{
// Send one event shutdown from each supplier
event[0].header.type = this->shutdown_event_type_;
ACE_hrtime_t now = ACE_OS::gethrtime ();
ORBSVCS_Time::hrtime_to_TimeT (event[0].header.creation_time,
now);
this->supplier_->send_event (event);
}
catch (const CORBA::SystemException& sys_ex)
{
sys_ex._tao_print_exception ("SYS_EX");
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("SYS_EX");
}
ACE_DEBUG ((LM_DEBUG,
"Supplier task finished\n"));
return 0;
}
int
Test_Supplier::svc ()
{
try
{
// Initialize a time value to pace the test
ACE_Time_Value tv (0, this->burst_pause_);
// Pre-allocate a message to send
ACE_Message_Block mb (this->event_size_);
mb.wr_ptr (this->event_size_);
RtecEventComm::EventSet event (1);
event.length (1);
event[0].header.source = this->supplier_id ();
event[0].header.ttl = 1;
ACE_hrtime_t t = ACE_OS::gethrtime ();
ORBSVCS_Time::hrtime_to_TimeT (event[0].header.creation_time, t);
// We use replace to minimize the copies, this should result
// in just one memory allocation;
#if (TAO_NO_COPY_OCTET_SEQUENCES == 1)
event[0].data.payload.replace (this->event_size_,
&mb);
#else
// If the replace method is not available, we will need
// to do the copy manually. First, set the octet sequence length.
event[0].data.payload.length (this->event_size_);
// Now copy over each byte.
char* base = mb.data_block ()->base ();
for(CORBA::ULong i = 0; i < (CORBA::ULong)this->event_size_; i++)
{
event[0].data.payload[i] = base[i];
}
#endif /* TAO_NO_COPY_OCTET_SEQUENCES == 1 */
ACE_hrtime_t test_start = ACE_OS::gethrtime ();
for (int i = 0; i < this->burst_count_; ++i)
{
for (int j = 0; j < this->burst_size_; ++j)
{
event[0].header.type =
this->type_start_ + j % this->type_count_;
ACE_hrtime_t request_start = ACE_OS::gethrtime ();
ORBSVCS_Time::hrtime_to_TimeT (event[0].header.creation_time,
request_start);
// ACE_DEBUG ((LM_DEBUG, "(%t) supplier push event\n"));
this->consumer_proxy ()->push (event);
ACE_hrtime_t end = ACE_OS::gethrtime ();
this->throughput_.sample (end - test_start,
end - request_start);
}
if (TAO_debug_level > 0
&& i % 100 == 0)
{
ACE_DEBUG ((LM_DEBUG,
"ECT_Supplier (%P|%t): %d bursts sent\n",
i));
}
ACE_OS::sleep (tv);
}
// Send one event shutdown from each supplier
event[0].header.type = ACE_ES_EVENT_SHUTDOWN;
ACE_hrtime_t request_start = ACE_OS::gethrtime ();
ORBSVCS_Time::hrtime_to_TimeT (event[0].header.creation_time,
request_start);
this->consumer_proxy ()->push(event);
ACE_hrtime_t end = ACE_OS::gethrtime ();
this->throughput_.sample (end - test_start,
end - request_start);
}
catch (const CORBA::SystemException& sys_ex)
{
sys_ex._tao_print_exception ("SYS_EX");
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("NON SYS EX");
}
ACE_DEBUG ((LM_DEBUG,
"Supplier %4.4x completed\n",
this->supplier_id_));
return 0;
}
void
TAO_ECG_UDP_Sender::push (const RtecEventComm::EventSet &events)
{
if (events.length () == 0)
{
// ORBSVCS_DEBUG ((EC_FORMAT (DEBUG,
// "Nothing to multicast: "
// "0-length EventSet.")));
return;
}
// Send each event in a separate message.
// @@ TODO It is interesting to group events destined to the
// same mcast group in a single message.
for (u_int i = 0; i < events.length (); ++i)
{
// To avoid loops we keep a TTL field on the events and skip the
// events with TTL <= 0
if (events[i].header.ttl <= 0)
continue;
const RtecEventComm::Event& e = events[i];
// We need to modify the TTL field, but copying the entire event
// would be wasteful; instead we create a new header and only
// modify the header portion.
RtecEventComm::EventHeader header = e.header;
header.ttl--;
// Start building the message
TAO_OutputCDR cdr;
// Marshal as if it was a sequence of one element, notice how we
// marshal a modified version of the header, but the payload is
// marshal without any extra copies.
cdr.write_ulong (1);
if (!(cdr << header)
|| !(cdr << e.data))
throw CORBA::MARSHAL ();
ACE_INET_Addr inet_addr;
try
{
// Grab the right mcast group for this event...
RtecUDPAdmin::UDP_Address_var udp_addr;
this->addr_server_->get_address (header, udp_addr.out());
switch (udp_addr->_d())
{
case RtecUDPAdmin::Rtec_inet:
inet_addr.set(udp_addr->v4_addr().port,
udp_addr->v4_addr().ipaddr);
break;
case RtecUDPAdmin::Rtec_inet6:
#if defined (ACE_HAS_IPV6)
inet_addr.set_type(PF_INET6);
#endif
inet_addr.set_address(udp_addr->v6_addr().ipaddr,16,0);
inet_addr.set_port_number(udp_addr->v6_addr().port);
break;
}
}
catch (const ::CORBA::BAD_OPERATION &)
{
// server only supports IPv4
// Grab the right mcast group for this event...
RtecUDPAdmin::UDP_Addr udp_addr;
this->addr_server_->get_addr (header, udp_addr);
inet_addr.set (udp_addr.port, udp_addr.ipaddr);
}
this->cdr_sender_.send_message (cdr, inet_addr);
}
}
int
ECMS_Driver::supplier_task (Test_Supplier *supplier,
void* /* cookie */)
{
try
{
ACE_Time_Value tv (0, this->event_period_);
CORBA::ULong n = this->event_size_;
ECM_IDLData::Info info;
info.mobile_name = CORBA::string_dup ("test");
info.mobile_speed = 1;
info.trajectory.length (n);
ECM_Data other;
other.description = CORBA::string_dup ("some data");
for (CORBA::ULong j = 0; j < n; ++j)
{
info.trajectory[j].x = j;
info.trajectory[j].y = j * j;
other.inventory.bind (j, j + 1);
}
ACE_DEBUG ((LM_DEBUG,
"The inventory contains (%d) elements\n",
other.inventory.current_size ()));
// We have to make it big enough so we get a contiguous block,
// otherwise the octet sequence will not work correctly.
// NOTE: we could pre-allocate enough memory in the CDR stream
// but we want to show that chaining works!
TAO_OutputCDR cdr;
CORBA::Boolean byte_order = TAO_ENCAP_BYTE_ORDER;
cdr << CORBA::Any::from_boolean (byte_order);
// The typecode name standard, the encode method is not (in
// general the CDR interface is not specified).
if (!(cdr << info))
throw CORBA::MARSHAL ();
// Here we marshall a non-IDL type.
cdr << other;
if (!cdr.good_bit ())
ACE_ERROR ((LM_ERROR, "Problem marshalling C++ data\n"));
const ACE_Message_Block* mb = cdr.begin ();
// NOTE: total_length () return the length of the complete
// chain.
CORBA::ULong mblen = cdr.total_length ();
for (CORBA::Long i = 0; i < this->event_count_; ++i)
{
RtecEventComm::EventSet event (1);
event.length (1);
event[0].header.source = supplier->supplier_id ();
event[0].header.ttl = 1;
ACE_hrtime_t t = ACE_OS::gethrtime ();
ORBSVCS_Time::hrtime_to_TimeT (event[0].header.creation_time, t);
if (i == static_cast<CORBA::Long> (this->event_count_) - 1)
event[0].header.type = ACE_ES_EVENT_SHUTDOWN;
else if (i % 2 == 0)
event[0].header.type = this->event_a_;
else
event[0].header.type = this->event_b_;
// We use replace to minimize the copies, this should result
// in just one memory allocation;
#if (TAO_NO_COPY_OCTET_SEQUENCES == 1)
event[0].data.payload.replace (mblen, mb);
#else
// If the replace method is not available, we will need
// to do the copy manually. First, set the octet sequence length.
event[0].data.payload.length (mblen);
// Now copy over each byte.
char* base = mb->data_block ()->base ();
for(CORBA::ULong i = 0; i < mblen; i++)
{
event[0].data.payload[i] = base[i];
}
#endif /* TAO_NO_COPY_OCTET_SEQUENCES == 1 */
supplier->consumer_proxy ()->push(event);
// ACE_DEBUG ((LM_DEBUG, "(%t) supplier push event\n"));
ACE_OS::sleep (tv);
}
}
catch (const CORBA::SystemException& sys_ex)
{
sys_ex._tao_print_exception ("SYS_EX");
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("NON SYS EX");
}
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
// Initialize the EC Factory so we can customize the EC
TAO_EC_Default_Factory::init_svcs ();
// Initialize the ORB.
CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
const ACE_TCHAR* ecname = ACE_TEXT ("EventService");
const ACE_TCHAR* address = ACE_TEXT ("localhost");
const ACE_TCHAR* iorfile = 0;
u_short port = 12345;
u_short listenport = 12345;
int mcast = 1;
for (int i = 0; argv[i] != 0; i++) {
if (ACE_OS::strcmp(argv[i], ACE_TEXT("-ecname")) == 0) {
if (argv[i+1] != 0) {
i++;
ecname = argv[i];
} else {
std::cerr << "Missing Event channel name" << std::endl;
}
} else if (ACE_OS::strcmp(argv[i], ACE_TEXT("-address")) == 0) {
if (argv[i+1] != 0) {
i++;
address = argv[i];
} else {
std::cerr << "Missing address" << std::endl;
}
} else if (ACE_OS::strcmp(argv[i], ACE_TEXT("-port")) == 0) {
if (argv[i+1] != 0) {
i++;
port = ACE_OS::atoi(argv[i]);
} else {
std::cerr << "Missing port" << std::endl;
}
} else if (ACE_OS::strcmp(argv[i], ACE_TEXT("-listenport")) == 0) {
if (argv[i+1] != 0) {
i++;
listenport = ACE_OS::atoi(argv[i]);
} else {
std::cerr << "Missing port" << std::endl;
}
} else if (ACE_OS::strcmp(argv[i], ACE_TEXT("-iorfile")) == 0) {
if (argv[i+1] != 0) {
i++;
iorfile = argv[i];
}
} else if (ACE_OS::strcmp(argv[i], ACE_TEXT("-udp")) == 0) {
mcast = 0;
}
}
// Get the POA
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 ();
// Create a local event channel and register it
TAO_EC_Event_Channel_Attributes attributes (poa.in (), poa.in ());
PortableServer::Servant_var<TAO_EC_Event_Channel> ec_impl =
new TAO_EC_Event_Channel(attributes);
ec_impl->activate ();
PortableServer::ObjectId_var oid = poa->activate_object(ec_impl.in());
CORBA::Object_var ec_obj = poa->id_to_reference(oid.in());
RtecEventChannelAdmin::EventChannel_var ec =
RtecEventChannelAdmin::EventChannel::_narrow(ec_obj.in());
// Find the Naming Service.
CORBA::Object_var obj = orb->resolve_initial_references("NameService");
CosNaming::NamingContextExt_var root_context = CosNaming::NamingContextExt::_narrow(obj.in());
// Bind the Event Channel using Naming Services
CosNaming::Name_var name = root_context->to_name (ACE_TEXT_ALWAYS_CHAR (ecname));
root_context->rebind(name.in(), ec.in());
// Get a proxy push consumer from the EventChannel.
RtecEventChannelAdmin::SupplierAdmin_var admin = ec->for_suppliers();
RtecEventChannelAdmin::ProxyPushConsumer_var consumer =
admin->obtain_push_consumer();
// Instantiate an EchoEventSupplier_i servant.
PortableServer::Servant_var<EchoEventSupplier_i> servant =
new EchoEventSupplier_i(orb.in());
// Register it with the RootPOA.
oid = poa->activate_object(servant.in());
CORBA::Object_var supplier_obj = poa->id_to_reference(oid.in());
RtecEventComm::PushSupplier_var supplier =
RtecEventComm::PushSupplier::_narrow(supplier_obj.in());
// Connect to the EC.
ACE_SupplierQOS_Factory qos;
qos.insert (MY_SOURCE_ID, MY_EVENT_TYPE, 0, 1);
consumer->connect_push_supplier (supplier.in (), qos.get_SupplierQOS ());
// Initialize the address server with the desired address.
// This will be used by the sender object and the multicast
// receiver.
ACE_INET_Addr send_addr (port, address);
PortableServer::Servant_var<SimpleAddressServer> addr_srv_impl =
new SimpleAddressServer(send_addr);
PortableServer::ObjectId_var addr_srv_oid =
poa->activate_object(addr_srv_impl.in());
CORBA::Object_var addr_srv_obj = poa->id_to_reference(addr_srv_oid.in());
RtecUDPAdmin::AddrServer_var addr_srv =
RtecUDPAdmin::AddrServer::_narrow(addr_srv_obj.in());
// Create and initialize the sender object
PortableServer::Servant_var<TAO_ECG_UDP_Sender> sender =
TAO_ECG_UDP_Sender::create();
TAO_ECG_UDP_Out_Endpoint endpoint;
if (endpoint.dgram ().open (ACE_Addr::sap_any) == -1) {
std::cerr << "Cannot open send endpoint" << std::endl;
return 1;
}
// TAO_ECG_UDP_Sender::init() takes a TAO_ECG_Refcounted_Endpoint.
// If we don't clone our endpoint and pass &endpoint, the sender will
// attempt to delete endpoint during shutdown.
TAO_ECG_Refcounted_Endpoint clone (new TAO_ECG_UDP_Out_Endpoint (endpoint));
sender->init (ec.in (), addr_srv.in (), clone);
// Setup the subscription and connect to the EC
ACE_ConsumerQOS_Factory cons_qos_fact;
cons_qos_fact.start_disjunction_group ();
cons_qos_fact.insert (ACE_ES_EVENT_SOURCE_ANY, ACE_ES_EVENT_ANY, 0);
RtecEventChannelAdmin::ConsumerQOS sub = cons_qos_fact.get_ConsumerQOS ();
sender->connect (sub);
// Create and initialize the receiver
PortableServer::Servant_var<TAO_ECG_UDP_Receiver> receiver =
TAO_ECG_UDP_Receiver::create();
// TAO_ECG_UDP_Receiver::init() takes a TAO_ECG_Refcounted_Endpoint.
// If we don't clone our endpoint and pass &endpoint, the receiver will
// attempt to delete endpoint during shutdown.
TAO_ECG_Refcounted_Endpoint clone2 (new TAO_ECG_UDP_Out_Endpoint (endpoint));
receiver->init (ec.in (), clone2, addr_srv.in ());
// Setup the registration and connect to the event channel
ACE_SupplierQOS_Factory supp_qos_fact;
supp_qos_fact.insert (MY_SOURCE_ID, MY_EVENT_TYPE, 0, 1);
RtecEventChannelAdmin::SupplierQOS pub = supp_qos_fact.get_SupplierQOS ();
receiver->connect (pub);
// Create the appropriate event handler and register it with the reactor
auto_ptr<ACE_Event_Handler> eh;
if (mcast) {
auto_ptr<TAO_ECG_Mcast_EH> mcast_eh(new TAO_ECG_Mcast_EH (receiver.in()));
mcast_eh->reactor (orb->orb_core ()->reactor ());
mcast_eh->open (ec.in());
ACE_auto_ptr_reset(eh,mcast_eh.release());
//eh.reset(mcast_eh.release());
} else {
auto_ptr<TAO_ECG_UDP_EH> udp_eh (new TAO_ECG_UDP_EH (receiver.in()));
udp_eh->reactor (orb->orb_core ()->reactor ());
ACE_INET_Addr local_addr (listenport);
if (udp_eh->open (local_addr) == -1) {
std::cerr << "Cannot open EH" << std::endl;
}
ACE_auto_ptr_reset(eh,udp_eh.release());
//eh.reset(udp_eh.release());
}
// Create an event (just a string in this case).
const CORBA::String_var eventData = CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR (ecname));
// Create an event set for one event
RtecEventComm::EventSet event (1);
event.length (1);
// Initialize event header.
event[0].header.source = MY_SOURCE_ID;
event[0].header.ttl = 1;
event[0].header.type = MY_EVENT_TYPE;
// Initialize data fields in event.
event[0].data.any_value <<= eventData;
if (iorfile != 0) {
CORBA::String_var str = orb->object_to_string( ec.in() );
std::ofstream iorFile( ACE_TEXT_ALWAYS_CHAR(iorfile) );
iorFile << str.in() << std::endl;
iorFile.close();
}
std::cout << "Starting main loop" << std::endl;
const int EVENT_DELAY_MS = 10;
while (1) {
consumer->push (event);
ACE_Time_Value tv(0, 1000 * EVENT_DELAY_MS);
orb->run(tv);
}
orb->destroy();
return 0;
}
catch(const CORBA::Exception& exc)
{
std::cerr << "Caught CORBA::Exception" << std::endl << exc << std::endl;
}
return 1;
}