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_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
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 ();
}
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;
}
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
{
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[])
{
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 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();
}
}
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;
}
