TAO/tests/MT_Client/orb_creation.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 int nthreads = 5;
   8 int niterations = 5;
   9
  10 int
  11 parse_args (int argc, ACE_TCHAR *argv[])
  12 {
  13   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("k:n:i:"));
  14   int c;
  15
  16   while ((c = get_opts ()) != -1)
  17     switch (c)
  18       {
  19       case 'k':
  20         ior = get_opts.opt_arg ();
  21         break;
  22       case 'n':
  23         nthreads = ACE_OS::atoi (get_opts.opt_arg ());
  24         break;
  25       case 'i':
  26         niterations = ACE_OS::atoi (get_opts.opt_arg ());
  27         break;
  28       case '?':
  29       default:
  30         ACE_ERROR_RETURN ((LM_ERROR,
  31                            "usage:  %s "
  32                            "-k <ior> "
  33                            "-n <nthreads> "
  34                            "-i <niterations> "
  35                            "\n",
  36                            argv [0]),
  37                           -1);
  38       }
  39   // Indicates successful parsing of the command line
  40   return 0;
  41 }
  42
  43 class Client : public ACE_Task_Base
  44 {
  45   // = TITLE
  46   //   Run the client thread
  47   //
  48   // = DESCRIPTION
  49   //   Use the ACE_Task_Base class to run the client threads.
  50   //
  51 public:
  52   Client (int niterations,
  53           const char* ior);
  54   // ctor
  55
  56   virtual int svc ();
  57   // The thread entry point.
  58
  59 private:
  60   int niterations_;
  61   // The number of iterations on each client thread.
  62
  63   const char* ior_;
  64   // The IOR that we should use.
  65 };
  66
  67 int
  68 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
  69 {
  70   try
  71     {
  72       CORBA::ORB_var orb =
  73         CORBA::ORB_init (argc, argv);
  74
  75       if (parse_args (argc, argv) != 0)
  76         return 1;
  77
  78       CORBA::Object_var object =
  79         orb->string_to_object (ior);
  80
  81       Simple_Server_var server =
  82         Simple_Server::_narrow (object.in ());
  83
  84       if (CORBA::is_nil (server.in ()))
  85         {
  86           ACE_ERROR_RETURN ((LM_ERROR,
  87                              "Object reference <%s> is nil.\n",
  88                              ior),
  89                             1);
  90         }
  91
  92       Client client (niterations, ior);
  93       if (client.activate (THR_NEW_LWP | THR_JOINABLE,
  94                            nthreads) != 0)
  95         ACE_ERROR_RETURN ((LM_ERROR,
  96                            "Cannot activate client threads\n"),
  97                           1);
  98
  99       client.thr_mgr ()->wait ();
 100
 101       ACE_DEBUG ((LM_DEBUG, "threads finished\n"));
 102
 103       server->shutdown ();
 104     }
 105   catch (const CORBA::Exception& ex)
 106     {
 107       ex._tao_print_exception ("Exception caught:");
 108       return 1;
 109     }
 110
 111   return 0;
 112 }
 113
 114 // ****************************************************************
 115
 116 Client::Client (int niterations,
 117                 const char* ior)
 118   :  niterations_ (niterations),
 119      ior_ (ior)
 120 {
 121 }
 122
 123 int
 124 Client::svc ()
 125 {
 126   try
 127     {
 128       for (int i = 0; i < this->niterations_; ++i)
 129         {
 130           // If we are using a global ORB this is a nop, otherwise it
 131           // initializes the ORB resources for this thread.
 132           int argc = 0;
 133           CORBA::String_var argv0 = CORBA::string_dup ("dummy_argv");
 134           char* argv[1] = { argv0.inout () };
 135           CORBA::ORB_var orb =
 136             CORBA::ORB_init (argc, argv);
 137
 138           CORBA::Object_var object =
 139             orb->string_to_object (this->ior_);
 140
 141           Simple_Server_var server =
 142             Simple_Server::_narrow (object.in ());
 143
 144           if (CORBA::is_nil (server.in ()))
 145             {
 146               ACE_ERROR_RETURN ((LM_ERROR,
 147                                  "(%P|%t) Object reference <%s> is nil\n",
 148                                  ior),
 149                                 1);
 150             }
 151
 152           server->test_method ();
 153           if (TAO_debug_level > 0 && i % 100 == 0)
 154             ACE_DEBUG ((LM_DEBUG, "(%P|%t) iteration = %d\n", i));
 155         }
 156     }
 157   catch (const CORBA::Exception& ex)
 158     {
 159       ex._tao_print_exception ("MT_Client: exception raised");
 160     }
 161   return 0;
 162 }