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