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