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
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 ();
}
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 ());
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
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
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
Notify_Push_Consumer::_connect (CosNotifyChannelAdmin::ConsumerAdmin_ptr consumer_admin,
CosNotifyChannelAdmin::EventChannel_ptr)
{
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 ());
// give ownership to POA
this->_remove_ref ();
}
void
Filter_StructuredPushConsumer::connect (CosNotifyChannelAdmin::ConsumerAdmin_ptr consumer_admin)
{
// Activate the consumer with the default_POA_
CosNotifyComm::StructuredPushConsumer_var objref =
this->_this ();
CosNotifyChannelAdmin::ProxySupplier_var proxysupplier =
consumer_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 ()));
proxy_supplier_->connect_structured_push_consumer (objref.in ());
}
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 ();
}
int main(int argc,char *argv [])
{
CORBA::ORB_ptr orb_ptr;
try
{
/************************************************************************/
/* INICIALIZAMOS LA PARTE DEL ORB */
/************************************************************************/
int alt_argc = 0;
char ** alt_argv;
const char * orb_id="Test_TIDNotification";
orb_ptr=CORBA::ORB_init(argc, argv, orb_id);
if (!orb_ptr)
{
cerr<<"El ORB es null"<<endl;
return -1;
}
CORBA::Object_ptr delegado_POA;
PortableServer::POA_ptr rootPOA;
try
{
delegado_POA = orb_ptr->resolve_initial_references("RootPOA");
}
catch ( CORBA::ORB::InvalidName ex )
{
ex._name();
return -1;
}
rootPOA = PortableServer::_POAHelper::narrow( delegado_POA,true );
PortableServer::POAManager_var poa_manager = rootPOA->the_POAManager();
CORBA::PolicyList_var policies = NULL;
policies = new CORBA::PolicyList(2);
policies->length(2);
// Valores cambiados
(*policies)[0] = rootPOA->create_lifespan_policy
( PortableServer::PERSISTENT );
(*policies)[1] = rootPOA->create_id_assignment_policy
( PortableServer::USER_ID );
PortableServer::POA_var consumerPOA = rootPOA->create_POA("consumerPOA", poa_manager, *policies );
/***********************************************************************/
/* OBTENEMOS LA FACTORIA DEL CANAL DE EVENTOS Y CREAMOS EL CANAL */
/**********************************************************************/
CORBA::Object_ptr delegado_event_channel_factory;
delegado_event_channel_factory=orb_ptr->string_to_object(argv[1]);
CosNotifyChannelAdmin::EventChannelFactory_var factory;
factory = CosNotifyChannelAdmin::EventChannelFactory::_narrow(delegado_event_channel_factory);
if (CORBA::is_nil(factory)) {
cerr << "[server] ERROR: factoria nula " << endl;
return -1;
}
CosNotifyChannelAdmin::EventChannel_var channel;
//CosNotifyChannelAdmin::EventChannel_var channelv[10];
CosNotification::QoSProperties initial_qos;
CosNotification::AdminProperties initial_admin;
CosNotifyChannelAdmin::ChannelID id;
//CosNotifyChannelAdmin::ChannelID idv[10];
// // Politicas Soportadas:
// initial_qos.length(9);
// initial_qos[0].name = CORBA::string_dup("OrderPolicy");
// initial_qos[0].value <<= CosNotification::FifoOrder; // Any Fifo Priority Deadline
// initial_qos[1].name = CORBA::string_dup("EventReliability");
// initial_qos[1].value <<= CosNotification::BestEffort; // Persistent
// initial_qos[2].name = CORBA::string_dup("ConnectionReliability");
// initial_qos[2].value <<= CosNotification::BestEffort; // Persistent
// initial_qos[3].name = CORBA::string_dup("Priority");
// initial_qos[3].value <<= CosNotification::HighestPriority; // Highest, Default
// initial_qos[4].name = CORBA::string_dup("StartTime");
// initial_qos[4].value <<= *(new TimeBase::UtcT(
// TIDorb::core::util::Time::currentTimeMillis(),
// 0,0,0));
// initial_qos[5].name = CORBA::string_dup("StopTime");
// initial_qos[5].value <<= *(new TimeBase::UtcT(
// TIDorb::core::util::Time::currentTimeMillis(),
// 0,0,0));
// initial_qos[6].name = CORBA::string_dup("Timeout");
// initial_qos[6].value <<= (TimeBase::TimeT)TIDorb::core::util::Time::currentTimeMillis();
// initial_qos[7].name = CORBA::string_dup("StartTimeSupported");
// initial_qos[7].value <<= (CORBA::Boolean) 0;
// initial_qos[8].name = CORBA::string_dup("StopTimeSupported");
// initial_qos[8].value <<= (CORBA::Boolean) 1;
//
// Politicas de QoS no soportadas
//
// initial_qos[0].name = CORBA::string_dup("DiscardPolicy");
// initial_qos[0].value <<= CosNotification::AnyOrder; // Any Fifo Priority Deadline
// initial_qos[7].name = CORBA::string_dup("MaximumBatchSize");
// initial_qos[7].value <<= (CORBA::Long) 20;
// initial_qos[0].name = CORBA::string_dup("PacingInterval");
// initial_qos[0].value <<= (TimeBase::TimeT)TIDorb::core::util::Time::currentTimeMillis();
// initial_qos[9].name = CORBA::string_dup("MaxEventsPerConsumer");
// initial_qos[9].value <<= (CORBA::Long) 20;
try {
// Crear el canal
channel = factory->get_event_channel(0);
// for(int i=0; i < 10; i++){
// channelv[i] = factory->create_channel(initial_qos, initial_admin, idv[i]);
// }
} catch (CosNotifyChannelAdmin::ChannelNotFound &ex) {
cerr << "[server_consumer] CosNotifyChannelAdmin::ChannelNotFound: " << ex._name();
return -1;
}
/**************************************************************************/
/* OBTENEMOS EL CONSUMERADMIN POR DEFECTO */
/**************************************************************************/
CosNotifyChannelAdmin::ConsumerAdmin_ptr consumerAdmin;
consumerAdmin = channel->default_consumer_admin();
//Metemos los filtros en el consumer admin
CosNotifyFilter::Filter* filter_II = create_filter(channel,"GSyC","test","$domain_name != 'GSyC'");
//consumerAdmin->add_filter(filter_II);
//CosNotifyFilter::Filter* filter_III = create_filter(channel,"GSyC","test","$.remainder_of_boy.campo_uno != 1");
//consumerAdmin->add_filter(filter_III);
/**************************************************************************/
/* OBTENEMOS EL PROXYSUPPLIER APARTIR DEL CONSUMERADMIN */
/**************************************************************************/
//TODO_MORFEO: add new filters
CosNotifyChannelAdmin::ProxySupplier_ptr proxySupplier;
CosNotifyChannelAdmin::ProxyID proxySupplierID = 1;
proxySupplier =
consumerAdmin->obtain_notification_push_supplier(CosNotifyChannelAdmin::ANY_EVENT,
proxySupplierID);
/**************************************************************************/
/* OBTENEMOS EL PROXYPUSHSUPPLIER APARTIR DEL CONSUMERADMIN */
/**************************************************************************/
CosNotifyChannelAdmin::StructuredProxyPushSupplier_ptr proxyPushSupplier;
proxyPushSupplier = CosNotifyChannelAdmin::StructuredProxyPushSupplier::_narrow(proxySupplier);
/**************************************************************************/
/* INSTANCIAMOS LOS PROXYS Y LOS ACTIVAMOS EN EL POA */
/**************************************************************************/
my_push_consumer * my_consumer = new my_push_consumer(orb_ptr,proxyPushSupplier);
PortableServer::ObjectId_ptr consumer_objectID = PortableServer::string_to_ObjectId("My_Consumer:1.0");
consumerPOA->activate_object_with_id(*consumer_objectID,my_consumer);
poa_manager->activate();
CORBA::Object_ptr obj_consumer = consumerPOA->id_to_reference(*consumer_objectID);
CosNotifyComm::StructuredPushConsumer_ptr my_pushConsumer = CosNotifyComm::StructuredPushConsumer::_narrow(obj_consumer);
/***********************************************************************/
/* CONECTAMOS EL PUSHSUPPLIER Y EL PUSHCONSUMER */
/***********************************************************************/
proxyPushSupplier->connect_structured_push_consumer(my_pushConsumer);
orb_ptr->run();
}
catch (CORBA::Exception & e)
{
cerr<<"[Test_Filter] unknown error"<< typeid(e).name() << e._name();
return -1;
}
}