void
TAO_Notify_Tests_Filter_Command::handle_create_filter_factory (void)
{
CosNotifyChannelAdmin::EventChannel_var ec;
LOOKUP_MANAGER->resolve (ec, this->factory_.c_str ());
CosNotifyFilter::FilterFactory_var ff =
ec->default_filter_factory ();
LOOKUP_MANAGER->_register (ff.in(), this->name_.c_str ());
}
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 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
{
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();
poa_manager->activate();
/*Get event_channel*/
std::cout << "Get event_channel now" << std::endl;
CosNotifyChannelAdmin::EventChannel_var ec = get_event_channel(orb.in());
//Attaching a filter to pps
CosNotifyFilter::FilterFactory_var dff =
ec->default_filter_factory();
ACE_ASSERT(!CORBA::is_nil(dff.in()));
std::cout << "Test CosNotifyFilter::Filter::match_structured" << std::endl;
//Constructing a test event
CosNotification::StructuredEvent event;
event.header.fixed_header.event_type.domain_name =
CORBA::string_dup("Test_domain");
event.header.fixed_header.event_type.type_name =
CORBA::string_dup("Test_type_name");
event.header.variable_header.length(0);
event.remainder_of_body <<= "";
std::cout << "Constructing a test event" << std::endl;
std::cout << "\t**s header.fixed_header.event_type.domain_name="
<< event.header.fixed_header.event_type.domain_name
<< std::endl;
std::cout << "\t**s header.fixed_header.event_type.type_name="
<< event.header.fixed_header.event_type.type_name
<< std::endl;
CosNotifyFilter::Filter_var filter = dff->create_filter("EXTENDED_TCL");
update_constraints (filter, "DomainA", "TypeA", "DomainB", "TypeB");
bool expected_result = false;
match_structure_test (filter, event, expected_result);
update_constraints (filter, "*", "%ALL", "DomainB", "TypeB");
expected_result = true;
match_structure_test (filter, event, expected_result);
update_constraints (filter, "Test_domain", "%ALL", "DomainB", "TypeB");
expected_result = true;
match_structure_test (filter, event, expected_result);
update_constraints (filter, "*", "Test_type_name", "DomainB", "TypeB");
expected_result = true;
match_structure_test (filter, event, expected_result);
update_constraints (filter, "*", "*", "*", "*");
expected_result = true;
match_structure_test (filter, event, expected_result);
orb->shutdown();
}
catch(...)
{
std::cerr << "Filter: Some exceptions was caught!" << std::endl;
exit(1);
}
return 0;
}
