TAO/tests/Muxed_GIOP_Versions/client.cpp

   1 #include "testC.h"
   2 #include "tao/debug.h"
   3 #include "ace/Get_Opt.h"
   4 #include "ace/Task.h"
   5
   6 const ACE_TCHAR *ior = ACE_TEXT("file://test.ior");
   7 const ACE_TCHAR *corbaloc_arg = ACE_TEXT("corbaloc:iiop:1.0@localhost:12000/ObjectName");
   8 int nthreads = 5;
   9 int niterations = 5;
  10 int server_shutdown = 0;
  11
  12 int
  13 parse_args (int argc, ACE_TCHAR *argv[])
  14 {
  15   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("l:k:n:i:x"));
  16   int c;
  17
  18   while ((c = get_opts ()) != -1)
  19     switch (c)
  20       {
  21       case 'k':
  22         ior = get_opts.opt_arg ();
  23         break;
  24       case 'l':
  25         corbaloc_arg = get_opts.opt_arg ();
  26         break;
  27       case 'n':
  28         nthreads = ACE_OS::atoi (get_opts.opt_arg ());
  29         break;
  30       case 'i':
  31         niterations = ACE_OS::atoi (get_opts.opt_arg ());
  32         break;
  33       case 'x':
  34         server_shutdown = 1;
  35         break;
  36       case '?':
  37       default:
  38         ACE_ERROR_RETURN ((LM_ERROR,
  39                            "usage:  %s "
  40                            "-k <ior> "
  41                            "-n <nthreads> "
  42                            "-i <niterations> "
  43                            "\n",
  44                            argv [0]),
  45                           -1);
  46       }
  47   // Indicates successful parsing of the command line
  48   return 0;
  49 }
  50
  51 class Client : public ACE_Task_Base
  52 {
  53   // = TITLE
  54   //   Run the client thread
  55   //
  56   // = DESCRIPTION
  57   //   Use the ACE_Task_Base class to run the client threads.
  58   //
  59 public:
  60   Client (Simple_Server_ptr server, int niterations);
  61   // ctor
  62
  63   virtual int svc ();
  64   // The thread entry point.
  65
  66 private:
  67   void validate_connection ();
  68   // Validate the connection
  69
  70 private:
  71   Simple_Server_var server_;
  72   // The server.
  73
  74   int niterations_;
  75   // The number of iterations on each client thread.
  76 };
  77
  78 int
  79 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
  80 {
  81   try
  82     {
  83       CORBA::ORB_var orb =
  84         CORBA::ORB_init (argc, argv);
  85
  86       if (parse_args (argc, argv) != 0)
  87         return 1;
  88
  89       CORBA::Object_var object =
  90         orb->string_to_object (ior);
  91
  92       Simple_Server_var server =
  93         Simple_Server::_narrow (object.in ());
  94
  95       if (CORBA::is_nil (server.in ()))
  96         {
  97           ACE_ERROR_RETURN ((LM_ERROR,
  98                              "Object reference <%s> is nil.\n",
  99                              ior),
 100                             1);
 101         }
 102
 103       Client client (server.in (), niterations);
 104       if (client.activate (THR_NEW_LWP | THR_JOINABLE,
 105                            nthreads) != 0)
 106         ACE_ERROR_RETURN ((LM_ERROR,
 107                            "Cannot activate client threads\n"),
 108                           1);
 109
 110       // While those threads are busy sending 1.2 messages
 111       // send some corba loc requests, don't really care if there is an
 112       // object there to find
 113       if (!server_shutdown)
 114         {
 115           ACE_DEBUG ((LM_DEBUG,
 116                       "starting string_to_object %s\n",
 117                       corbaloc_arg));
 118
 119           for (int c = 0; c < (niterations * 2); c++)
 120             {
 121               try
 122                 {
 123                   CORBA::Object_var probably_not_exist =
 124                     orb->string_to_object(corbaloc_arg);
 125
 126
 127                   if (CORBA::is_nil(probably_not_exist.in()))
 128                     {
 129                       ACE_DEBUG ((LM_DEBUG, "not found\n", corbaloc_arg));
 130                     }
 131                   else
 132                     {
 133                       Simple_Server_var newserver =
 134                         Simple_Server::_narrow (probably_not_exist.in ());
 135
 136                       // should throw an exception
 137                       if (CORBA::is_nil(newserver.in()))
 138                         {
 139                           ACE_DEBUG ((LM_DEBUG, "not found it\n", corbaloc_arg));
 140                         }
 141                       else
 142                         {
 143                           ACE_DEBUG ((LM_DEBUG, "found it\n", corbaloc_arg));
 144                         }
 145                     }
 146                 }
 147               catch (const CORBA::Exception&)
 148                 {
 149                   // ACE_DEBUG ((LM_DEBUG, "caught exception\n", corbaloc_arg));
 150                 }
 151             }
 152         }
 153       ACE_DEBUG ((LM_DEBUG,
 154                   "(%P|%t) waiting for threads\n"));
 155
 156       client.thr_mgr ()->wait ();
 157
 158       ACE_DEBUG ((LM_DEBUG,
 159                   "(%P|%t) threads finished\n"));
 160
 161       if (server_shutdown)
 162         {
 163           server->shutdown ();
 164         }
 165
 166       orb->destroy ();
 167     }
 168   catch (const CORBA::Exception& ex)
 169     {
 170       ex._tao_print_exception ("Caught exception:");
 171       return 1;
 172     }
 173
 174   return 0;
 175 }
 176
 177 // ****************************************************************
 178
 179 Client::Client (Simple_Server_ptr server,
 180                 int niterations)
 181   :  server_ (Simple_Server::_duplicate (server)),
 182      niterations_ (niterations)
 183 {
 184 }
 185
 186 void
 187 Client::validate_connection ()
 188 {
 189   // Ping the object 100 times, ignoring all exceptions.
 190   // It would be better to use validate_connection() but the test must
 191   // run on minimum CORBA builds too!
 192   for (int j = 0; j != 100; ++j)
 193     {
 194       try
 195         {
 196           this->server_->test_method (j);
 197         }
 198       catch (const CORBA::Exception&){}
 199     }
 200 }
 201
 202 int
 203 Client::svc ()
 204 {
 205   try
 206     {
 207       this->validate_connection ();
 208
 209       for (int i = 0; i < this->niterations_; ++i)
 210         {
 211           this->server_->test_method (i);
 212
 213           if (TAO_debug_level > 0 && i % 100 == 0)
 214             ACE_DEBUG ((LM_DEBUG, "(%P|%t) iteration = %d\n",
 215                         i));
 216         }
 217     }
 218   catch (const CORBA::Exception& ex)
 219     {
 220       ex._tao_print_exception ("MT_Client: exception raised");
 221     }
 222   return 0;
 223 }