TAO/orbsvcs/tests/Notify/Basic/Events.cpp

   1 #include "ace/Arg_Shifter.h"
   2 #include "ace/Get_Opt.h"
   3 #include "tao/debug.h"
   4 #include "Events.h"
   5
   6
   7
   8 /***************************************************************************/
   9
  10 Event_StructuredPushConsumer::Event_StructuredPushConsumer (Events *test_client)
  11   : test_client_ (test_client)
  12 {
  13 }
  14
  15 void
  16 Event_StructuredPushConsumer::push_structured_event (
  17     const CosNotification::StructuredEvent & notification
  18   )
  19 {
  20   int event_num;
  21   notification.filterable_data[0].value >>= event_num;
  22
  23   if (TAO_debug_level)
  24     ACE_DEBUG ((LM_DEBUG,
  25                 "Received event# %d\n",
  26                 event_num));
  27
  28   this->test_client_->on_event_received ();
  29 }
  30
  31 /***************************************************************************/
  32
  33 Event_StructuredPushSupplier::Event_StructuredPushSupplier (
  34     Events* test_client
  35   )
  36   : test_client_ (test_client)
  37 {
  38 }
  39
  40 Event_StructuredPushSupplier::~Event_StructuredPushSupplier (void)
  41 {
  42 }
  43
  44 /***************************************************************************/
  45 Events::Events (void)
  46   : use_default_admin_ (0), event_count_ (5)
  47 {
  48 }
  49
  50 Events::~Events (void)
  51 {
  52 }
  53
  54 int
  55 Events::init (int argc,
  56                    ACE_TCHAR* argv [])
  57 {
  58   // Initialize the base class.
  59   Notify_Test_Client::init (argc,
  60                             argv);
  61
  62   // Create all participents.
  63   this->create_EC ();
  64
  65   CosNotifyChannelAdmin::AdminID adminid;
  66
  67   if (use_default_admin_ == 1)
  68     {
  69       this->supplier_admin_ =
  70         this->ec_->default_supplier_admin ();
  71     }
  72   else
  73     {
  74       this->supplier_admin_ =
  75         this->ec_->new_for_suppliers (this->ifgop_,
  76                                       adminid);
  77     }
  78
  79   ACE_ASSERT (!CORBA::is_nil (supplier_admin_.in ()));
  80
  81   if (use_default_admin_ == 1)
  82     {
  83       this->consumer_admin_ =
  84         this->ec_->default_consumer_admin ();
  85     }
  86   else
  87     {
  88       this->consumer_admin_ =
  89         this->ec_->new_for_consumers (this->ifgop_,
  90                                       adminid);
  91     }
  92
  93   ACE_ASSERT (!CORBA::is_nil (consumer_admin_.in ()));
  94
  95   ACE_NEW_RETURN (this->consumer_,
  96                   Event_StructuredPushConsumer (this),
  97                   -1);
  98   this->consumer_->init (root_poa_.in ());
  99   this->consumer_->connect (this->consumer_admin_.in ());
 100
 101   Event_StructuredPushConsumer* consumer2 = 0;
 102   ACE_NEW_RETURN (consumer2,
 103                   Event_StructuredPushConsumer (this),
 104                   -1);
 105   consumer2->init (root_poa_.in ());
 106   consumer2->connect (this->consumer_admin_.in ());
 107
 108   ACE_NEW_RETURN (this->supplier_,
 109                   Event_StructuredPushSupplier (this),
 110                   -1);
 111   this->supplier_->init (root_poa_.in ());
 112
 113   this->supplier_->connect (this->supplier_admin_.in ());
 114
 115   consumer_start( 0 );
 116
 117   return 0;
 118 }
 119
 120 int
 121 Events::parse_args (int argc,
 122                          ACE_TCHAR *argv[])
 123 {
 124     ACE_Arg_Shifter arg_shifter (argc,
 125                                  argv);
 126     const ACE_TCHAR *current_arg = 0;
 127
 128     while (arg_shifter.is_anything_left ())
 129     {
 130       if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-use_default_admin")) == 0)
 131         {
 132           this->use_default_admin_ = 1;
 133           arg_shifter.consume_arg ();
 134
 135         }
 136       else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-events"))))
 137         {
 138           this->event_count_ = ACE_OS::atoi (current_arg);
 139           // The number of events to send/receive.
 140           arg_shifter.consume_arg ();
 141         }
 142       else if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-?")) == 0)
 143         {
 144           ACE_DEBUG((LM_DEBUG,
 145                      "usage: %s "
 146                      "-use_default_admin "
 147                      "-events event_count\n",
 148                      argv[0], argv[0]));
 149
 150           arg_shifter.consume_arg ();
 151
 152           return -1;
 153         }
 154       else
 155         {
 156           arg_shifter.ignore_arg ();
 157         }
 158     }
 159
 160   return 0;
 161 }
 162
 163 void
 164 Events::create_EC (void)
 165 {
 166   CosNotifyChannelAdmin::ChannelID id;
 167
 168   this->ec_ = notify_factory_->create_channel (this->initial_qos_,
 169                                                this->initial_admin_,
 170                                                id);
 171
 172   /****************************************************************/
 173   /*
 174   CosNotification::AdminProperties admin(2);
 175   admin.length (2);
 176
 177   admin[0].name =
 178     CORBA::string_dup(CosNotification::MaxQueueLength);
 179
 180   admin[0].value <<= (CORBA::Long)5;
 181
 182   admin[1].name =
 183     CORBA::string_dup(CosNotification::MaxConsumers);
 184
 185   admin[1].value <<= (CORBA::Long)2;
 186
 187   ec_->set_admin (admin);
 188   */
 189
 190   /****************************************************************/
 191   ACE_ASSERT (!CORBA::is_nil (this->ec_.in ()));
 192 }
 193
 194 void
 195 Events::on_event_received (void)
 196 {
 197   ++this->result_count_;
 198
 199   if (TAO_debug_level)
 200     ACE_DEBUG ((LM_DEBUG,
 201                 "event count = #%d\n",
 202                 this->result_count_.value ()));
 203
 204   if (this->result_count_ == 2 * this->event_count_)
 205     {
 206       this->end_test ();
 207     }
 208 }
 209
 210 void
 211 Events::run_test (void)
 212 {
 213   // operations:
 214   CosNotification::StructuredEvent event;
 215
 216   // EventHeader.
 217
 218   // FixedEventHeader.
 219   // EventType.
 220   // string.
 221   event.header.fixed_header.event_type.domain_name = CORBA::string_dup("*");
 222   // string
 223   event.header.fixed_header.event_type.type_name = CORBA::string_dup("*");
 224   // string
 225   event.header.fixed_header.event_name = CORBA::string_dup("myevent");
 226
 227   // OptionalHeaderFields.
 228   // PropertySeq.
 229   // sequence<Property>: string name, any value
 230   CosNotification::PropertySeq& qos =  event.header.variable_header;
 231   qos.length (1); // put nothing here
 232
 233   // FilterableEventBody
 234   // PropertySeq
 235   // sequence<Property>: string name, any value
 236   event.filterable_data.length (3);
 237   event.filterable_data[0].name = CORBA::string_dup("threshold");
 238
 239   event.filterable_data[1].name = CORBA::string_dup("temperature");
 240   event.filterable_data[1].value <<= (CORBA::Long)70;
 241
 242   event.filterable_data[2].name = CORBA::string_dup("pressure");
 243   event.filterable_data[2].value <<= (CORBA::Long)80;
 244
 245   CORBA::Short prio = CosNotification::LowestPriority;
 246
 247   for (int i = 0; i < this->event_count_; ++i)
 248     {
 249       event.filterable_data[0].value <<= (CORBA::Long)i;
 250
 251       // any
 252       event.remainder_of_body <<= (CORBA::Long)i;
 253
 254       qos[0].name = CORBA::string_dup (CosNotification::Priority);
 255       qos[0].value <<= (CORBA::Short)prio++;
 256
 257       this->supplier_->send_event (event);
 258     }
 259 }
 260
 261 void
 262 Events::end_test (void)
 263 {
 264   consumer_done( 0 );
 265 }
 266
 267 int
 268 Events::check_results (void)
 269 {
 270   // Destroy the channel.
 271   this->ec_->destroy ();
 272
 273   if (this->result_count_ == 2 * this->event_count_)
 274     {
 275       ACE_DEBUG ((LM_DEBUG,
 276                   "Events test success\n"));
 277       return 0;
 278     }
 279   else
 280     {
 281       ACE_DEBUG ((LM_DEBUG,
 282                   "Events test failed!\n"));
 283       return 1;
 284     }
 285 }
 286
 287 /***************************************************************************/
 288
 289 int
 290 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
 291 {
 292   Events events;
 293
 294   if (events.parse_args (argc, argv) == -1)
 295     {
 296       return 1;
 297     }
 298
 299   try
 300     {
 301       events.init (argc,
 302                    argv);
 303
 304       events.run_test ();
 305
 306       events.ORB_run( );
 307     }
 308   catch (const CORBA::Exception& se)
 309     {
 310       se._tao_print_exception ("Error: ");
 311       return 1;
 312     }
 313
 314   int status = 0;
 315
 316   try
 317     {
 318       status = events.check_results ();
 319     }
 320   catch (const CORBA::Exception& se)
 321     {
 322       se._tao_print_exception ("Error: ");
 323       status = 1;
 324     }
 325
 326   return status;
 327 }