TAO/tests/RTCORBA/Bug_3643_Regression/server.cpp

   1 #include "test_i.h"
   2 #include "ace/Get_Opt.h"
   3 #include "ace/OS_NS_unistd.h"
   4 #include "tao/ORB_Core.h"
   5 #include "ace/Task.h"
   6 #include "tao/RTPortableServer/RTPortableServer.h"
   7 #include "../check_supported_priorities.cpp"
   8
   9 const ACE_TCHAR *ior_output_file = ACE_TEXT("ior");
  10 int ior_count = 1;
  11 CORBA::ULong static_threads = 1;
  12 CORBA::ULong dynamic_threads = 25;
  13 long nap_time = 1000;
  14
  15 int
  16 parse_args (int argc, ACE_TCHAR *argv[])
  17 {
  18   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("o:s:d:t:h"));
  19   int c;
  20
  21   while ((c = get_opts ()) != -1)
  22     switch (c)
  23       {
  24       case 'o':
  25         ior_output_file = get_opts.opt_arg ();
  26         break;
  27
  28       case 's':
  29         static_threads = ACE_OS::atoi (get_opts.opt_arg ());
  30         break;
  31
  32       case 'd':
  33         dynamic_threads = ACE_OS::atoi (get_opts.opt_arg ());
  34         break;
  35
  36       case 't':
  37         nap_time = ACE_OS::atoi (get_opts.opt_arg ());
  38         break;
  39
  40       case 'h':
  41         ACE_ERROR_RETURN ((LM_ERROR,
  42                            "usage:  %s "
  43                            "-o <iorfile> "
  44                            "-s <static_threads> "
  45                            "-d <dynamic_threads> "
  46                            "-t <nap_time> "
  47                            "\n",
  48                            argv [0]),
  49                           -1);
  50       }
  51
  52   // Indicates successful parsing of the command line
  53   return 0;
  54 }
  55
  56 int
  57 write_ior_to_file (CORBA::ORB_ptr orb,
  58                    test_ptr test)
  59 {
  60   CORBA::String_var ior =
  61     orb->object_to_string (test);
  62
  63   char filename[BUFSIZ];
  64   ACE_OS::sprintf (filename,
  65                    "%s_%d",
  66                    ACE_TEXT_ALWAYS_CHAR (ior_output_file),
  67                    ior_count++);
  68
  69   FILE *output_file =
  70     ACE_OS::fopen (filename,
  71                    "w");
  72
  73   if (output_file == 0)
  74     ACE_ERROR_RETURN ((LM_ERROR,
  75                        "Cannot open output file for writing IOR: %s",
  76                        filename),
  77                       -1);
  78
  79   ACE_OS::fprintf (output_file,
  80                    "%s",
  81                    ior.in ());
  82
  83   ACE_OS::fclose (output_file);
  84
  85   return 0;
  86 }
  87
  88 int
  89 create_POA_and_register_servant (CORBA::Policy_ptr threadpool_policy,
  90                                  const char *poa_name,
  91                                  PortableServer::POAManager_ptr poa_manager,
  92                                  PortableServer::POA_ptr root_poa,
  93                                  CORBA::ORB_ptr orb,
  94                                  RTCORBA::RTORB_ptr rt_orb)
  95 {
  96   // Policies for the firstPOA to be created.
  97   CORBA::PolicyList policies (3); policies.length (3);
  98
  99   // Implicit_activation policy.
 100   policies[0] =
 101     root_poa->create_implicit_activation_policy
 102     (PortableServer::IMPLICIT_ACTIVATION);
 103
 104   // Thread pool policy.
 105   policies[1] =
 106     CORBA::Policy::_duplicate (threadpool_policy);
 107
 108   // Priority Model policy.
 109   policies[2] =
 110     rt_orb->create_priority_model_policy (RTCORBA::CLIENT_PROPAGATED,
 111                                           0);
 112
 113   // Create the POA under the RootPOA.
 114   PortableServer::POA_var poa =
 115     root_poa->create_POA (poa_name,
 116                           poa_manager,
 117                           policies);
 118
 119   // Creation of POAs is over. Destroy the Policy objects.
 120   for (CORBA::ULong i = 0;
 121        i < policies.length ();
 122        ++i)
 123     {
 124       policies[i]->destroy ();
 125     }
 126
 127   test_i *servant =
 128     new test_i (orb,
 129                 poa.in (),
 130                 nap_time);
 131
 132   PortableServer::ServantBase_var safe_servant (servant);
 133   ACE_UNUSED_ARG (safe_servant);
 134
 135   PortableServer::ObjectId_var id =
 136     poa->activate_object (servant);
 137
 138   CORBA::Object_var object = poa->id_to_reference (id.in ());
 139
 140   test_var test =
 141     test::_narrow (object.in ());
 142
 143   int result =
 144     write_ior_to_file (orb,
 145                        test.in ());
 146
 147   return result;
 148 }
 149
 150 class Task : public ACE_Task_Base
 151 {
 152 public:
 153
 154   Task (ACE_Thread_Manager &thread_manager,
 155         CORBA::ORB_ptr orb);
 156
 157   int svc (void);
 158
 159   CORBA::ORB_var orb_;
 160
 161 };
 162
 163 Task::Task (ACE_Thread_Manager &thread_manager,
 164             CORBA::ORB_ptr orb)
 165   : ACE_Task_Base (&thread_manager),
 166     orb_ (CORBA::ORB::_duplicate (orb))
 167 {
 168 }
 169
 170 int
 171 Task::svc (void)
 172 {
 173   try
 174     {
 175       CORBA::Object_var object =
 176         this->orb_->resolve_initial_references ("RootPOA");
 177
 178       PortableServer::POA_var root_poa =
 179         PortableServer::POA::_narrow (object.in ());
 180
 181       PortableServer::POAManager_var poa_manager =
 182         root_poa->the_POAManager ();
 183
 184       object =
 185         this->orb_->resolve_initial_references ("RTORB");
 186
 187       RTCORBA::RTORB_var rt_orb =
 188         RTCORBA::RTORB::_narrow (object.in ());
 189
 190       object =
 191         this->orb_->resolve_initial_references ("RTCurrent");
 192
 193       RTCORBA::Current_var current =
 194         RTCORBA::Current::_narrow (object.in ());
 195
 196       RTCORBA::Priority default_thread_priority =
 197         get_implicit_thread_CORBA_priority (this->orb_.in ());
 198
 199       test_i servant (this->orb_.in (),
 200                       root_poa.in (),
 201                       nap_time);
 202       PortableServer::ObjectId_var id =
 203         root_poa->activate_object (&servant);
 204
 205       CORBA::Object_var object_act = root_poa->id_to_reference (id.in ());
 206
 207       test_var test =
 208         test::_narrow (object_act.in ());
 209
 210       int result =
 211         write_ior_to_file (this->orb_.in (),
 212                            test.in ());
 213
 214       if (result != 0)
 215         return result;
 216
 217       poa_manager->activate ();
 218
 219       CORBA::ULong stacksize = 0;
 220       CORBA::Boolean allow_request_buffering = 0;
 221       CORBA::ULong max_buffered_requests = 0;
 222       CORBA::ULong max_request_buffer_size = 0;
 223
 224       RTCORBA::ThreadpoolId threadpool_id_1 =
 225         rt_orb->create_threadpool (stacksize,
 226                                    static_threads,
 227                                    dynamic_threads,
 228                                    default_thread_priority,
 229                                    allow_request_buffering,
 230                                    max_buffered_requests,
 231                                    max_request_buffer_size);
 232
 233       CORBA::Policy_var threadpool_policy_1 =
 234         rt_orb->create_threadpool_policy (threadpool_id_1);
 235
 236       CORBA::Boolean allow_borrowing = 0;
 237       RTCORBA::ThreadpoolLanes lanes (1);
 238       lanes.length (1);
 239
 240       lanes[0].lane_priority = default_thread_priority;
 241       lanes[0].static_threads = static_threads;
 242       lanes[0].dynamic_threads = dynamic_threads;
 243
 244       RTCORBA::ThreadpoolId threadpool_id_2 =
 245         rt_orb->create_threadpool_with_lanes (stacksize,
 246                                               lanes,
 247                                               allow_borrowing,
 248                                               allow_request_buffering,
 249                                               max_buffered_requests,
 250                                               max_request_buffer_size);
 251
 252       CORBA::Policy_var threadpool_policy_2 =
 253         rt_orb->create_threadpool_policy (threadpool_id_2);
 254
 255       result =
 256         create_POA_and_register_servant (threadpool_policy_1.in (),
 257                                          "first_poa",
 258                                          poa_manager.in (),
 259                                          root_poa.in (),
 260                                          this->orb_.in (),
 261                                          rt_orb.in ());
 262       if (result != 0)
 263         return result;
 264
 265       result =
 266         create_POA_and_register_servant (threadpool_policy_2.in (),
 267                                          "second_poa",
 268                                          poa_manager.in (),
 269                                          root_poa.in (),
 270                                          this->orb_.in (),
 271                                          rt_orb.in ());
 272       if (result != 0)
 273         return result;
 274
 275       this->orb_->run ();
 276
 277       this->orb_->destroy ();
 278     }
 279   catch (const CORBA::Exception& ex)
 280     {
 281       ex._tao_print_exception ("Exception caught:");
 282       return -1;
 283     }
 284
 285   return 0;
 286 }
 287
 288 int
 289 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
 290 {
 291   try
 292     {
 293       CORBA::ORB_var orb =
 294         CORBA::ORB_init (argc, argv);
 295
 296       int result =
 297         parse_args (argc, argv);
 298       if (result != 0)
 299         return result;
 300
 301       // Make sure we can support multiple priorities that are required
 302       // for this test.
 303       if (!check_supported_priorities (orb.in ()))
 304         return 2;
 305
 306       // Thread Manager for managing task.
 307       ACE_Thread_Manager thread_manager;
 308
 309       // Create task.
 310       Task task (thread_manager,
 311                  orb.in ());
 312
 313       // Task activation flags.
 314       long flags =
 315         THR_NEW_LWP |
 316         THR_JOINABLE |
 317         orb->orb_core ()->orb_params ()->thread_creation_flags ();
 318
 319       // Activate task.
 320       result =
 321         task.activate (flags);
 322       if (result == -1)
 323         {
 324           if (errno == EPERM)
 325             {
 326               ACE_ERROR_RETURN ((LM_ERROR,
 327                                  "Cannot create thread with scheduling policy %s\n"
 328                                  "because the user does not have the appropriate privileges, terminating program....\n"
 329                                  "Check svc.conf options and/or run as root\n",
 330                                  sched_policy_name (orb->orb_core ()->orb_params ()->ace_sched_policy ())),
 331                                 2);
 332             }
 333           else
 334             // Unexpected error.
 335             ACE_ASSERT (0);
 336         }
 337
 338       // Wait for task to exit.
 339       result =
 340         thread_manager.wait ();
 341       ACE_ASSERT (result != -1);
 342     }
 343   catch (const CORBA::Exception& ex)
 344     {
 345       ex._tao_print_exception ("Exception caught");
 346       return -1;
 347     }
 348
 349   return 0;
 350 }