TAO/tests/NestedUpcall/Simple/simple-client.cpp

   1 #include "client_i.h"
   2 #include "ace/Get_Opt.h"
   3 #include "ace/Task.h"
   4
   5 static const ACE_TCHAR *ior = ACE_TEXT ("file://test.ior");
   6 // Server IOR.
   7
   8 static int shutdown_server = 0;
   9 // Flag to tell server to shutdown.
  10
  11 static CORBA::UShort call_count = 5;
  12 // # of nested calls to be made.
  13
  14 static int quiet = 0;
  15 // The test is quiet...
  16
  17 static int number_of_threads = 1;
  18 // Number of client threads.
  19
  20 class Client_Task
  21 {
  22 public:
  23   Client_Task (client_ptr c,
  24                server_ptr s);
  25   int svc (void);
  26
  27 private:
  28   client_var client_;
  29   server_var server_;
  30 };
  31
  32 Client_Task::Client_Task (client_ptr c,
  33                           server_ptr s)
  34   : client_ (client::_duplicate (c)),
  35     server_ (server::_duplicate (s))
  36 {
  37 }
  38
  39 int
  40 Client_Task::svc (void)
  41 {
  42   try
  43     {
  44       if (!quiet)
  45         ACE_DEBUG ((LM_DEBUG,
  46                     "(%t) Client_Task::svc calling start -> time to live = %d\n",
  47                     call_count));
  48
  49       // Now, we can invoke an operation on the remote side.
  50       this->server_->start (this->client_.in (),
  51                             call_count);
  52
  53       return 0;
  54     }
  55   catch (const CORBA::Exception& ex)
  56     {
  57       ex._tao_print_exception ("Client_Task::svc");
  58       return -1;
  59     }
  60   return 0;
  61 }
  62
  63 static int
  64 parse_args (int argc, ACE_TCHAR **argv)
  65 {
  66   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("qxn:k:t:"));
  67   int c;
  68
  69   while ((c = get_opts ()) != -1)
  70     switch (c)
  71       {
  72       case 'q':
  73         quiet = 1;
  74         break;
  75
  76       case 'x':
  77         shutdown_server = 1;
  78         break;
  79
  80       case 'n':
  81         call_count = ACE_OS::atoi (get_opts.opt_arg ());
  82         break;
  83
  84       case 't':
  85         number_of_threads = ACE_OS::atoi (get_opts.opt_arg ());
  86         break;
  87
  88       case 'k':
  89         ior = get_opts.opt_arg ();
  90         break;
  91
  92       case '?':
  93       default:
  94         ACE_ERROR_RETURN ((LM_ERROR,
  95                            "usage:  %s"
  96                            " [-n number of nested calls]"
  97                            " [-k ior]"
  98                            " [-q (quite)]"
  99                            " [-x (shutdown server)]"
 100                            "\n",
 101                            argv[0]),
 102                           -1);
 103       }
 104
 105   if (ior == 0)
 106     ACE_ERROR_RETURN ((LM_ERROR,
 107                        "%s: no nested up calls server ior specified\n",
 108                        argv[0]),
 109                       -1);
 110
 111   // Indicates successful parsing of command line.
 112   return 0;
 113 }
 114
 115 int
 116 ACT_TMAIN (int argc, ACE_TCHAR **argv)
 117 {
 118   try
 119     {
 120       CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
 121
 122       int result = parse_args (argc, argv);
 123       if (result != 0)
 124         return result;
 125
 126       CORBA::Object_var object = orb->resolve_initial_references ("RootPOA");
 127
 128       PortableServer::POA_var root_poa =
 129         PortableServer::POA::_narrow (object.in ());
 130
 131       PortableServer::POAManager_var poa_manager =
 132         root_poa->the_POAManager ();
 133
 134       poa_manager->activate ();
 135
 136       object = orb->string_to_object (ior);
 137
 138       server_var server = server::_narrow (object.in ());
 139
 140       // Create an client object to hand to the other side...
 141       client_i client_servant (quiet,
 142                                server.in ());
 143
 144       PortableServer::ObjectId_var id =
 145         root_poa->activate_object (&client_servant);
 146
 147       CORBA::Object_var object_act = root_poa->id_to_reference (id.in ());
 148
 149       client_var client_object = client::_narrow (object_act.in ());
 150
 151       Client_Task client_tasks (client_object.in (),
 152                                 server.in ());
 153
 154       client_tasks.svc ();
 155
 156
 157       if (shutdown_server)
 158         {
 159           server->shutdown ();
 160         }
 161
 162       root_poa->destroy (1,
 163                          1);
 164     }
 165   catch (const CORBA::Exception& ex)
 166     {
 167       ex._tao_print_exception ("client::main");
 168       return -1;
 169     }
 170   return 0;
 171 }