CosNotifyFilter::FilterID ExtendedFilter::add_filter (CosNotifyFilter::FilterAdmin_ptr filter_admin) { // setup a filter at the filter admin CosNotifyFilter::Filter_var filter = this->ffact_->create_filter ("ETCL"); ACE_ASSERT (!CORBA::is_nil (filter.in ())); const char* test_filter_string = "A > B"; CosNotifyFilter::ConstraintExpSeq constraint_list (1); constraint_list.length (1); constraint_list[0].event_types.length (0); constraint_list[0].constraint_expr = CORBA::string_dup (test_filter_string); filter->add_constraints (constraint_list); CosNotifyFilter::FilterID id = filter_admin->add_filter (filter.in ()); // Print the ID if (TAO_debug_level) ACE_DEBUG ((LM_DEBUG, "Added Filter %d\n", id)); return id; }
void Consumer::setAntennaName(std::string antennaName) { //If the antenna name is already set, do nothing if (this->antennaName.compare("") != 0) return; this->antennaName = antennaName; if (antennaName.compare("") != 0) { std::cout << "Adding filter" << std::endl; CosNotifyFilter::FilterFactory_var filter_factory = notifyChannel_m->default_filter_factory(); CosNotifyFilter::Filter_var filter = filter_factory->create_filter( "ETCL"); if (CORBA::is_nil(filter)) { ACS_SHORT_LOG( (LM_ERROR,"Consumer::createConsumer failed for the '%s' channel due the filter cannot be created!", channelName_mp)); } CosNotifyFilter::ConstraintExpSeq constraint_list; constraint_list.length(1); constraint_list[0].event_types.length(0); std::string filter_expr = "$antenna_name == '" + antennaName + "'"; std::cout << filter_expr << std::endl; constraint_list[0].constraint_expr = CORBA::string_dup( filter_expr.c_str()); filter->add_constraints(constraint_list); proxySupplier_m->add_filter(filter.in()); } }
static CosNotifyChannelAdmin::ConsumerAdmin_ptr create_consumeradmin (CosNotifyChannelAdmin::EventChannel_ptr ec) { CosNotifyChannelAdmin::AdminID adminid = 0; CosNotifyChannelAdmin::ConsumerAdmin_var admin = ec->new_for_consumers (CosNotifyChannelAdmin::AND_OP, adminid); if (filter) { ACE_DEBUG((LM_DEBUG, "\nConsumer filter enabled.\n")); CosNotifyFilter::FilterFactory_var ffact = ec->default_filter_factory (); CosNotifyFilter::Filter_var filter = ffact->create_filter (GRAMMAR); CosNotifyFilter::ConstraintExpSeq constraint_list (1); constraint_list.length (1); constraint_list[0].event_types.length (0); constraint_list[0].constraint_expr = CORBA::string_dup ("type == 'even'"); filter->add_constraints (constraint_list); admin->add_filter (filter.in ()); } return CosNotifyChannelAdmin::ConsumerAdmin::_duplicate (admin.in ()); }
void TAO_Notify_Tests_Filter_Command::handle_destroy_filter (void) { CosNotifyFilter::Filter_var filter; LOOKUP_MANAGER->resolve (filter, this->name_.c_str ()); filter->destroy (); }
::CosNotifyFilter::Filter_ptr TAO::FT_FaultNotifier_i::create_subscription_filter ( const char * constraint_grammar ) { METHOD_ENTRY(TAO::FT_FaultNotifier_i::create_subscription_filter); ACE_UNUSED_ARG (constraint_grammar); //@@todo CosNotifyFilter::Filter_var filter = this->filter_factory_->create_filter ("ETCL"); METHOD_RETURN(TAO::FT_FaultNotifier_i::create_subscription_filter) filter._retn (); }
void TAO_Notify_Tests_Filter_Command::handle_create_filter (void) { CosNotifyFilter::FilterFactory_var ff; LOOKUP_MANAGER->resolve (ff , this->factory_.c_str ()); CosNotifyFilter::Filter_var filter = ff->create_filter ("ETCL"); LOOKUP_MANAGER->_register (filter.in(), this->name_.c_str ()); }
void TAO_Notify_Tests_Filter_Command::handle_add_filter (void) { CosNotifyFilter::Filter_var filter; LOOKUP_MANAGER->resolve (filter , this->name_.c_str ()); CosNotifyFilter::FilterAdmin_var filter_admin; LOOKUP_MANAGER->resolve (filter_admin , this->factory_.c_str ()); filter_admin->add_filter (filter.in ()); }
/** * register this object */ int StubBatchConsumer::init (CORBA::ORB_ptr orb, ::FT::FaultNotifier_var & notifier) { int result = 0; this->orb_ = CORBA::ORB::_duplicate (orb); this->notifier_ = notifier; this->identity_ = "StubBatchConsumer"; // Use the ROOT POA for now CORBA::Object_var poa_object = this->orb_->resolve_initial_references (TAO_OBJID_ROOTPOA); if (CORBA::is_nil (poa_object.in ())) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT (" (%P|%t) Unable to initialize the POA.\n")), -1); // Get the POA . this->poa_ = PortableServer::POA::_narrow (poa_object.in ()); if (CORBA::is_nil(this->poa_.in ())) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT (" (%P|%t) Unable to narrow the POA.\n")), -1); } PortableServer::POAManager_var poa_manager = this->poa_->the_POAManager (); poa_manager->activate (); // Register with the POA. this->object_id_ = this->poa_->activate_object (this); // find my identity as an object CORBA::Object_var this_obj = this->poa_->id_to_reference (object_id_.in ()); CosNotifyFilter::Filter_var filter = CosNotifyFilter::Filter::_nil(); this->consumer_id_ = notifier->connect_sequence_fault_consumer( CosNotifyComm::SequencePushConsumer::_narrow(this_obj.in ()), filter.in ()); return result; }
void TAO_Notify_Tests_Filter_Command::handle_add_constraint (void) { CosNotifyFilter::Filter_var filter; LOOKUP_MANAGER->resolve (filter , this->name_.c_str ()); CosNotifyFilter::ConstraintExpSeq constraint_list (1); constraint_list.length (1); constraint_list[0].event_types.length (0); constraint_list[0].constraint_expr = CORBA::string_dup (this->constraint_.c_str ()); ACE_DEBUG ((LM_DEBUG, "Adding constraint %s\n", this->constraint_.c_str ())); filter->add_constraints (constraint_list); }
void match_structure_test (const CosNotifyFilter::Filter_var& filter, const CosNotification::StructuredEvent& event, bool & expected_result) { bool bResult = false; try{ bResult = filter->match_structured(event); } catch(CosNotifyFilter::UnsupportedFilterableData) { std::cerr << "UnsupportedFilterableData!" << std::endl; } catch (CORBA::SystemException& se ) { std::cerr << "System exception occurred during match_structured: " << se << std::endl; exit(1); } std::cout << "The result is:" << (bResult?"Match":"Unmatch") << std::endl; if (bResult != expected_result) { // The result should be unmatched as it's filtered with event type. std::cerr << "filter test failed." << std::endl; exit(1); } }
void Notify_Push_Supplier::_connect ( CosNotifyChannelAdmin::SupplierAdmin_ptr supplier_admin, CosNotifyChannelAdmin::EventChannel_ptr notify_channel, bool useFilter) { CosNotifyComm::StructuredPushSupplier_var objref = this->_this (); CosNotifyChannelAdmin::ProxyConsumer_var proxyconsumer = supplier_admin->obtain_notification_push_consumer ( CosNotifyChannelAdmin::STRUCTURED_EVENT, proxy_id_); if (useFilter) { CosNotifyFilter::FilterFactory_var ffact = notify_channel->default_filter_factory (); CosNotifyFilter::Filter_var filter = ffact->create_filter ("TCL"); ACE_ASSERT(! CORBA::is_nil (filter.in ())); CosNotifyFilter::ConstraintExpSeq constraint_list (1); constraint_list.length (1); constraint_list[0].event_types.length (0); constraint_list[0].constraint_expr = CORBA::string_dup ("group != 0"); filter->add_constraints (constraint_list); proxyconsumer->add_filter (filter.in ()); } this->proxy_ = CosNotifyChannelAdmin::StructuredProxyPushConsumer::_narrow ( proxyconsumer.in ()); this->proxy_->connect_structured_push_supplier (objref.in ()); // give ownership to POA this->_remove_ref (); }
TAO_Notify::Topology_Object* TAO_Notify_FilterAdmin::load_child (const ACE_CString &type, CORBA::Long id, const TAO_Notify::NVPList& attrs) { if (type == "filter") { TAO_Notify_Object::ID mapid = 0; attrs.load("MapId", mapid); TAO_Notify_FilterFactory* factory = ec_->default_filter_factory_servant (); CosNotifyFilter::Filter_var filter = factory->get_filter (mapid); if (! CORBA::is_nil(filter.in())) { this->filter_ids_.set_last_used(id); if (this->filter_list_.bind (id, filter) != 0) throw CORBA::INTERNAL (); } } return this; }
void update_constraints (const CosNotifyFilter::Filter_var& filter, const char* domain1, const char* type1, const char* domain2, const char* type2) { filter->remove_all_constraints (); CosNotification::EventTypeSeq event_types(2); event_types.length(2); event_types[0].domain_name = CORBA::string_dup(domain1); event_types[0].type_name = CORBA::string_dup(type1); event_types[1].domain_name = CORBA::string_dup(domain2); event_types[1].type_name = CORBA::string_dup(type2); CosNotifyFilter::ConstraintExpSeq constraints(1); constraints.length(1); constraints[0].event_types = event_types; constraints[0].constraint_expr = CORBA::string_dup(""); CosNotifyFilter::ConstraintInfoSeq_var cons_info = filter->add_constraints(constraints); std::cout << "Constructing a filter..." << std::endl; for (CORBA::ULong i = 0; i < event_types.length(); ++i) { std::cout << "\tevent_types[" << i << "].domain_name=" << event_types[i].domain_name << std::endl; std::cout << "\tevent_types[" << i << "].type_name=" << event_types[i].type_name << std::endl; } std::cout << "\t**s constraint =" << constraints[0].constraint_expr.in () << std::endl; }
CosNotifyFilter::Filter_ptr TAO_Notify_ETCL_FilterFactory::find_filter (const TAO_Notify_Object::ID& id) { ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->mtx_, CosNotifyFilter::Filter::_nil ()); TAO_Notify_ETCL_Filter* filter = 0; if (filters_.find (id, filter) == -1) return CosNotifyFilter::Filter::_nil (); else { CORBA::Object_var obj = this->filter_poa_->servant_to_reference (filter); CosNotifyFilter::Filter_var filter = CosNotifyFilter::Filter::_narrow (obj.in ()); return filter._retn (); } }
static CosNotifyFilter::Filter_ptr create_proxyFilter (CosNotifyChannelAdmin::EventChannel_ptr ec) { CosNotifyFilter::FilterFactory_var ffact = ec->default_filter_factory (); CosNotifyFilter::Filter_var filter = ffact->create_filter ("EXTENDED_TCL"); if(!CORBA::is_nil(filter.in())) { CosNotifyFilter::ConstraintExpSeq constraint_list (1); constraint_list.length(1); constraint_list[0].event_types.length (0); constraint_list[0].constraint_expr = CORBA::string_dup ("$.domain_name == 'domain1'"); filter->add_constraints (constraint_list); } return filter._retn(); }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { try { Consumer_Client client; int status = client.init (argc, argv); ACE_ASSERT(status == 0); ACE_UNUSED_ARG(status); CosNotifyChannelAdmin::EventChannel_var ec = client.create_event_channel ("MyEventChannel", 1); CORBA::ORB_ptr orb = client.orb (); CORBA::Object_var object = orb->string_to_object (ior); sig_var sig = sig::_narrow (object.in ()); ACE_ASSERT(! CORBA::is_nil (sig.in ())); CosNotifyChannelAdmin::ConsumerAdmin_var admin = create_consumeradmin (ec.in ()); if (filter) { CosNotifyFilter::FilterFactory_var ffact = ec->default_filter_factory (); CosNotifyFilter::Filter_var filter = ffact->create_filter ("TCL"); ACE_ASSERT(! CORBA::is_nil(filter.in())); CosNotifyFilter::ConstraintExpSeq constraint_list (1); constraint_list.length(1); constraint_list[0].event_types.length (0); constraint_list[0].constraint_expr = CORBA::string_dup(ACE_TEXT_ALWAYS_CHAR (constraintString)); filter->add_constraints (constraint_list); admin->add_filter(filter.in()); } ACE_ASSERT (!CORBA::is_nil (admin.in ())); create_consumers(admin.in (), &client); // Tell the supplier to go sig->go (); client.ORB_run( ); ACE_DEBUG((LM_DEBUG, "Consumer done.\n")); sig->done (); return 0; } catch (const CORBA::Exception& e) { e._tao_print_exception ("Error: Consumer exception: "); } return 1; }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { try { Consumer_Client client; int status = client.init (argc, argv); if (status != 0) { ACE_ERROR((LM_ERROR, "Error: Unable to init consumer.\n")); return 1; } CosNotifyChannelAdmin::EventChannel_var ec = client.create_event_channel ("Struct_Multi_Filter", 1); CosNotifyChannelAdmin::AdminID adminid = 0; CosNotifyChannelAdmin::ConsumerAdmin_var consumer_admin = ec->new_for_consumers ((consumerFilter == OrOp ? CosNotifyChannelAdmin::OR_OP : CosNotifyChannelAdmin::AND_OP), adminid); ACE_ASSERT(! CORBA::is_nil (consumer_admin.in ())); if (consumerFilter != None) { CosNotifyFilter::FilterFactory_var ffact = ec->default_filter_factory (); CosNotifyFilter::Filter_var filter = ffact->create_filter (GRAMMAR); if (CORBA::is_nil (filter.in ())) { ACE_ERROR ((LM_ERROR, " (%P|%t) Consumer unable to initialize filter.\n")); return 1; } CosNotifyFilter::ConstraintExpSeq constraint_list (1); constraint_list.length (1); constraint_list[0].event_types.length (0); constraint_list[0].constraint_expr = CORBA::string_dup ("type != 1"); filter->add_constraints (constraint_list); consumer_admin->add_filter (filter.in ()); } CORBA::ORB_ptr orb = client.orb (); CORBA::Object_var object = orb->string_to_object (ior); sig_var sig = sig::_narrow (object.in ()); ACE_ASSERT(! CORBA::is_nil (sig.in ())); create_consumer (consumer_admin.in (), ec.in (), &client); ACE_DEBUG((LM_DEBUG, "\nConsumer waiting for events...\n")); sig->go (); client.ORB_run( ); ACE_DEBUG((LM_DEBUG, "\nConsumer done.\n")); sig->done(); return 0; } catch (const CORBA::Exception& e) { e._tao_print_exception ("\nError: Consumer:"); } return 1; }
//----------------------------------------------------------------------------- int Consumer::addFilter(const char* type_name, const char* filterString) { ACS_TRACE("Consumer::addFilter"); try { //Create a temporary filter factory CosNotifyFilter::FilterFactory_var filterFactory = notifyChannel_m->default_filter_factory(); if(CORBA::is_nil(filterFactory.in()) == true) { CORBAProblemExImpl err = CORBAProblemExImpl(__FILE__,__LINE__,"nc::Consumer::addFilter"); throw err.getCORBAProblemEx(); } //Create a filter CosNotifyFilter::Filter_var filter = 0; filter = filterFactory->create_filter(getFilterLanguage()); if(filter.in() == 0) { CORBAProblemExImpl err = CORBAProblemExImpl(__FILE__,__LINE__,"nc::Consumer::addFilter"); throw err.getCORBAProblemEx(); } //Create the constraint expression sequence CosNotifyFilter::ConstraintExpSeq cexp(1); cexp.length(1); cexp[0].event_types.length(1); cexp[0].event_types[0].domain_name = getChannelDomain(); cexp[0].event_types[0].type_name = CORBA::string_dup(type_name); cexp[0].constraint_expr = CORBA::string_dup(filterString); try { filter->add_constraints(cexp); } catch(CosNotifyFilter::InvalidConstraint e) { if (filter.in() != 0) { filter->destroy(); filter = 0; } ACS_SHORT_LOG((LM_ERROR,"Consumer::addFilter failed for the '%s' channel, '%s' event type, and '%s' filter!", channelName_mp, type_name, filterString)); CORBAProblemExImpl err = CORBAProblemExImpl(__FILE__,__LINE__,"nc::Consumer::addFilter"); throw err.getCORBAProblemEx(); } return proxySupplier_m->add_filter(filter._retn()); } catch(CORBAProblemEx) { ACS_SHORT_LOG((LM_TRACE,"Consumer::addFilter failed for the '%s' channel, '%s' event type, and '%s' filter with a nil pointer!", channelName_mp, type_name, filterString)); throw; } catch(...) { ACS_SHORT_LOG((LM_ERROR,"Consumer::addFilter failed for the '%s' channel, '%s' event type, and '%s' filter!", channelName_mp, type_name, filterString)); CORBAProblemExImpl err = CORBAProblemExImpl(__FILE__,__LINE__,"nc::Consumer::addFilter"); throw err.getCORBAProblemEx(); } }
void ExtendedFilter::run_filter_test (CosNotifyFilter::FilterAdmin_ptr filter_admin) { if (TAO_debug_level) ACE_DEBUG ((LM_DEBUG, "Narrowing CosNotifyFilterExt::FilterFactory\n")); CosNotifyFilterExt::FilterFactory_var extffact = CosNotifyFilterExt::FilterFactory::_narrow(ffact_.in()); ACE_ASSERT (!CORBA::is_nil (extffact.in ())); if (TAO_debug_level) ACE_DEBUG ((LM_DEBUG, "Getting ec2 FilterFactory\n")); CosNotifyFilter::FilterFactory_var ffact2 = ec2_->default_filter_factory (); if (TAO_debug_level) ACE_DEBUG ((LM_DEBUG, "Narrowing CosNotifyFilterExt::FilterFactory\n")); CosNotifyFilterExt::FilterFactory_var extffact2 = CosNotifyFilterExt::FilterFactory::_narrow(ffact2.in()); ACE_ASSERT (!CORBA::is_nil (extffact2.in ())); if (TAO_debug_level) ACE_DEBUG ((LM_DEBUG, "Adding a filter\n")); CosNotifyFilter::FilterID id_1 = this->add_filter (filter_admin); this->verify_filter_count (filter_admin, 1); if (TAO_debug_level) { ACE_DEBUG ((LM_DEBUG, "Calling print_filters\n")); this->print_filters (filter_admin); } if (TAO_debug_level) ACE_DEBUG ((LM_DEBUG, "Calling CosNotifyFilterExt::FilterFactory::get_filter\n")); CosNotifyFilter::Filter_var filter = extffact->get_filter (id_1); ACE_ASSERT (!CORBA::is_nil (filter.in ())); if (TAO_debug_level) ACE_DEBUG ((LM_DEBUG, "Calling CosNotifyFilterExt::FilterFactory::get_filterid\n")); CosNotifyFilter::FilterID id_dup = extffact->get_filterid (filter.in()); ACE_ASSERT (id_dup == id_1); #if defined (ACE_NDEBUG) ACE_UNUSED_ARG (id_dup ); #endif if (TAO_debug_level) ACE_DEBUG ((LM_DEBUG, "Calling CosNotifyFilterExt::FilterFactory::get_filterid of non existent filter\n")); bool id_lookup_failed = false; try { CosNotifyFilter::FilterID id_ne = extffact2->get_filterid (filter.in()); ACE_UNUSED_ARG (id_ne ); } catch (const CORBA::INTERNAL& ) { id_lookup_failed = true; } ACE_ASSERT (id_lookup_failed ); #if defined (ACE_NDEBUG) ACE_UNUSED_ARG (id_lookup_failed ); #endif if (TAO_debug_level) ACE_DEBUG ((LM_DEBUG, "Calling remove_filter\n")); // remove the filter. filter_admin->remove_filter (id_1); this->verify_filter_count (filter_admin, 0); if (TAO_debug_level) { ACE_DEBUG ((LM_DEBUG, "Calling print_filters\n")); this->print_filters (filter_admin); } if (TAO_debug_level) ACE_DEBUG ((LM_DEBUG, "Calling remove_all_filters\n")); filter_admin->remove_all_filters (); if (TAO_debug_level) { ACE_DEBUG ((LM_DEBUG, "Calling print_filters\n")); this->print_filters (filter_admin); } // Make sure all filters are removed - this->verify_filter_count (filter_admin, 0); if (TAO_debug_level) ACE_DEBUG ((LM_DEBUG, "Calling CosNotifyFilterExt::FilterFactory::remove_filter\n")); extffact->remove_filter(filter.in()); filter = CosNotifyFilter::Filter::_nil (); if (TAO_debug_level) ACE_DEBUG ((LM_DEBUG, "Calling CosNotifyFilterExt::FilterFactory::get_filter of removed filter\n")); filter = extffact->get_filter (id_1); ACE_ASSERT (CORBA::is_nil (filter.in ())); ACE_DEBUG ((LM_DEBUG, "ExtendedFilters test has run successfully\n")); }
void FilterClient::verify_filter (CosNotifyFilter::FilterAdmin_var& admin, const char* constraint_expr, const char* mod_constraint_expr) { ACE_UNUSED_ARG (constraint_expr); // only used to validate assert, which is // compiled out for nondebug builds. const CosNotifyFilter::FilterIDSeq_var ids = admin->get_all_filters (); ACE_ASSERT (ids->length () == 1); CosNotifyFilter::Filter_var filter = admin->get_filter (ids[0]); ACE_ASSERT (! CORBA::is_nil (filter.in ())); CosNotifyFilter::ConstraintInfoSeq_var infos = filter->get_all_constraints(); ACE_ASSERT (infos->length () == 2); u_int index = 0; for (index = 0; index < infos->length (); ++ index) { CosNotifyFilter::ConstraintID id = infos[index].constraint_id; ACE_UNUSED_ARG (id); // only used to validate assert, which is // compiled out for nondebug builds. ACE_ASSERT (id != 0); ACE_ASSERT (ACE_OS::strcmp (infos[index].constraint_expression.constraint_expr.in (), constraint_expr) == 0); CosNotification::EventTypeSeq& events = infos[index].constraint_expression.event_types; ACE_UNUSED_ARG (events); // only used to validate assert, which is // compiled out for nondebug builds. ACE_ASSERT (events.length () == 1); ACE_ASSERT (ACE_OS::strcmp (events[0].domain_name.in (), DOMAIN_NAME) == 0); ACE_ASSERT (ACE_OS::strcmp (events[0].type_name.in (), TYPE_NAME) == 0); } if (modify_constraint_) { CosNotifyFilter::ConstraintIDSeq_var ids = new CosNotifyFilter::ConstraintIDSeq (2); ids->length (2); for (index = 0; index < infos->length (); ++ index) { ids[index] = infos[index].constraint_id; ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t)modify constraint %d \n"), ids[index])); infos[index].constraint_expression.constraint_expr = CORBA::string_dup (mod_constraint_expr); } filter->modify_constraints (ids.in (), infos.in()); } }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { try { PortableServer::POAManager_var poa_manager; CORBA::ORB_var orb = CORBA::ORB_init(argc, argv); CORBA::Object_var poa_obj = orb->resolve_initial_references("RootPOA"); PortableServer::POA_var root_poa = PortableServer::POA::_narrow(poa_obj.in()); poa_manager = root_poa->the_POAManager(); if (parse_args (argc, argv) != 0) return 1; poa_manager->activate(); /*Get event_channel*/ std::cout << "Get event_channel now" << std::endl; CosNotifyChannelAdmin::EventChannel_var ec = get_event_channel(orb.in()); //Instanciating the Consumer CosNotifyComm::StructuredPushConsumer_var spc = CosNotifyComm::StructuredPushConsumer::_nil(); CosNotifyCommImpl::StructuredPushConsumer *pImpl_spc = new CosNotifyCommImpl::StructuredPushConsumer; spc = pImpl_spc->_this(); //Obtain a Consumer Admin CosNotifyChannelAdmin::AdminID adminid = 0; CosNotifyChannelAdmin::ConsumerAdmin_var ca = ec->new_for_consumers (CosNotifyChannelAdmin::AND_OP, adminid); if( ca.in() == CosNotifyChannelAdmin::ConsumerAdmin::_nil() ){ std::cerr << "ca is nil!" << std::endl; return 1; } //Obtain a Proxy Consumer CosNotifyChannelAdmin::ProxyID proxy_id; CosNotifyChannelAdmin::ClientType ctype = CosNotifyChannelAdmin::STRUCTURED_EVENT; CosNotifyChannelAdmin::ProxySupplier_var proxySupplier_obj; try { proxySupplier_obj = ca->obtain_notification_push_supplier(ctype, proxy_id); } catch(CosNotifyChannelAdmin::AdminLimitExceeded err) { std::cerr << "CosNotifyChannelAdmin::AdminLimitExceeded Exception!" << std::endl; throw; } CosNotifyChannelAdmin::StructuredProxyPushSupplier_var pps = CosNotifyChannelAdmin::StructuredProxyPushSupplier::_narrow(proxySupplier_obj.in()); //Attaching a filter to pps CosNotifyFilter::FilterFactory_var dff = ec->default_filter_factory(); ACE_ASSERT(!CORBA::is_nil(dff.in())); CosNotifyFilter::Filter_var filter = dff->create_filter("EXTENDED_TCL"); CosNotification::EventTypeSeq event_types(1); event_types.length(2); event_types[0].domain_name = CORBA::string_dup("DomainA"); event_types[0].type_name = CORBA::string_dup("TypeA"); event_types[1].domain_name = CORBA::string_dup("DomainB"); event_types[1].type_name = CORBA::string_dup("TypeB"); CosNotifyFilter::ConstraintExpSeq constraints(1); constraints.length(1); constraints[0].event_types = event_types; constraints[0].constraint_expr = CORBA::string_dup( ""); filter->add_constraints(constraints); pps->add_filter(filter.in()); std::cout << "Attached a filter to ProxyPushSupplier" << std::endl; std::cout << "The filter's event_types[0].domain_name=" << event_types[0].domain_name << std::endl; std::cout << "The filter's event_types[0].type_name=" << event_types[0].type_name << std::endl; std::cout << "The filter's event_types[1].domain_name=" << event_types[1].domain_name << std::endl; std::cout << "The filter's event_types[1].type_name=" << event_types[1].type_name << std::endl; //Connecting a Supplier to a Proxy Consumer try { pps->connect_structured_push_consumer(spc.in()); } catch (CosEventChannelAdmin::AlreadyConnected ac) { std::cerr << "CosEventChannelAdmin::AlreadyConnected" << std::endl; throw; } catch (const CORBA::SystemException& se) { std::cerr << "System exception occurred during connect: " << se << std::endl; throw; } ACE_Time_Value tv (runtime); orb->run (tv); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Consumer done.\n"))); if (pImpl_spc->received_events ()) { //Consumer should not receive any events as it's filtered with event type. std::cerr << "Test failed - received test events." << std::endl; return 1; } else { std::cerr << "Test passed - did not receive test events as expected." << std::endl; } } catch(...) { std::cerr << "Consumer: Some exceptions was caught!" << std::endl; return 1; } return 0; }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { int status = 0; try { Consumer_Client client; status = client.init (argc, argv); if (status == 0) { CosNotifyChannelAdmin::EventChannel_var ec = client.create_event_channel ("MyEventChannel", 1); CORBA::ORB_ptr orb = client.orb (); CORBA::Object_var object = orb->string_to_object (ior); sig_var sig = sig::_narrow (object.in ()); if (CORBA::is_nil (sig.in ())) { ACE_ERROR_RETURN ((LM_ERROR, "Object reference <%s> is nil\n", ior), 1); } CosNotifyChannelAdmin::ConsumerAdmin_var admin = ec->default_consumer_admin(); CosNotifyFilter::Filter_var filter = create_proxyFilter (ec.in()); if (!CORBA::is_nil (admin.in ())) { create_consumers (admin.in (), &client, filter.in()); // Tell the supplier to go sig->go (); ACE_Time_Value tv(10, 0); client.ORB_run(tv); ACE_DEBUG((LM_DEBUG, "Consumer done.\n")); sig->done (); ACE_DEBUG((LM_DEBUG, "Expected %d message(s) and received %d message(s).\n", expect_fail == 1 ? 0 : 1, consumer_1->messages_received())); if (1 == expect_fail) status = consumer_1->messages_received() == 0 ? 0 : 1; else status = consumer_1->messages_received() == 1 ? 0 : 1; ACE_DEBUG((LM_DEBUG, "Test status is %s.\n", status == 1 ? "fail" : "pass")); } } } catch (const CORBA::Exception& e) { e._tao_print_exception ("Error: Consumer exception: "); status = 1; } return status; }