TAO/tests/AMI/client.cpp

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