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