TAO/tests/CSD_Strategy_Tests/TP_Test_2/ServerApp.cpp

   1 #include "ServerApp.h"
   2 #include "AppHelper.h"
   3 #include "OrbRunner.h"
   4 #include "AppShutdown.h"
   5 #include "TestAppExceptionC.h"
   6 #include "Foo_A_ClientEngine.h"
   7 #include "ace/Get_Opt.h"
   8 // To force static load the service.
   9 #include "tao/PI/PI.h"
  10 #include "tao/CSD_ThreadPool/CSD_ThreadPool.h"
  11
  12 ServerApp::ServerApp()
  13   : TestAppBase("TP_Test_2_Server"),
  14     ior_filename_prefix_(ACE_TEXT("foo")),
  15     num_servants_(1),
  16     num_csd_threads_(1),
  17     num_orb_threads_(1),
  18     num_remote_clients_(1),
  19     num_collocated_clients_(0),
  20     collocated_client_kind_(0)
  21 {
  22 }
  23
  24
  25 int
  26 ServerApp::run_i(int argc, ACE_TCHAR* argv[])
  27 {
  28   int result = this->init(argc, argv);
  29   if (result != 0)
  30     {
  31       return result;
  32     }
  33
  34   this->poa_setup();
  35   this->csd_setup();
  36   this->servant_setup();
  37   this->collocated_setup();
  38   this->poa_activate();
  39   this->run_collocated_clients();
  40   this->run_orb_event_loop();
  41
  42   // Calling wait on ACE_Thread_Manager singleton to avoid the problem
  43   // that the main thread might exit before all CSD Threads exit.
  44
  45   // Wait for all CSD task threads exit.
  46   ACE_Thread_Manager::instance ()->wait ();
  47
  48   this->cleanup();
  49   return this->check_validity () ? 0 : -1;
  50 }
  51
  52
  53 int
  54 ServerApp::init(int argc, ACE_TCHAR* argv[])
  55 {
  56   this->orb_ = CORBA::ORB_init(argc, argv);
  57
  58   // Parse the command-line args for this application.
  59   // * Raises -1 if problems are encountered.
  60   // * Returns 1 if the usage statement was explicitly requested.
  61   // * Returns 0 otherwise.
  62   int result = this->parse_args(argc, argv);
  63
  64   if (result != 0)
  65     {
  66       return result;
  67     }
  68
  69   unsigned num_clients = this->num_remote_clients_ +
  70                          this->num_collocated_clients_;
  71
  72   TheAppShutdown->init (this->orb_.in (), num_clients);
  73
  74   return 0;
  75 }
  76
  77
  78 void
  79 ServerApp::poa_setup()
  80 {
  81   this->poa_ = this->create_poa(this->orb_.in(),
  82                                 "ChildPoa");
  83 }
  84
  85
  86 void
  87 ServerApp::csd_setup()
  88 {
  89   this->tp_strategy_ = new TAO::CSD::TP_Strategy(this->num_csd_threads_);
  90
  91   if (!this->tp_strategy_->apply_to(this->poa_.in()))
  92     {
  93       ACE_ERROR((LM_ERROR,
  94                  "Failed to apply CSD strategy to poa.\n"));
  95       throw TestAppException();
  96     }
  97 }
  98
  99
 100 void
 101 ServerApp::servant_setup()
 102 {
 103   this->servants_.create_and_activate(this->num_servants_,
 104                                       this->orb_.in (),
 105                                       this->poa_.in (),
 106                                       this->ior_filename_prefix_.c_str());
 107 }
 108
 109
 110 void
 111 ServerApp::collocated_setup()
 112 {
 113   int client_id_start = this->num_remote_clients_;
 114   for (unsigned i = 0; i < this->num_collocated_clients_; i++)
 115     {
 116       // Dole out the servant object references in a round-robin fashion.
 117       unsigned servant_index = i % this->num_servants_;
 118
 119       ServantListType::T_stub_var obj = this->servants_.objref(servant_index);
 120       ClientEngine_Handle engine = new Foo_A_ClientEngine(obj.in(), ++client_id_start);
 121       this->collocated_client_task_.add_engine(engine.in());
 122     }
 123 }
 124
 125
 126 void
 127 ServerApp::poa_activate()
 128 {
 129   PortableServer::POAManager_var poa_manager
 130     = this->poa_->the_POAManager();
 131
 132   poa_manager->activate();
 133 }
 134
 135
 136 void
 137 ServerApp::run_collocated_clients()
 138 {
 139   if (this->num_collocated_clients_ > 0)
 140     {
 141       if (this->collocated_client_task_.open() == -1)
 142         {
 143           throw TestAppException ();
 144         }
 145     }
 146 }
 147
 148
 149 void
 150 ServerApp::run_orb_event_loop()
 151 {
 152   OrbRunner orb_runner(this->orb_.in(), this->num_orb_threads_);
 153   orb_runner.run();
 154   TheAppShutdown->wait ();
 155 }
 156
 157
 158 void
 159 ServerApp::cleanup()
 160 {
 161 }
 162
 163
 164 int
 165 ServerApp::parse_args(int argc, ACE_TCHAR* argv[])
 166 {
 167   this->exe_name_ = argv[0];
 168
 169   ACE_Get_Opt get_opts(argc, argv, ACE_TEXT("p:s:n:t:r:c:k:"));
 170
 171   int c;
 172
 173   while ((c = get_opts()) != -1)
 174     {
 175       int result = 0;
 176       switch (c)
 177       {
 178         case 'p':
 179           this->ior_filename_prefix_ = get_opts.opt_arg();
 180           break;
 181
 182         case 's':
 183           result = this->set_arg(this->num_servants_,
 184                   get_opts.opt_arg(),
 185                   c,
 186                   "num_servants",
 187                   1);
 188           break;
 189
 190         case 'n':
 191           result = this->set_arg(this->num_csd_threads_,
 192                   get_opts.opt_arg(),
 193                   c,
 194                   "num_servants",
 195                   1);
 196           break;
 197
 198         case 't':
 199           result = this->set_arg(this->num_orb_threads_,
 200                   get_opts.opt_arg(),
 201                   c,
 202                   "num_orb_threads",
 203                   1);
 204           break;
 205
 206         case 'r':
 207           result = this->set_arg(this->num_remote_clients_,
 208                   get_opts.opt_arg(),
 209                   c,
 210                   "num_remote_clients");
 211           break;
 212
 213         case 'c':
 214           result = this->set_arg(this->num_collocated_clients_,
 215                   get_opts.opt_arg(),
 216                   c,
 217                   "num_collocated_clients");
 218           break;
 219
 220         case 'k':
 221           result = this->set_arg(this->collocated_client_kind_,
 222                   get_opts.opt_arg(),
 223                   c,
 224                   "collocated_client_kind");
 225           break;
 226
 227         case '?':
 228           this->usage_statement();
 229           return 1;
 230
 231         default:
 232           this->usage_statement();
 233           return -1;
 234       }
 235
 236       if (result != 0)
 237         {
 238           return result;
 239         }
 240     }
 241
 242   return this->arg_dependency_checks();
 243 }
 244
 245 void
 246 ServerApp::usage_statement()
 247 {
 248   ACE_ERROR((LM_ERROR,
 249              "Usage:  %s [options]\n\n"
 250              "OPTIONS:\n\n"
 251              "\t[-p <ior_filename_prefix>]\n"
 252              "\t[-s <num_servants>]\n"
 253              "\t[-n <num_csd_threads>]\n"
 254              "\t[-t <num_orb_threads>]\n"
 255              "\t[-r <num_remote_clients>]\n"
 256              "\t[-c <num_collocated_clients>]\n"
 257              "\t[-k <collocated_client_kind>]\n"
 258              "\t[-?]\n\n",
 259              this->exe_name_.c_str()));
 260 }
 261
 262
 263 int
 264 ServerApp::arg_dependency_checks()
 265 {
 266   return (this->num_remote_clients_
 267          + this->num_collocated_clients_) > 0 ? 0 : -1;
 268 }
 269
 270
 271 int
 272 ServerApp::set_arg(unsigned&   value,
 273                    const ACE_TCHAR* arg,
 274                    char        opt,
 275                    const char* name,
 276                    int         min)
 277 {
 278   int tmp = ACE_OS::atoi(arg);
 279
 280   if (tmp < min)
 281     {
 282       ACE_ERROR((LM_ERROR,
 283                  "Error: -%c <%s> must be integer type with a value of, "
 284                  "at least, %d.\n", opt, name, min));
 285       this->usage_statement();
 286       return -1;
 287     }
 288
 289   value = tmp;
 290   return 0;
 291 }
 292
 293
 294 PortableServer::POA_ptr
 295 ServerApp::create_poa(CORBA::ORB_ptr orb,
 296                       const char* poa_name)
 297 {
 298   // Get the Root POA.
 299   PortableServer::POA_var root_poa
 300     = RefHelper<PortableServer::POA>::resolve_initial_ref(orb,
 301                                                           "RootPOA");
 302
 303   // Get the POAManager from the Root POA.
 304   PortableServer::POAManager_var poa_manager
 305     = root_poa->the_POAManager();
 306
 307   // Create the child POA Policies.
 308   CORBA::PolicyList policies(0);
 309   policies.length(0);
 310
 311   // Create the child POA
 312   PortableServer::POA_var poa = AppHelper::create_poa(poa_name,
 313                                                       root_poa.in(),
 314                                                       poa_manager.in(),
 315                                                       policies);
 316
 317   // Give away the child POA_ptr from the POA_var variable.
 318   return poa._retn();
 319 }
 320
 321
 322 bool
 323 ServerApp::check_validity ()
 324 {
 325   // Check whether the clients return any errors.
 326   if (this->num_collocated_clients_ > 0
 327     && this->collocated_client_task_.failure_count () > 0)
 328     {
 329       return false;
 330     }
 331
 332   unsigned num_clients = this->num_remote_clients_ +
 333                          this->num_collocated_clients_;
 334
 335   Foo_A_Statistics stats (num_clients);
 336
 337   Foo_A_ClientEngine::expected_results (stats);
 338
 339   for (unsigned i = 0; i < this->num_servants_; i++)
 340     {
 341       this->servants_.servant(i)->gather_stats(stats);
 342     }
 343
 344   return stats.actual_vs_expected ();
 345 }