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