TAO/orbsvcs/tests/Bug_2377_Regression/uipmc_test.cpp

   1
   2 #include "ace/Task.h"
   3 #include "ace/Mutex.h"
   4 #include "Hello_Impl.h"
   5 #include "orbsvcs/PortableGroup/GOA.h"
   6 #include "ace/Get_Opt.h"
   7 #include "ace/Manual_Event.h"
   8 #include "tao/Policy_Manager.h"
   9
  10 #define CLIENT_SLEEP_TIME       1000     /* in microseconds */
  11 #define CLIENT_THREAD_NUMBER    32
  12 #define HELLO_CALL_NUMBER       100
  13
  14 const ACE_TCHAR *uipmc_url = 0;
  15 const ACE_TCHAR *client_uipmc_url = 0;
  16
  17 void
  18 test_sleep (int microsec)
  19 {
  20   ACE_Time_Value tv (microsec / 1000000, microsec % 1000000);
  21
  22   ACE_OS::sleep ((const ACE_Time_Value &) tv);
  23 }
  24
  25 int
  26 parse_args (int argc, ACE_TCHAR *argv[])
  27 {
  28   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("u:c:"));
  29   const unsigned char full_success = 0x03;
  30   unsigned char success = 0;
  31
  32   do
  33     {
  34       int c = get_opts ();
  35       if (success == full_success && c == -1)
  36         break;
  37
  38       if (c == -1)
  39         ACE_ERROR_RETURN ((LM_ERROR,
  40                            "usage:  %s"
  41                            " -u <url>"
  42                            " -c <client_url>"
  43                            "\n",
  44                            argv [0]),
  45                            -1);
  46
  47       switch (c)
  48         {
  49         case 'u':
  50           uipmc_url = get_opts.opt_arg ();
  51           success |= 0x01;
  52           break;
  53         case 'c':
  54           client_uipmc_url = get_opts.opt_arg ();
  55           success |= 0x02;
  56           break;
  57         }
  58     }
  59   while (true);
  60
  61   // Indicates successful parsing of the command line
  62   return 0;
  63 }
  64
  65
  66 class ORBThread
  67   : public ACE_Task_Base
  68 {
  69 public:
  70   ORBThread (CORBA::ORB_ptr orb, ACE_Manual_Event& me, ACE_Thread_Manager *thr_mgr)
  71     : ACE_Task_Base (thr_mgr)
  72     , orb_ (CORBA::ORB::_duplicate (orb))
  73     , me_ (me)
  74   {
  75   }
  76
  77   virtual int
  78   svc ()
  79   {
  80     try
  81       {
  82         this->me_.signal ();
  83         this->orb_->run ();
  84       }
  85     catch (const CORBA::Exception& ex)
  86       {
  87         ex._tao_print_exception ("Exception caught in ORBThread:");
  88         return -1;
  89       }
  90
  91     return 0;
  92   }
  93
  94 private:
  95   CORBA::ORB_var orb_;
  96   ACE_Manual_Event& me_;
  97 };
  98
  99
 100 class ClientThread
 101   : public ACE_Task_Base
 102 {
 103 public:
 104   ClientThread (Test::Hello_ptr hello, MessageLog *log, int calls)
 105     : hello_ (Test::Hello::_duplicate (hello))
 106     , logger_ (log)
 107     , call_count_ (calls)
 108     , count_ (0)
 109   {
 110   }
 111
 112   virtual int
 113   svc ()
 114   {
 115     try
 116       {
 117         while (true)
 118           {
 119             int c = 0;
 120             {
 121               ACE_GUARD_RETURN (ACE_Mutex, ace_mon, this->mutex_, 0);
 122               c = this->count_++;
 123             }
 124
 125             if (c >= this->call_count_)
 126               break;
 127
 128             this->hello_->say_hello (c);
 129
 130             this->logger_->register_message_send (c);
 131
 132             test_sleep (CLIENT_SLEEP_TIME);
 133           }
 134       }
 135     catch (const CORBA::Exception& ex)
 136       {
 137         ex._tao_print_exception ("Exception caught in ClientThread:");
 138         return -1;
 139       }
 140
 141     return 0;
 142   }
 143
 144 private:
 145   ACE_Mutex mutex_;
 146   Test::Hello_var hello_;
 147   MessageLog *logger_;
 148   int call_count_;
 149   int count_;
 150 };
 151
 152
 153 int
 154 ACE_TMAIN (int argc, ACE_TCHAR *argv[])
 155 {
 156   MessageLog logger (HELLO_CALL_NUMBER);
 157
 158   try
 159     {
 160       CORBA::ORB_var orb =
 161         CORBA::ORB_init (argc, argv);
 162
 163       CORBA::Object_var poa_object =
 164         orb->resolve_initial_references("RootPOA");
 165
 166       PortableGroup::GOA_var root_poa =
 167         PortableGroup::GOA::_narrow (poa_object.in ());
 168
 169       if (CORBA::is_nil (root_poa.in ()))
 170         ACE_ERROR_RETURN ((LM_ERROR,
 171                            " (%P|%t) Panic: nil RootPOA\n"),
 172                            1);
 173
 174       PortableServer::POAManager_var poa_manager =
 175         root_poa->the_POAManager ();
 176
 177       Hello_Impl* hello_impl;
 178       ACE_NEW_RETURN (hello_impl,
 179                       Hello_Impl (orb.in (), &logger),
 180                       1);
 181       PortableServer::ServantBase_var owner_transfer (hello_impl);
 182
 183       if (parse_args (argc, argv) != 0)
 184         return 2;
 185
 186       // create UIPMC reference
 187       CORBA::String_var multicast_url =
 188         CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR(uipmc_url));
 189       CORBA::Object_var miop_ref =
 190         orb->string_to_object (multicast_url.in ());
 191
 192       // create UIPMC reference for client access
 193       CORBA::String_var client_multicast_url =
 194         CORBA::string_dup (ACE_TEXT_ALWAYS_CHAR(client_uipmc_url));
 195       CORBA::Object_var client_miop_ref =
 196         orb->string_to_object (client_multicast_url.in ());
 197
 198       // create ids
 199       PortableServer::ObjectId_var id =
 200         root_poa->create_id_for_reference (miop_ref.in ());
 201       PortableServer::ObjectId_var client_id =
 202         root_poa->create_id_for_reference (client_miop_ref.in ());
 203
 204       // activate Hello Object
 205       root_poa->activate_object_with_id (id.in (),
 206                                          hello_impl);
 207
 208       // create Hello reference
 209       Test::Hello_var hello =
 210         Test::Hello::_unchecked_narrow (client_miop_ref.in ());
 211
 212       poa_manager->activate ();
 213
 214       {
 215         // start orb thread
 216         ACE_Manual_Event me;
 217         ORBThread orb_thr (orb.in (), me, ACE_Thread_Manager::instance ());
 218         orb_thr.activate (THR_NEW_LWP | THR_JOINABLE, 1, 1);
 219         me.wait ();
 220
 221         // start clients
 222         ClientThread cln_thr (hello.in (), &logger, HELLO_CALL_NUMBER);
 223         cln_thr.activate (THR_NEW_LWP | THR_JOINABLE, CLIENT_THREAD_NUMBER);
 224         cln_thr.wait ();
 225
 226         // shutdown the server, after 10 invocations of shutdown() we can be
 227         // more or less sure that server actually received that call
 228         for (int i = 0; i < 10; i++)
 229           hello->shutdown ();
 230         orb_thr.wait ();
 231       }
 232
 233       if (logger.report_statistics () == HELLO_CALL_NUMBER)
 234         ACE_ERROR_RETURN ((LM_ERROR,
 235                            "\n (%P|%t) No single call got through to the server\n"),
 236                            3);
 237
 238       root_poa->destroy (true, true);
 239
 240       orb->destroy ();
 241     }
 242   catch (const CORBA::Exception& ex)
 243     {
 244       ex._tao_print_exception ("Exception caught in main ():");
 245       return 4;
 246     }
 247
 248   ACE_DEBUG ((LM_DEBUG,
 249               "\n (%P|%t) uipmc_test is successful..\n"));
 250   return 0;
 251 }