TAO/tests/RTCORBA/Profile_And_Endpoint_Selection/server.cpp

   1 #include "ace/Get_Opt.h"
   2 #include "tao/ORB_Core.h"
   3 #include "tao/RTCORBA/Thread_Pool.h"
   4 #include "tao/RTPortableServer/RTPortableServer.h"
   5 #include "tao/Strategies/advanced_resource.h"
   6 #include "../check_supported_priorities.cpp"
   7 #include "../common_args.cpp"
   8 #include "testS.h"
   9
  10 static CORBA::ULong stacksize = 0;
  11 static CORBA::ULong static_threads = 2;
  12 static CORBA::ULong dynamic_threads = 0;
  13 static CORBA::Boolean allow_request_buffering = 0;
  14 static CORBA::ULong max_buffered_requests = 0;
  15 static CORBA::ULong max_request_buffer_size = 0;
  16 static CORBA::Boolean allow_borrowing = 0;
  17
  18 static int debug = 1;
  19 static int ior_file_count = 1;
  20 static const ACE_TCHAR *ior_file_base = ACE_TEXT ("ior");
  21 static const ACE_TCHAR *bands_file = ACE_TEXT ("empty_file");
  22 static const ACE_TCHAR *lanes_file = ACE_TEXT ("empty_file");
  23
  24 class test_i :
  25   public POA_test
  26 {
  27 public:
  28   test_i (CORBA::ORB_ptr orb,
  29           PortableServer::POA_ptr poa);
  30
  31   void method (void);
  32
  33   //FUZZ: disable check_for_lack_ACE_OS
  34   void shutdown (void);
  35   //FUZZ: enable check_for_lack_ACE_OS
  36
  37   PortableServer::POA_ptr _default_POA (void);
  38
  39 private:
  40
  41   CORBA::ORB_var orb_;
  42   PortableServer::POA_var poa_;
  43 };
  44
  45 test_i::test_i (CORBA::ORB_ptr orb,
  46                 PortableServer::POA_ptr poa)
  47   : orb_ (CORBA::ORB::_duplicate (orb)),
  48     poa_ (PortableServer::POA::_duplicate (poa))
  49 {
  50 }
  51
  52 void
  53 test_i::method (void)
  54 {
  55   // Get the ORB_Core's TSS resources.
  56   TAO_ORB_Core_TSS_Resources *tss =
  57     this->orb_->orb_core ()->get_tss_resources ();
  58
  59   /// Get the lane attribute in TSS.
  60     TAO_Thread_Lane *lane =
  61       (TAO_Thread_Lane *) tss->lane_;
  62
  63     if (debug)
  64       {
  65         if (lane)
  66           ACE_DEBUG ((LM_DEBUG,
  67                       "test_i::method request in thread %t (pool id = %d; lane id = %d)\n",
  68                       lane->pool ().id (),
  69                       lane->id ()));
  70         else
  71           ACE_DEBUG ((LM_DEBUG,
  72                       "test_i::method request in thread %t (default thread pool)\n"));
  73       }
  74 }
  75
  76 void
  77 test_i::shutdown (void)
  78 {
  79   if (debug)
  80     ACE_DEBUG ((LM_DEBUG,
  81                 "test_i::shutdown\n"));
  82
  83   this->orb_->shutdown (false);
  84 }
  85
  86 PortableServer::POA_ptr
  87 test_i::_default_POA (void)
  88 {
  89   return PortableServer::POA::_duplicate (this->poa_.in ());
  90 }
  91
  92 static int
  93 parse_args (int argc, ACE_TCHAR **argv)
  94 {
  95   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("b:d:l:o:"));
  96   int c;
  97
  98   while ((c = get_opts ()) != -1)
  99     switch (c)
 100       {
 101       case 'b':
 102         bands_file = get_opts.opt_arg ();
 103         break;
 104
 105       case 'd':
 106         debug = ACE_OS::atoi (get_opts.opt_arg ());
 107         break;
 108
 109       case 'l':
 110         lanes_file = get_opts.opt_arg ();
 111         break;
 112
 113       case 'o':
 114         ior_file_base = get_opts.opt_arg ();
 115         break;
 116
 117       case '?':
 118       default:
 119         ACE_ERROR_RETURN ((LM_ERROR,
 120                            "%s usage:\n"
 121                            "\t-b <bands file> (defaults to %s)\n"
 122                            "\t-b <lanes file> (defaults to %s)\n"
 123                            "\t-o <ior file base> (defaults to %s)\n"
 124                            "\n",
 125                            argv[0],
 126                            bands_file,
 127                            lanes_file,
 128                            ior_file_base),
 129                           -1);
 130       }
 131
 132   return 0;
 133 }
 134
 135 static void
 136 write_iors_to_file (CORBA::Object_ptr object,
 137                     CORBA::ORB_ptr orb)
 138 {
 139   char filename[BUFSIZ];
 140   ACE_OS::sprintf (filename,
 141                    "%s_%d",
 142                    ACE_TEXT_ALWAYS_CHAR (ior_file_base),
 143                    ior_file_count);
 144   ior_file_count++;
 145
 146   FILE *file =
 147     ACE_OS::fopen (filename, "w");
 148   ACE_ASSERT (file != 0);
 149
 150   CORBA::String_var ior =
 151     orb->object_to_string (object);
 152
 153   u_int result = 0;
 154   result =
 155     ACE_OS::fprintf (file,
 156                      "%s",
 157                      ior.in ());
 158
 159   ACE_ASSERT (result == ACE_OS::strlen (ior.in ()));
 160   ACE_UNUSED_ARG (result);
 161
 162   ACE_OS::fclose (file);
 163 }
 164
 165 void
 166 vanilla_poa (CORBA::ORB_ptr orb,
 167              PortableServer::POA_ptr root_poa,
 168              PortableServer::POAManager_ptr poa_manager)
 169 {
 170   CORBA::PolicyList policies;
 171
 172   CORBA::Policy_var implicit_activation_policy =
 173     root_poa->create_implicit_activation_policy (PortableServer::IMPLICIT_ACTIVATION);
 174
 175   policies.length (policies.length () + 1);
 176   policies[policies.length () - 1] =
 177     implicit_activation_policy;
 178
 179   PortableServer::POA_var poa =
 180     root_poa->create_POA ("child",
 181                           poa_manager,
 182                           policies);
 183
 184   test_i *servant = 0;
 185   ACE_NEW_THROW_EX (servant,
 186                     test_i (orb,
 187                             poa.in ()),
 188                     CORBA::NO_MEMORY ());
 189
 190   PortableServer::ServantBase_var safe_servant (servant);
 191
 192   PortableServer::ObjectId_var id_act =
 193     poa->activate_object (servant);
 194
 195   CORBA::Object_var object = poa->id_to_reference (id_act.in ());
 196
 197   test_var test =
 198     test::_narrow (object.in ());
 199
 200   write_iors_to_file (test.in (),
 201                       orb);
 202 }
 203
 204 void
 205 rt_poa (CORBA::ORB_ptr orb,
 206         RTCORBA::RTORB_ptr rt_orb,
 207         PortableServer::POA_ptr root_poa,
 208         PortableServer::POAManager_ptr poa_manager)
 209 {
 210   CORBA::PolicyList policies;
 211
 212   int result =
 213     get_priority_bands ("server",
 214                         bands_file,
 215                         rt_orb,
 216                         policies,
 217                         debug);
 218   if (result != 0)
 219     {
 220       ACE_ERROR ((LM_ERROR,
 221                   "Error in parsing bands data file: %s\n",
 222                   bands_file));
 223       return;
 224     }
 225
 226   result =
 227     get_priority_lanes ("server",
 228                         lanes_file,
 229                         rt_orb,
 230                         stacksize,
 231                         static_threads,
 232                         dynamic_threads,
 233                         allow_request_buffering,
 234                         max_buffered_requests,
 235                         max_request_buffer_size,
 236                         allow_borrowing,
 237                         policies,
 238                         debug);
 239   if (result != 0)
 240     {
 241       ACE_ERROR ((LM_ERROR,
 242                   "Error in parsing lanes data file: %s\n",
 243                   lanes_file));
 244       return;
 245     }
 246
 247   CORBA::Policy_var priority_model_policy =
 248     rt_orb->create_priority_model_policy (RTCORBA::CLIENT_PROPAGATED,
 249                                           0);
 250
 251   // Implicit_activation policy.
 252   CORBA::Policy_var implicit_activation_policy =
 253     root_poa->create_implicit_activation_policy (PortableServer::IMPLICIT_ACTIVATION);
 254
 255   policies.length (policies.length () + 1);
 256   policies[policies.length () - 1] =
 257     priority_model_policy;
 258
 259   policies.length (policies.length () + 1);
 260   policies[policies.length () - 1] =
 261     implicit_activation_policy;
 262
 263   PortableServer::POA_var poa =
 264     root_poa->create_POA ("rt_poa",
 265                           poa_manager,
 266                           policies);
 267
 268   test_i *servant = 0;
 269   ACE_NEW_THROW_EX (servant,
 270                     test_i (orb,
 271                             poa.in ()),
 272                     CORBA::NO_MEMORY ());
 273
 274   PortableServer::ServantBase_var safe_servant (servant);
 275
 276   PortableServer::ObjectId_var id_act =
 277     poa->activate_object (servant);
 278
 279   CORBA::Object_var object = poa->id_to_reference (id_act.in ());
 280
 281   test_var test =
 282     test::_narrow (object.in ());
 283
 284   write_iors_to_file (test.in (),
 285                       orb);
 286 }
 287
 288 class Task : public ACE_Task_Base
 289 {
 290 public:
 291
 292   Task (ACE_Thread_Manager &thread_manager,
 293         CORBA::ORB_ptr orb);
 294
 295   int svc (void);
 296
 297   CORBA::ORB_var orb_;
 298
 299 };
 300
 301 Task::Task (ACE_Thread_Manager &thread_manager,
 302             CORBA::ORB_ptr orb)
 303   : ACE_Task_Base (&thread_manager),
 304     orb_ (CORBA::ORB::_duplicate (orb))
 305 {
 306 }
 307
 308 int
 309 Task::svc (void)
 310 {
 311   try
 312     {
 313       CORBA::Object_var object =
 314         this->orb_->resolve_initial_references ("RTORB");
 315
 316       RTCORBA::RTORB_var rt_orb =
 317         RTCORBA::RTORB::_narrow (object.in ());
 318
 319       object =
 320         this->orb_->resolve_initial_references ("RootPOA");
 321
 322       PortableServer::POA_var root_poa =
 323         PortableServer::POA::_narrow (object.in ());
 324
 325       PortableServer::POAManager_var poa_manager =
 326         root_poa->the_POAManager ();
 327
 328       vanilla_poa (this->orb_.in (),
 329                    root_poa.in (),
 330                    poa_manager.in ());
 331
 332       rt_poa (this->orb_.in (),
 333               rt_orb.in (),
 334               root_poa.in (),
 335               poa_manager.in ());
 336
 337       poa_manager->activate ();
 338
 339       this->orb_->run ();
 340
 341       this->orb_->destroy ();
 342     }
 343   catch (const CORBA::Exception& ex)
 344     {
 345       ex._tao_print_exception ("Exception caught");
 346       return -1;
 347     }
 348
 349   return 0;
 350 }
 351
 352 int
 353 ACE_TMAIN (int argc, ACE_TCHAR *argv[])
 354 {
 355   try
 356     {
 357       CORBA::ORB_var orb =
 358         CORBA::ORB_init (argc, argv);
 359
 360       int result =
 361         parse_args (argc, argv);
 362       if (result != 0)
 363         return result;
 364
 365       // Make sure we can support multiple priorities that are required
 366       // for this test.
 367       if (!check_supported_priorities (orb.in ()))
 368         return 2;
 369
 370       // Thread Manager for managing task.
 371       ACE_Thread_Manager thread_manager;
 372
 373       // Create task.
 374       Task task (thread_manager,
 375                  orb.in ());
 376
 377       // Task activation flags.
 378       long flags =
 379         THR_NEW_LWP |
 380         THR_JOINABLE |
 381         orb->orb_core ()->orb_params ()->thread_creation_flags ();
 382
 383       // Activate task.
 384       result =
 385         task.activate (flags);
 386       if (result == -1)
 387         {
 388           if (errno == EPERM)
 389             {
 390               ACE_ERROR_RETURN ((LM_ERROR,
 391                                  "Cannot create thread with scheduling policy %C\n"
 392                                  "because the user does not have the appropriate privileges, terminating program....\n"
 393                                  "Check svc.conf options and/or run as root\n",
 394                                  sched_policy_name (orb->orb_core ()->orb_params ()->ace_sched_policy ())),
 395                                 2);
 396             }
 397           else
 398             // Unexpected error.
 399             ACE_ASSERT (0);
 400         }
 401
 402       // Wait for task to exit.
 403       result =
 404         thread_manager.wait ();
 405       ACE_ASSERT (result != -1);
 406     }
 407   catch (const CORBA::Exception& ex)
 408     {
 409       ex._tao_print_exception ("Exception caught");
 410       return -1;
 411     }
 412
 413   return 0;
 414 }