void Notify_Push_Consumer::_connect ( CosNotifyChannelAdmin::ConsumerAdmin_ptr consumer_admin, CosNotifyFilter::Filter_ptr filter) { CosNotifyComm::StructuredPushConsumer_var objref = this->_this (); CosNotifyChannelAdmin::ProxySupplier_var proxysupplier = consumer_admin->obtain_notification_push_supplier ( CosNotifyChannelAdmin::STRUCTURED_EVENT, proxy_id_); this->proxy_ = CosNotifyChannelAdmin::StructuredProxyPushSupplier::_narrow ( proxysupplier.in ()); CosNotification::QoSProperties properties (3); properties.length (3); properties[0].name = CORBA::string_dup (CosNotification::MaximumBatchSize); properties[0].value <<= (CORBA::Long) 3; properties[1].name = CORBA::string_dup (CosNotification::PacingInterval); properties[1].value <<= (TimeBase::TimeT) 1 * 1000 * 10000; this->proxy_->set_qos (properties); this->proxy_->add_filter (filter); this->proxy_->connect_structured_push_consumer (objref.in ()); // give ownership to POA this->_remove_ref (); }
void TAO_Notify_ThreadPool_Consumer::connect (void) { // Activate the consumer with the default_POA_ CosNotifyComm::StructuredPushConsumer_var objref = this->_this (); CosNotifyChannelAdmin::ProxySupplier_var proxysupplier; if (this->proxy_supplier_thread_count_ != 0) { // Narrow to the extended interface. NotifyExt::ConsumerAdmin_var admin_ext = NotifyExt::ConsumerAdmin::_narrow (this->admin_.in ()); NotifyExt::ThreadPoolParams tp_params = { NotifyExt::CLIENT_PROPAGATED, 0, 0, static_cast<CORBA::ULong> (this->proxy_supplier_thread_count_), 0, 0, 0, 0, 0 }; CosNotification::QoSProperties qos (1); qos.length (1); qos[0].name = CORBA::string_dup (NotifyExt::ThreadPool); qos[0].value <<= tp_params; // Obtain the proxy. The QoS is applied to the POA in which the Proxy is hosted. proxysupplier = admin_ext->obtain_notification_push_supplier_with_qos (CosNotifyChannelAdmin::STRUCTURED_EVENT , proxy_supplier_id_, qos); } else { proxysupplier = this->admin_->obtain_notification_push_supplier (CosNotifyChannelAdmin::STRUCTURED_EVENT , proxy_supplier_id_); } ACE_ASSERT (!CORBA::is_nil (proxysupplier.in ())); // narrow this->proxy_supplier_ = CosNotifyChannelAdmin::StructuredProxyPushSupplier::_narrow (proxysupplier.in ()); ACE_ASSERT (!CORBA::is_nil (proxy_supplier_.in ())); this->proxy_supplier_->connect_structured_push_consumer (objref.in ()); // Call subscription_change to inform the supplier that this consumer is available. CosNotification::EventTypeSeq added (1); CosNotification::EventTypeSeq removed; added.length (1); added[0].domain_name = CORBA::string_dup ("TEST_DOMAIN"); /* We generate a unique Id for the consumer type so that the supplier can distinguish between the consumers.*/ char type[BUFSIZ]; ACE_OS::sprintf (type, "TEST_TYPE_%d", this->proxy_supplier_id_); added[0].type_name = CORBA::string_dup (type); this->proxy_supplier_->subscription_change (added, removed); ACE_DEBUG ((LM_DEBUG, "(%P,%t) Created Consumer %d with %d threads at the ProxySupplier\n", proxy_supplier_id_, this->proxy_supplier_thread_count_)); }
CosNotifyChannelAdmin::EventChannel_ptr TAO_Notify_Lanes_Supplier_Client::create_ec (void) { CosNotifyChannelAdmin::EventChannel_var ec; CosNotifyChannelAdmin::EventChannelFactory_var ecf = this->orb_objects_.notify_factory (); // Create an EventChannel CosNotification::QoSProperties qos; CosNotification::AdminProperties admin; // Create an event channel CosNotifyChannelAdmin::ChannelID id; ec = ecf->create_channel (qos, admin, id); // Set the Qos : 2 Lanes NotifyExt::ThreadPoolLanesParams tpl_params; tpl_params.priority_model = NotifyExt::CLIENT_PROPAGATED; tpl_params.server_priority = 0; tpl_params.stacksize = 0; tpl_params.lanes.length (this->consumer_count_ + 1); tpl_params.allow_borrowing = 0; tpl_params.allow_request_buffering = 0; tpl_params.max_buffered_requests = 0; tpl_params.max_request_buffer_size = 0; /* * Note that we actually create 1 extra Lane. * The extra Lane at priority 0 is created to match the priority 0 of the supplier thread. * As the ProxyConsumer is activated in an RT POA with lanes, each invocation must mach some lane. * Now, we typically reserve higer priorities to make requests and the lowest priority 0 for administrative calls * e.g. <subscription_change>. If we do not have a lane at the lowest 0 priority, then the invocation made from * the supplier at priority 0 will fail. */ tpl_params.lanes[0].lane_priority = 0; // Priority 0 tpl_params.lanes[0].static_threads = 1; tpl_params.lanes[0].dynamic_threads = 0; RTCORBA::Priority priority = 1; // The priority at which we send an event each. for (int i = 1; i <= this->consumer_count_; ++i, ++priority) { tpl_params.lanes[i].lane_priority = priority; tpl_params.lanes[i].static_threads = 1; tpl_params.lanes[i].dynamic_threads = 0; } qos.length (1); qos[0].name = CORBA::string_dup (NotifyExt::ThreadPoolLanes); qos[0].value <<= tpl_params; // Note that instead of <set_qos>, the <qos> can also be passed while creating the channel. ec->set_qos (qos); return ec._retn (); }
void Notify_Sequence_Push_Consumer::_connect ( CosNotifyChannelAdmin::ConsumerAdmin_ptr consumer_admin) { CosNotifyComm::SequencePushConsumer_var objref = this->_this (); CosNotifyChannelAdmin::ProxySupplier_var proxysupplier = consumer_admin->obtain_notification_push_supplier ( CosNotifyChannelAdmin::SEQUENCE_EVENT, proxy_id_); this->proxy_ = CosNotifyChannelAdmin::SequenceProxyPushSupplier::_narrow ( proxysupplier.in ()); CosNotification::QoSProperties properties (1); properties.length (1); properties[0].name = CORBA::string_dup (CosNotification::PacingInterval); properties[0].value <<= PACING; this->proxy_->set_qos (properties); this->proxy_->connect_sequence_push_consumer (objref.in ()); // give ownership to POA this->_remove_ref (); }
//----------------------------------------------------------------------------- const CosNotification::QoSProperties BaseHelper::getQoSProps() { CosNotification::QoSProperties retVal; retVal.length(0); return retVal; }
MyConsumer(CosNotifyChannelAdmin::EventChannel_ptr ec) : Miro::StructuredPushConsumer(ec) { CosNotification::QoSProperties properties; properties.length(2); // only queue one event per consumer properties[0].name = CORBA::string_dup(CosNotification::MaxEventsPerConsumer); properties[0].value <<= CORBA::Long(1); // discard older events properties[1].name = CORBA::string_dup(CosNotification::DiscardPolicy); properties[1].value <<= CORBA::Long(CosNotification::FifoOrder); consumerAdmin_->set_qos(properties); }
void Notify_Structured_Push_Consumer::_connect ( CosNotifyChannelAdmin::ConsumerAdmin_ptr consumer_admin) { #ifdef TEST_QOS_MAX_EVENTS_PER_CONSUMER CosNotification::QoSProperties properties (8); properties.length (2); CORBA::ULong idx = 0; properties[idx].name = CORBA::string_dup (CosNotification::DiscardPolicy); properties[idx].value <<= this->CosNotification::FifoOrder; idx += 1; properties[idx].name = CORBA::string_dup (CosNotification::MaxEventsPerConsumer); properties[idx].value <<= 500; idx += 1; ACE_OS::printf("Setting %d::%d QoS properties in Admin.\n", (int)idx, (int)properties.length()); consumer_admin->set_qos (properties); #endif // TEST_QOS_MAX_EVENTS_PER_CONSUMER CosNotifyComm::StructuredPushConsumer_var objref = this->_this (); CosNotifyChannelAdmin::ProxySupplier_var proxysupplier = consumer_admin->obtain_notification_push_supplier ( CosNotifyChannelAdmin::STRUCTURED_EVENT, proxy_id_); this->proxy_ = CosNotifyChannelAdmin::StructuredProxyPushSupplier::_narrow ( proxysupplier.in ()); this->proxy_->connect_structured_push_consumer (objref.in ()); CosNotification::EventTypeSeq added (1); CosNotification::EventTypeSeq removed (1); added.length (1); removed.length (1); added[0].domain_name = CORBA::string_dup ("*"); added[0].type_name = CORBA::string_dup ("examples"); removed[0].domain_name = CORBA::string_dup ("*"); removed[0].type_name = CORBA::string_dup ("*"); this->subscription_change (added, removed); // give ownership to POA this->_remove_ref (); }
void TAO_Notify_ThreadPool_Supplier::connect (void) { // Activate the supplier object. CosNotifyComm::StructuredPushSupplier_var objref = this->_this (); CosNotifyChannelAdmin::ProxyConsumer_var proxyconsumer; if (this->proxy_consumer_thread_count_ != 0) { // Narrow to the extended interface. NotifyExt::SupplierAdmin_var admin_ext = NotifyExt::SupplierAdmin::_narrow (this->admin_.in ()); NotifyExt::ThreadPoolParams tp_params = { NotifyExt::CLIENT_PROPAGATED, 0, 0, static_cast<CORBA::ULong> (this->proxy_consumer_thread_count_), 0, 0, 0, 0, 0 }; CosNotification::QoSProperties qos (1); qos.length (1); qos[0].name = CORBA::string_dup (NotifyExt::ThreadPool); qos[0].value <<= tp_params; // Obtain the proxy. The QoS is applied to the POA in which the Proxy is hosted. proxyconsumer = admin_ext->obtain_notification_push_consumer_with_qos (CosNotifyChannelAdmin::STRUCTURED_EVENT , proxy_consumer_id_, qos); } else { // Obtain the proxy. proxyconsumer = this->admin_->obtain_notification_push_consumer (CosNotifyChannelAdmin::STRUCTURED_EVENT , proxy_consumer_id_); } ACE_ASSERT (!CORBA::is_nil (proxyconsumer.in ())); // narrow this->proxy_consumer_ = CosNotifyChannelAdmin::StructuredProxyPushConsumer::_narrow (proxyconsumer.in ()); ACE_ASSERT (!CORBA::is_nil (proxy_consumer_.in ())); // connect to the proxyconsumer. proxy_consumer_->connect_structured_push_supplier (objref.in ()); ACE_DEBUG ((LM_DEBUG, "(%P,%t) Created Supplier %d with %d threads at the ProxyConsumer\n", proxy_consumer_id_, this->proxy_consumer_thread_count_)); }
void Notify_Structured_Push_Consumer::_connect ( CosNotifyChannelAdmin::ConsumerAdmin_ptr consumer_admin) { CosNotifyComm::StructuredPushConsumer_var objref = this->_this (); CosNotifyChannelAdmin::ProxySupplier_var proxysupplier = consumer_admin->obtain_notification_push_supplier ( CosNotifyChannelAdmin::STRUCTURED_EVENT, proxy_id_); this->proxy_ = CosNotifyChannelAdmin::StructuredProxyPushSupplier::_narrow ( proxysupplier.in ()); CosNotification::QoSProperties properties (2); properties.length (2); // The discard policy and admin properties tests already test using // the MaxQueueLength policy, so we'll use MEPC instead. It should // make no difference. // If the blocking timeout is less than CONSUMER_DELAY seconds, then // we want to ensure that exactly one event is discarded, so we set // the MEPC to expected_ - 1. If the supplier sends 20, then we expect 19, // and we set MEPC to 18. The first event will be dispatched at once, but // will block in the consumer. This will allow the queue in the notify svc // to fill up to 18. However, the blocking code will timeout before the // consumer finishes which will cause an event to be discarded. This will // allow the last event to be queued. Eventually the consumer will unblock // and receive the remaining events properties[0].name = CORBA::string_dup (CosNotification::MaxEventsPerConsumer); if (blocking_timeout_ < CONSUMER_DELAY * 1000 * 1000 * 10) properties[0].value <<= (CORBA::Long) expected_ - 1; else properties[0].value <<= (CORBA::Long) 10; properties[1].name = CORBA::string_dup (TAO_Notify_Extensions::BlockingPolicy); properties[1].value <<= this->blocking_timeout_; this->proxy_->set_qos (properties); this->proxy_->connect_structured_push_consumer (objref.in ()); // give ownership to POA this->_remove_ref (); }
void TAO_CosNotify_Service::set_threads (CosNotification::QoSProperties &qos, int threads) { NotifyExt::ThreadPoolParams tp_params = {NotifyExt::CLIENT_PROPAGATED, 0, 0, (unsigned)threads, 0, 0, 0, 0, 0 }; qos.length (1); qos[0].name = CORBA::string_dup (NotifyExt::ThreadPool); qos[0].value <<= tp_params; }
CosNotifyChannelAdmin::EventChannel_ptr TAO_Notify_ThreadPool_Supplier_Client::create_ec (void) { CosNotifyChannelAdmin::EventChannel_var ec; CosNotifyChannelAdmin::EventChannelFactory_var ecf = this->orb_objects_.notify_factory (); // Create an EventChannel CosNotification::QoSProperties qos; CosNotification::AdminProperties admin; // Create an event channel CosNotifyChannelAdmin::ChannelID id; ec = ecf->create_channel (qos, admin, id); // Set the Qos // See $TAO_ROOT/orbsvcs/orbsvcs/NotifyExt.idl if (this->ec_thread_count_) { NotifyExt::ThreadPoolParams tp_params = { NotifyExt::CLIENT_PROPAGATED, 0, 0, static_cast<CORBA::ULong> (this->ec_thread_count_), 0, 0, 0, 0, 0 }; CosNotification::QoSProperties qos (1); qos.length (1); qos[0].name = CORBA::string_dup (NotifyExt::ThreadPool); qos[0].value <<= tp_params; // Note that instead of <set_qos>, the <qos> can also be passed while creating the channel. ec->set_qos (qos); } ACE_DEBUG ((LM_DEBUG, "(%P,%t) Created Event Channel with %d threads\n", this->ec_thread_count_)); return ec._retn (); }
void Notify_Sequence_Push_Consumer::_connect ( CosNotifyChannelAdmin::ConsumerAdmin_ptr consumer_admin) { CosNotifyComm::SequencePushConsumer_var objref = this->_this (); CosNotifyChannelAdmin::ProxySupplier_var proxysupplier = consumer_admin->obtain_notification_push_supplier ( CosNotifyChannelAdmin::SEQUENCE_EVENT, proxy_id_); this->proxy_ = CosNotifyChannelAdmin::SequenceProxyPushSupplier::_narrow ( proxysupplier.in ()); CosNotification::QoSProperties properties (3); properties.length (3); properties[0].name = CORBA::string_dup (CosNotification::MaximumBatchSize); properties[0].value <<= (CORBA::Long) BATCH_SIZE; properties[1].name = CORBA::string_dup (CosNotification::PacingInterval); properties[1].value <<= (TimeBase::TimeT) (1000 * 10000); // 1 secs if (use_ordering_) { properties[2].name = CORBA::string_dup (CosNotification::OrderPolicy); properties[2].value <<= this->order_policy_; } else { properties.length(2); } this->proxy_->set_qos (properties); this->proxy_->connect_sequence_push_consumer (objref.in ()); // give ownership to POA this->_remove_ref (); }
void Notify_Sequence_Push_Consumer::_connect ( CosNotifyChannelAdmin::ConsumerAdmin_ptr consumer_admin) { CosNotifyComm::SequencePushConsumer_var consumer = this->_this (); CosNotifyChannelAdmin::ProxySupplier_var proxysupplier = consumer_admin->obtain_notification_push_supplier ( CosNotifyChannelAdmin::SEQUENCE_EVENT, proxy_id_); this->proxy_ = CosNotifyChannelAdmin::SequenceProxyPushSupplier::_narrow ( proxysupplier.in ()); CosNotification::QoSProperties properties (4); properties.length (4); CORBA::ULong idx = 0; properties[idx].name = CORBA::string_dup (CosNotification::MaximumBatchSize); properties[idx].value <<= BATCH_SIZE; properties[++idx].name = CORBA::string_dup (CosNotification::PacingInterval); properties[idx].value <<= PACING; properties[++idx].name = CORBA::string_dup (CosNotification::DiscardPolicy); properties[idx].value <<= this->discard_policy_; properties[++idx].name = CORBA::string_dup (CosNotification::MaxEventsPerConsumer); // We set this equal to the batch size so that we conveniently always receive // one more batch after the first. properties[idx].value <<= BATCH_SIZE; this->proxy_->set_qos (properties); this->proxy_->connect_sequence_push_consumer (consumer.in ()); // give ownership to POA this->_remove_ref (); }
void TAO_Notify_Tests_Options_Parser::execute (CosNotification::QoSProperties& qos, ACE_Arg_Shifter& arg_shifter) { const ACE_TCHAR *current_arg = 0; NotifyExt::Priority default_priority = NotifyExt::minPriority; if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-ThreadPool")) == 0) // -ThreadPool [-Threads static_threads] [-Priority default_priority] { arg_shifter.consume_arg (); CORBA::ULong static_threads = 1u; if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-Threads")) == 0) { arg_shifter.consume_arg (); current_arg = arg_shifter.get_current (); static_threads = static_cast<CORBA::ULong> (ACE_OS::atoi (current_arg)); arg_shifter.consume_arg (); } if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-Priority")) == 0) { arg_shifter.consume_arg (); current_arg = arg_shifter.get_current (); const int priority= ACE_OS::atoi (current_arg); if (priority < NotifyExt::minPriority) { NotifyExt::Priority default_priority = NotifyExt::minPriority; ACE_DEBUG ((LM_DEBUG, "-Priority %d is too small (min priority %d used)\n", priority, static_cast<int> (default_priority))); } else if (NotifyExt::maxPriority < priority) { NotifyExt::Priority default_priority = NotifyExt::maxPriority; ACE_DEBUG ((LM_DEBUG, "-Priority %d is too large (max priority %d used)\n", priority, static_cast<int> (default_priority))); } else default_priority = static_cast<NotifyExt::Priority> (priority); arg_shifter.consume_arg (); } NotifyExt::ThreadPoolParams tp_params = { NotifyExt::CLIENT_PROPAGATED, default_priority, 0, static_threads, 0, default_priority, 0, 0, 0 }; qos.length (1); qos[0].name = CORBA::string_dup (NotifyExt::ThreadPool); qos[0].value <<= tp_params; } /* ThreadPool */ else if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-Lanes")) == 0) // -Lanes lane_count -Lane prio static_thr dy_thr { arg_shifter.consume_arg (); current_arg = arg_shifter.get_current (); int lanecount = ACE_OS::atoi (current_arg); arg_shifter.consume_arg (); NotifyExt::ThreadPoolLanesParams tpl_params; tpl_params.priority_model = NotifyExt::CLIENT_PROPAGATED; tpl_params.server_priority = default_priority; tpl_params.stacksize = 0; tpl_params.lanes.length (lanecount); tpl_params.allow_borrowing = 0; tpl_params.allow_request_buffering = 0; tpl_params.max_buffered_requests = 0; tpl_params.max_request_buffer_size = 0; int l_index = 0; //parse lane values ... while (arg_shifter.is_anything_left ()) { if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-Lane")) == 0) { arg_shifter.consume_arg (); // read priority tpl_params.lanes[l_index].lane_priority = ACE_OS::atoi (arg_shifter.get_current ()); arg_shifter.consume_arg (); // static thread count tpl_params.lanes[l_index].static_threads = ACE_OS::atoi (arg_shifter.get_current ()); arg_shifter.consume_arg (); // dynamic thread count tpl_params.lanes[l_index].dynamic_threads = ACE_OS::atoi (arg_shifter.get_current ()); arg_shifter.consume_arg (); if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, "QoS Parser parsed lane: - %d, %d, %d\n", tpl_params.lanes[l_index].lane_priority, tpl_params.lanes[l_index].static_threads, tpl_params.lanes[l_index].dynamic_threads)); l_index++; } else break; } /* while -- lane values */ qos.length (1); qos[0].name = CORBA::string_dup (NotifyExt::ThreadPoolLanes); qos[0].value <<= tpl_params; } /* ThreadPoolLane */ }
int Sequence::init (int argc, ACE_TCHAR* argv []) { if (TAO_debug_level) { ACE_DEBUG ((LM_DEBUG, "Options: event count = %d\n" "supplier batch size = %d\n" "consumer batch size = %d\n" "pacing = %d secs\n" , event_count_ , supplier_batch_size_ , consumer_batch_size_ , pacing_)); ACE_DEBUG ((LM_DEBUG, "consumer delay = %d\n", consumer_delay_.sec ())); } // Initialize the base class. Notify_Test_Client::init (argc, argv); // Create all participents. this->create_EC (); CosNotifyChannelAdmin::AdminID adminid; this->supplier_admin_ = this->ec_->new_for_suppliers (this->ifgop_, adminid); ACE_ASSERT (!CORBA::is_nil (supplier_admin_.in ())); this->consumer_admin_ = this->ec_->new_for_consumers (this->ifgop_, adminid); ACE_ASSERT (!CORBA::is_nil (consumer_admin_.in ())); ACE_NEW_RETURN (this->consumer_, SequencePushConsumer (this), -1); this->consumer_->init (root_poa_.in ()); this->consumer_->connect (this->consumer_admin_.in ()); CosNotification::QoSProperties properties (3); properties.length (3); properties[0].name = CORBA::string_dup (CosNotification::MaximumBatchSize); properties[0].value <<= (CORBA::Long) this->consumer_batch_size_; properties[1].name = CORBA::string_dup (CosNotification::PacingInterval); properties[1].value <<= (TimeBase::TimeT) (this->pacing_ * 1000 * 10000); properties[2].name = CORBA::string_dup (CosNotification::OrderPolicy); properties[2].value <<= this->order_policy_; this->consumer_->get_proxy_supplier ()->set_qos (properties); ACE_NEW_RETURN (this->supplier_, SequencePushSupplier (this), -1); this->supplier_->init (root_poa_.in ()); this->supplier_->connect (this->supplier_admin_.in ()); consumer_start( 0 ); return 0; }
//------------------------------------------------------ CosNotification::QoSProperties CDBProperties::getCDBQoSProps(const std::string& channelName) { CosNotification::QoSProperties retVal; retVal.length(0); //sanity check if (cdbChannelConfigExists(channelName)==false) { return retVal; } //CDB //complete name of the channel within the CDB std::string cdbChannelName = "MACI/Channels/" + channelName; CDB::DAL_var cdbRef = getCDB(); CDB::DAO_var tempDAO = cdbRef->get_DAO_Servant(cdbChannelName.c_str()); //temporary pointer points to the name of the CosNotification //property const char *name_p; //temporary counter unsigned int i = 0U; //commented out because TAO does not support these props /* //EventReliability/////////////////////////////////////////////// { name_p = CosNotification::EventReliability; //allocate one extra element i++; retVal.length(i); retVal[i-1].name = CORBA::string_dup(name_p); std::string tStringER = tempDAO->get_string(name_p); if(tStringER=="BestEffort") { retVal[i-1].value <<= CosNotification::BestEffort; } else { retVal[i-1].value <<= CosNotification::Persistent; } } //ConnectionReliability/////////////////////////////////////////////// { name_p = CosNotification::ConnectionReliability; //allocate one extra element i++; retVal.length(i); retVal[i-1].name = CORBA::string_dup(name_p); std::string tStringCR = tempDAO->get_string(name_p); if(tStringCR=="BestEffort") { retVal[i-1].value <<= CosNotification::BestEffort; } else { retVal[i-1].value <<= CosNotification::Persistent; } } */ //Priority///////////////////////////////////////////////////// { name_p = CosNotification::Priority; //allocate one extra element i++; retVal.length(i); retVal[i-1].name = CORBA::string_dup(name_p); retVal[i-1].value <<= static_cast<CORBA::Short>(tempDAO->get_long(name_p)); } //Timeout////////////////////////////////////////////////////// { name_p = CosNotification::Timeout; //allocate one extra element i++; retVal.length(i); retVal[i-1].name = CORBA::string_dup(name_p); retVal[i-1].value <<= static_cast<TimeBase::TimeT>(tempDAO->get_long(name_p)); } //OrderPolicy/////////////////////////////////////////////// { name_p = CosNotification::OrderPolicy; //allocate one extra element i++; retVal.length(i); retVal[i-1].name = CORBA::string_dup(name_p); std::string tStringOP = tempDAO->get_string(name_p); if(tStringOP=="AnyOrder") { retVal[i-1].value <<= CosNotification::AnyOrder; } else if(tStringOP=="FifoOrder") { retVal[i-1].value <<= CosNotification::FifoOrder; } else if(tStringOP=="PriorityOrder") { retVal[i-1].value <<= CosNotification::PriorityOrder; } else if(tStringOP=="DeadlineOrder") { retVal[i-1].value <<= CosNotification::DeadlineOrder; } else { //DWF-throw exception } } //DiscardPolicy/////////////////////////////////////////////// { name_p = CosNotification::DiscardPolicy; //allocate one extra element i++; retVal.length(i); retVal[i-1].name = CORBA::string_dup(name_p); std::string tStringDP = tempDAO->get_string(name_p); if(tStringDP=="AnyOrder") { retVal[i-1].value <<= CosNotification::AnyOrder; } else if(tStringDP=="FifoOrder") { retVal[i-1].value <<= CosNotification::FifoOrder; } else if(tStringDP=="PriorityOrder") { retVal[i-1].value <<= CosNotification::PriorityOrder; } else if(tStringDP=="DeadlineOrder") { retVal[i-1].value <<= CosNotification::DeadlineOrder; } else if(tStringDP=="LifoOrder") { retVal[i-1].value <<= CosNotification::LifoOrder; } else { //DWF-throw exception } } //commented out because TAO does not support these props /* //Start Time Supported///////////////////////////////////////// { name_p = CosNotification::StartTimeSupported; //allocate one extra element i++; retVal.length(i); retVal[i-1].name = CORBA::string_dup(name_p); std::string tStringStartTS = tempDAO->get_string(name_p); if(tStringStartTS=="false") { retVal[i-1].value <<= false; } else { retVal[i-1].value <<= true; } } //Stop Time Supported///////////////////////////////////////// { name_p = CosNotification::StopTimeSupported; //allocate one extra element i++; retVal.length(i); retVal[i-1].name = CORBA::string_dup(name_p); std::string tStringStopTS = tempDAO->get_string(name_p); if(tStringStopTS=="false") { retVal[i-1].value <<= false; } else { retVal[i-1].value <<= true; } } */ //Max Events per Consumer///////////////////////////////////// { name_p = CosNotification::MaxEventsPerConsumer; //allocate one extra element i++; retVal.length(i); retVal[i-1].name = CORBA::string_dup(name_p); retVal[i-1].value <<= static_cast<CORBA::Long>(tempDAO->get_long(name_p)); } //for debugging purposes only std::string debugMessage = "Length=" + retVal.length(); STATIC_LOG(Logging::BaseLog::LM_DEBUG, "nc::CDBProperties::getCDBQoSProps", debugMessage); return retVal; }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { int status = 0; ACE_Auto_Ptr< sig_i > sig_impl; try { Supplier_Client client; status = client.init (argc, argv); if (status == 0) { CosNotifyChannelAdmin::EventChannel_var ec = client.create_event_channel ("MyEventChannel", 0); if (use_deadline_ordering) { CosNotification::QoSProperties qos (1); qos.length (1); qos[0].name = CORBA::string_dup (CosNotification::OrderPolicy); qos[0].value <<= (CORBA::Short)CosNotification::DeadlineOrder; ec->set_qos (qos); } sig_impl.reset( new sig_i( client.orb() ) ); sig_var sig = sig_impl->_this (); // If the ior_output_file exists, output the ior to it if (ior_output_file != 0) { CORBA::String_var ior = client.orb ()->object_to_string (sig.in ()); FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); ACE_ASSERT (output_file != 0); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); } CosNotifyChannelAdmin::SupplierAdmin_var admin = create_supplieradmin (ec.in ()); ACE_ASSERT(!CORBA::is_nil (admin.in ())); create_suppliers (admin.in (), client.root_poa ()); sig_impl->wait_for_startup(); ACE_DEBUG((LM_DEBUG, "1 supplier sending %d events...\n", num_events)); for (int i = 0; i < num_events; ++i) { ACE_DEBUG((LM_DEBUG, "+")); SendEvent (i + 1); } ACE_DEBUG((LM_DEBUG, "\nSupplier sent %d events.\n", num_events)); sig_impl->wait_for_completion(); ACE_OS::unlink (ior_output_file); supplier_1->disconnect(); ec->destroy(); } } catch (const CORBA::Exception& e) { e._tao_print_exception ("Error: "); status = 1; } return status; }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { try { CORBA::ORB_var orb = CORBA::ORB_init(argc, argv); 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()); PortableServer::Servant_var<StructuredEventConsumer_i> servant = new StructuredEventConsumer_i(orb.in()); PortableServer::ObjectId_var objectId = poa->activate_object (servant.in()); CORBA::Object_var consumer_obj = poa->id_to_reference (objectId.in ()); CosNotifyComm::StructuredPushConsumer_var consumer = CosNotifyComm::StructuredPushConsumer::_narrow (consumer_obj.in ()); 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()); CosNotification::QoSProperties properties (1); properties.length (1); properties[0].name = CORBA::string_dup (CosNotification::OrderPolicy); properties[0].value <<= CosNotification::FifoOrder; supplier_proxy->set_qos (properties); 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); PortableServer::POAManager_var poa_manager = poa->the_POAManager(); poa_manager->activate(); orb->run(); } catch(const CORBA::Exception& ex) { std::cerr << "Caught exception: " << ex << std::endl; 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 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 ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { ACE_Auto_Ptr< sig_i > sig_impl; try { Supplier_Client client; int status = client.init (argc, argv); ACE_UNUSED_ARG(status); ACE_ASSERT(status == 0); CosNotifyChannelAdmin::EventChannel_var ec = client.create_event_channel ("MyEventChannel", 0); CosNotification::QoSProperties qos (1); qos.length (1); qos[0].name = CORBA::string_dup (CosNotification::OrderPolicy); qos[0].value <<= order_policy; ec->set_qos (qos); CORBA::ORB_ptr orb = client.orb (); sig_impl.reset( new sig_i( orb ) ); sig_var sig = sig_impl->_this (); CORBA::String_var ior = orb->object_to_string (sig.in ()); if (ior_output_file != 0) { FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); if (output_file == 0) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file %s for " "writing IOR: %C", ior_output_file, ior.in ()), 1); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); } CosNotifyChannelAdmin::SupplierAdmin_var admin = create_supplieradmin (ec.in ()); ACE_ASSERT(!CORBA::is_nil (admin.in ())); create_suppliers (admin.in (), client.root_poa ()); sig_impl->wait_for_startup(); ACE_DEBUG((LM_DEBUG, "1 supplier sending %d events...\n", num_events)); for (int i = 0; i < num_events / BATCH_SIZE; ++i) { ACE_DEBUG((LM_DEBUG, "+")); SendBatch (i); } ACE_DEBUG((LM_DEBUG, "\nSupplier sent %d events.\n", num_events)); sig_impl->wait_for_completion(); ACE_OS::unlink (ior_output_file); supplier_1->disconnect(); ec->destroy(); return 0; } catch (const CORBA::Exception& e) { e._tao_print_exception ("Error: "); } return 1; }
void Supplier_Main::init_event_channel (void) { bool ok = false; if (this->reconnecting_) { try { this->ec_ = this->ecf_->get_event_channel ( this->ec_id_); ok = ! CORBA::is_nil (this->ec_.in ()); if (ok && this->verbose_) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Supplier: Reconnect to event channel %d\n"), static_cast<int>(this->ec_id_) )); } } catch (...) { } } // if we don't have a channel yet, and a channel id file was specified // try to read from it if (!ok && this->channel_file_.length () > 0) { FILE * chf = ACE_OS::fopen (this->channel_file_.c_str (), "r"); if (chf != 0) { char buffer[100]; ACE_OS::fgets (buffer, sizeof(buffer), chf); ACE_OS::fclose (chf); this->ec_id_ = ACE_OS::atoi (buffer); try { this->ec_ = this->ecf_->get_event_channel ( this->ec_id_); ok = ! CORBA::is_nil (this->ec_.in ()); if (ok) { if (this->verbose_) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Supplier: Connect to Existing event channel %d\n"), static_cast<int>(this->ec_id_) )); } // kill the channel filename so we don't overwrite the file this->channel_file_ = ACE_TEXT(""); } } catch (...) { } } } if (!ok) { CosNotification::QoSProperties qosprops (7); qosprops.length (7); CORBA::ULong i = 0; qosprops[i].name = CORBA::string_dup(CosNotification::EventReliability); qosprops[i++].value <<= CosNotification::Persistent; qosprops[i].name = CORBA::string_dup(CosNotification::ConnectionReliability); qosprops[i++].value <<= CosNotification::Persistent; // Required, or we won't persist much qosprops[i].name = CORBA::string_dup(CosNotification::Priority); qosprops[i++].value <<= CosNotification::HighestPriority; qosprops[i].name = CORBA::string_dup(CosNotification::Timeout); qosprops[i++].value <<= (TimeBase::TimeT) 42 * 1000000; // 4.2s qosprops[i].name = CORBA::string_dup(CosNotification::StopTimeSupported); qosprops[i++].value <<= CORBA::Any::from_boolean(1); qosprops[i].name = CORBA::string_dup(CosNotification::MaximumBatchSize); qosprops[i++].value <<= (CORBA::Long) 2; qosprops[i].name = CORBA::string_dup(CosNotification::PacingInterval); qosprops[i++].value <<= (TimeBase::TimeT) 50 * 10000; // 50ms CosNotification::AdminProperties adminprops(4); adminprops.length (4); i = 0; adminprops[i].name = CORBA::string_dup(CosNotification::MaxQueueLength); adminprops[i++].value <<= (CORBA::Long) 1234; adminprops[i].name = CORBA::string_dup(CosNotification::MaxConsumers); adminprops[i++].value <<= (CORBA::Long) 1000; adminprops[i].name = CORBA::string_dup(CosNotification::MaxSuppliers); adminprops[i++].value <<= (CORBA::Long) 1000; adminprops[i].name = CORBA::string_dup(CosNotification::RejectNewEvents); adminprops[i++].value <<= CORBA::Any::from_boolean(1); ec_ = this->ecf_->create_channel ( qosprops, adminprops, this->ec_id_); ok = ! CORBA::is_nil (ec_.in ()); if (ok && this->verbose_) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Supplier: Create event channel %d\n"), static_cast<int> (this->ec_id_) )); } } // save channel id if (ok && this->channel_file_.length() > 0) { FILE * chf = ACE_OS::fopen (this->channel_file_.c_str (), "w"); if (chf != 0) { ACE_OS::fprintf (chf, "%d\n", static_cast<int> (this->ec_id_)); ACE_OS::fclose (chf); } } }