TAO/tests/Bug_3567_Regression/client.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    client.cpp
   5  *
   6  *  A client which uses the AMI callback model.
   7  */
   8 //=============================================================================
   9
  10
  11 #include "ace/Get_Opt.h"
  12 #include "ace/Task.h"
  13 #include "ace/OS_NS_unistd.h"
  14 #include "ami_test_i.h"
  15
  16 const ACE_TCHAR *ior = ACE_TEXT("file://test.ior");
  17 int nthreads = 5;
  18 int niterations = 10;
  19 int debug = 0;
  20 ACE_Atomic_Op <TAO_SYNCH_MUTEX, long> number_of_replies = 0;
  21
  22 CORBA::Long in_number = 931232;
  23 const char * in_str = "Let's talk AMI.";
  24 int parameter_corruption = 0;
  25
  26 int
  27 parse_args (int argc, ACE_TCHAR *argv[])
  28 {
  29   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("dk:n:i:"));
  30   int c;
  31
  32   while ((c = get_opts ()) != -1)
  33     switch (c)
  34       {
  35       case 'd':
  36         debug = 1;
  37         break;
  38       case 'k':
  39         ior = get_opts.opt_arg ();
  40         break;
  41       case 'n':
  42         nthreads = ACE_OS::atoi (get_opts.opt_arg ());
  43         break;
  44       case 'i':
  45         niterations = ACE_OS::atoi (get_opts.opt_arg ());
  46         break;
  47       case '?':
  48       default:
  49         ACE_ERROR_RETURN ((LM_ERROR,
  50                            "usage:  %s "
  51                            "-d "
  52                            "-k <ior> "
  53                            "-n <nthreads> "
  54                            "-i <niterations> "
  55                            "\n",
  56                            argv [0]),
  57                           -1);
  58       }
  59   // Indicates successful parsing of the command line
  60   return 0;
  61 }
  62
  63 /**
  64  * Run a server thread
  65  *
  66  * Use the ACE_Task_Base class to run server threads
  67  */
  68 class Worker : public ACE_Task_Base
  69 {
  70 public:
  71   Worker (CORBA::ORB_ptr orb);
  72   // ctor
  73
  74   virtual int svc (void);
  75   // The thread entry point.
  76
  77 private:
  78   CORBA::ORB_var orb_;
  79   // The orb
  80 };
  81
  82
  83 /**
  84  * @class Client
  85  *
  86  * @brief Run the client thread
  87  *
  88  * Use the ACE_Task_Base class to run the client threads.
  89  */
  90 class Client : public ACE_Task_Base
  91 {
  92 public:
  93   /// ctor
  94   Client (A::AMI_Test_ptr server, int niterations, A::AMI_AMI_TestHandler_ptr hnd);
  95   /// dtor
  96   ~Client () ;
  97
  98   /// The thread entry point.
  99   virtual int svc (void);
 100
 101   // private:
 102   /// Var for the AMI_Test object.
 103   A::AMI_Test_var ami_test_var_;
 104
 105   /// The number of iterations on each client thread.
 106   int niterations_;
 107
 108   /// Var for AMI_AMI_Test_ReplyHandler object.
 109   A::AMI_AMI_TestHandler_var the_handler_var_;
 110 };
 111
 112 class Handler : public POA_A::AMI_AMI_TestHandler
 113 {
 114 public:
 115   Handler (void)
 116   {
 117   }
 118
 119   void set_ami_test (A::AMI_Test_ptr ami_test)
 120   {
 121     ami_test_var_ = A::AMI_Test::_duplicate (ami_test);
 122   }
 123
 124   void foo (CORBA::Long result,
 125             CORBA::Long out_l)
 126     {
 127       if (result == 0)
 128         {
 129           ACE_ERROR((LM_ERROR, "ERROR: Callback method detected parameter corruption.\n"));
 130           parameter_corruption = 1;
 131         }
 132
 133       if (debug)
 134         {
 135           ACE_DEBUG ((LM_DEBUG,
 136                       "(%P | %t) : Callback method called: result <%d>, out_arg <%d>\n",
 137                       result,
 138                       out_l));
 139         }
 140       ACE_OS::sleep (1);
 141       ami_test_var_->sendc_set_yadda (0, 5);
 142
 143       --number_of_replies;
 144     }
 145
 146    void foo_excep (::Messaging::ExceptionHolder * excep_holder)
 147     {
 148
 149       ACE_DEBUG ((LM_DEBUG,
 150                   "Callback method <foo_excep> called:\n"));
 151       try
 152         {
 153           excep_holder->raise_exception ();
 154         }
 155       catch (const CORBA::Exception& ex)
 156         {
 157           ex._tao_print_exception ("Caught exception:");
 158         }
 159     }
 160
 161   void get_yadda (CORBA::Long result)
 162     {
 163       ACE_DEBUG ((LM_DEBUG,
 164                   "Callback method <get_yadda> called: result <%d>\n",
 165                   result));
 166     }
 167
 168   void get_yadda_excep (::Messaging::ExceptionHolder *)
 169     {
 170       ACE_DEBUG ((LM_DEBUG,
 171                   "Callback method <get_yadda_excep> called:\n"));
 172     }
 173
 174   void set_yadda (void)
 175     {
 176       ACE_DEBUG ((LM_DEBUG,
 177                   "Callback method <set_yadda> called:\n"));
 178     }
 179
 180   void set_yadda_excep (::Messaging::ExceptionHolder *)
 181     {
 182       ACE_DEBUG ((LM_DEBUG,
 183                   "Callback method <set_yadda_excep> called:\n"));
 184     }
 185   ~Handler (void)
 186   {
 187   }
 188
 189   void inout_arg_test (const char *)
 190   {
 191     ACE_DEBUG ((LM_DEBUG,
 192                 "Callback method <set_yadda_excep> called:\n"));
 193   }
 194
 195   void inout_arg_test_excep (::Messaging::ExceptionHolder *)
 196   {
 197   }
 198
 199   A::AMI_Test_var ami_test_var_;
 200 };
 201
 202 int
 203 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
 204 {
 205   try
 206     {
 207       CORBA::ORB_var orb =
 208         CORBA::ORB_init (argc, argv);
 209
 210       if (parse_args (argc, argv) != 0)
 211         return 1;
 212
 213       A::AMI_Test_var server;
 214
 215       CORBA::Object_var object =
 216         orb->string_to_object (ior);
 217       server =  A::AMI_Test::_narrow (object.in ());
 218
 219       if (CORBA::is_nil (server.in ()))
 220         {
 221           ACE_ERROR_RETURN ((LM_ERROR,
 222                              "Object reference <%s> is nil.\n",
 223                              ior),
 224                             1);
 225         }
 226
 227       // Activate POA to handle the call back.
 228
 229       CORBA::Object_var poa_object =
 230         orb->resolve_initial_references("RootPOA");
 231
 232       if (CORBA::is_nil (poa_object.in ()))
 233         ACE_ERROR_RETURN ((LM_ERROR,
 234                            " (%P|%t) Unable to initialize the POA.\n"),
 235                           1);
 236
 237       PortableServer::POA_var root_poa =
 238         PortableServer::POA::_narrow (poa_object.in ());
 239
 240       PortableServer::POAManager_var poa_manager =
 241         root_poa->the_POAManager ();
 242
 243       poa_manager->activate ();
 244
 245       // Let the client perform the test in a separate thread
 246       Handler handler;
 247       PortableServer::ObjectId_var id =
 248         root_poa->activate_object (&handler);
 249
 250       CORBA::Object_var hnd_object = root_poa->id_to_reference (id.in ());
 251
 252       A::AMI_AMI_TestHandler_var the_handler_var =
 253         A::AMI_AMI_TestHandler::_narrow (hnd_object.in ());
 254
 255       handler.set_ami_test (server.in ());
 256
 257       Client client (server.in (), niterations, the_handler_var.in ());
 258       if (client.activate (THR_NEW_LWP | THR_JOINABLE,
 259                            nthreads) != 0)
 260         ACE_ERROR_RETURN ((LM_ERROR,
 261                            "Cannot activate client threads\n"),
 262                           1);
 263
 264       // Main thread collects replies. It needs to collect
 265       // <nthreads*niterations> replies.
 266       number_of_replies = nthreads *niterations;
 267
 268       if (debug)
 269         {
 270           ACE_DEBUG ((LM_DEBUG,
 271                       "(%P|%t) : Entering perform_work loop to receive <%d> replies\n",
 272                       number_of_replies.value ()));
 273         }
 274
 275       // ORB loop.
 276
 277       Worker worker (orb.in ());
 278       if (worker.activate (THR_NEW_LWP | THR_JOINABLE,
 279                            nthreads) != 0)
 280         ACE_ERROR_RETURN ((LM_ERROR,
 281                            "Cannot activate client threads\n"),
 282                           1);
 283
 284       worker.thr_mgr ()->wait ();
 285
 286       if (debug)
 287         {
 288           ACE_DEBUG ((LM_DEBUG,
 289                       "(%P|%t) : Exited perform_work loop Received <%d> replies\n",
 290                       (nthreads*niterations) - number_of_replies.value ()));
 291         }
 292
 293       client.thr_mgr ()->wait ();
 294
 295       ACE_DEBUG ((LM_DEBUG, "threads finished\n"));
 296
 297       server->shutdown ();
 298
 299       root_poa->destroy (1,  // ethernalize objects
 300                          0); // wait for completion
 301
 302       orb->destroy ();
 303     }
 304   catch (const CORBA::Exception& ex)
 305     {
 306       ex._tao_print_exception ("Caught exception:");
 307       return 1;
 308     }
 309
 310   return parameter_corruption;
 311 }
 312
 313 // ****************************************************************
 314
 315 Client::Client (A::AMI_Test_ptr server,
 316                 int niterations,
 317                 A::AMI_AMI_TestHandler_ptr hnd)
 318                 :  ami_test_var_ (A::AMI_Test::_duplicate (server))
 319                 ,  niterations_ (niterations)
 320                 ,  the_handler_var_ (A::AMI_AMI_TestHandler::_duplicate (hnd))
 321 {
 322 }
 323
 324 Client::~Client ()
 325 {
 326 }
 327
 328 int
 329 Client::svc (void)
 330 {
 331   try
 332     {
 333       for (int i = 0; i < this->niterations_; ++i)
 334         {
 335           ami_test_var_->sendc_foo (the_handler_var_.in (), in_number, in_str);
 336         }
 337       if (debug)
 338         {
 339           ACE_DEBUG ((LM_DEBUG,
 340                       "(%P|%t) <%d> Asynchronous methods issued\n",
 341                       niterations));
 342         }
 343     }
 344   catch (const CORBA::Exception& ex)
 345     {
 346       ex._tao_print_exception ("MT_Client: exception raised");
 347     }
 348   return 0;
 349 }
 350
 351 Worker::Worker (CORBA::ORB_ptr orb)
 352   :  orb_ (CORBA::ORB::_duplicate (orb))
 353 {
 354 }
 355
 356 int
 357 Worker::svc (void)
 358 {
 359   while (number_of_replies > 0)
 360     {
 361       CORBA::Boolean pending = this->orb_->work_pending();
 362
 363       if (pending)
 364         {
 365           ACE_Time_Value tm (1, 0);
 366           this->orb_->perform_work(tm);
 367         }
 368     }
 369
 370   return 0;
 371 }