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