TAO/tests/RTCORBA/Bug_3382_Regression/server.cpp

   1 #include "testS.h"
   2 #include "ace/Get_Opt.h"
   3 #include "ace/Task.h"
   4 #include "tao/ORB_Core.h"
   5 #include "tao/RTCORBA/RTCORBA.h"
   6 #include "tao/RTPortableServer/RTPortableServer.h"
   7 #include "../check_supported_priorities.cpp"
   8
   9 class Test_i : public POA_Test
  10 {
  11   // = TITLE
  12   //   An implementation for the Test interface in test.idl
  13   //
  14 public:
  15   Test_i (CORBA::ORB_ptr orb);
  16   // ctor
  17
  18   // = The Test methods.
  19   void test_method (CORBA::Short priority);
  20
  21   void shutdown ();
  22
  23 private:
  24   CORBA::ORB_var orb_;
  25   // The ORB
  26 };
  27
  28 Test_i::Test_i (CORBA::ORB_ptr orb)
  29   :  orb_ (CORBA::ORB::_duplicate (orb))
  30 {
  31 }
  32
  33 void
  34 Test_i::test_method (CORBA::Short priority)
  35 {
  36   // Use RTCurrent to find out the CORBA priority of the current
  37   // thread.
  38
  39   CORBA::Object_var obj =
  40     this->orb_->resolve_initial_references ("RTCurrent");
  41
  42   RTCORBA::Current_var current =
  43     RTCORBA::Current::_narrow (obj.in ());
  44
  45   if (CORBA::is_nil (obj.in ()))
  46     throw CORBA::INTERNAL ();
  47
  48   CORBA::Short servant_thread_priority =
  49     current->the_priority ();
  50
  51   // Print out the info.
  52   if (servant_thread_priority != priority)
  53     ACE_DEBUG ((LM_DEBUG,
  54                 "ERROR: servant thread priority is not equal "
  55                 "to method argument.\n"));
  56
  57   ACE_DEBUG ((LM_DEBUG,
  58               "Client priority: %d  "
  59               "Servant thread priority: %d\n",
  60               priority, servant_thread_priority));
  61 }
  62
  63 void
  64 Test_i::shutdown ()
  65 {
  66   this->orb_->shutdown (0);
  67 }
  68
  69 //*************************************************************************
  70
  71 const ACE_TCHAR *ior_output_file = ACE_TEXT("test.ior");
  72
  73 // Parse command-line arguments.
  74 int
  75 parse_args (int argc, ACE_TCHAR *argv[])
  76 {
  77   ACE_Get_Opt get_opts (argc, argv, "o:");
  78   int c;
  79
  80   while ((c = get_opts ()) != -1)
  81     switch (c)
  82       {
  83       case 'o':
  84         ior_output_file = get_opts.opt_arg ();
  85         break;
  86
  87       case '?':
  88       default:
  89         ACE_ERROR_RETURN ((LM_ERROR,
  90                            "usage:  %s "
  91                            "-o <iorfile>"
  92                            "\n",
  93                            argv [0]),
  94                           -1);
  95       }
  96
  97   return 0;
  98 }
  99
 100 class Task : public ACE_Task_Base
 101 {
 102 public:
 103
 104   Task (ACE_Thread_Manager &thread_manager,
 105         CORBA::ORB_ptr orb);
 106
 107   int svc (void);
 108
 109   CORBA::ORB_var orb_;
 110
 111 };
 112
 113 Task::Task (ACE_Thread_Manager &thread_manager,
 114             CORBA::ORB_ptr orb)
 115   : ACE_Task_Base (&thread_manager),
 116     orb_ (CORBA::ORB::_duplicate (orb))
 117 {
 118 }
 119
 120 int
 121 Task::svc (void)
 122 {
 123   try
 124     {
 125       CORBA::Object_var object =
 126         this->orb_->resolve_initial_references("RootPOA");
 127
 128       PortableServer::POA_var root_poa =
 129         PortableServer::POA::_narrow (object.in ());
 130
 131       if (CORBA::is_nil (root_poa.in ()))
 132         ACE_ERROR_RETURN ((LM_ERROR,
 133                            "ERROR: Panic <RootPOA> is nil\n"),
 134                           -1);
 135
 136       PortableServer::POAManager_var poa_manager =
 137         root_poa->the_POAManager ();
 138
 139       object = this->orb_->resolve_initial_references ("RTORB");
 140
 141       RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (object.in ());
 142
 143
 144       object =
 145         this->orb_->resolve_initial_references ("RTCurrent");
 146
 147       RTCORBA::Current_var current =
 148         RTCORBA::Current::_narrow (object.in ());
 149
 150       // Create POA with CLIENT_PROPAGATED PriorityModelPolicy,
 151       // and register Test object with it.
 152       CORBA::PolicyList poa_policy_list;
 153       poa_policy_list.length (1);
 154       poa_policy_list[0] =
 155         rt_orb->create_priority_model_policy (RTCORBA::CLIENT_PROPAGATED,
 156                                               0);
 157
 158       PortableServer::POA_var child_poa =
 159         root_poa->create_POA ("Child_POA",
 160                               poa_manager.in (),
 161                               poa_policy_list);
 162
 163       Test_i server_impl (this->orb_.in ());
 164
 165       PortableServer::ObjectId_var id =
 166         child_poa->activate_object (&server_impl);
 167
 168       CORBA::Object_var server =
 169         child_poa->id_to_reference (id.in ());
 170
 171       // Print Object IOR.
 172       CORBA::String_var ior =
 173         this->orb_->object_to_string (server.in ());
 174
 175       ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n\n", ior.in ()));
 176
 177       if (ior_output_file != 0)
 178         {
 179           FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
 180           if (output_file == 0)
 181             ACE_ERROR_RETURN ((LM_ERROR,
 182                                "Cannot open output file for writing IOR: %s",
 183                                ior_output_file),
 184                               -1);
 185           ACE_OS::fprintf (output_file, "%s", ior.in ());
 186           ACE_OS::fclose (output_file);
 187         }
 188
 189       // Get the initial priority of the current thread.
 190       CORBA::Short initial_thread_priority =
 191         get_implicit_thread_CORBA_priority (this->orb_.in ());
 192
 193       current->the_priority (initial_thread_priority);
 194
 195       // Run ORB Event loop.
 196       poa_manager->activate ();
 197
 198       this->orb_->run ();
 199
 200       ACE_DEBUG ((LM_DEBUG, "Server ORB event loop finished\n"));
 201
 202       // Get the final priority of the current thread.
 203       CORBA::Short final_thread_priority =
 204         current->the_priority ();
 205
 206       if (final_thread_priority != initial_thread_priority)
 207         ACE_DEBUG ((LM_DEBUG,
 208                     "ERROR: Priority of the servant thread "
 209                     "has been permanently changed!\n"
 210                     "Initial priority: %d  Final priority: %d\n",
 211                     initial_thread_priority, final_thread_priority));
 212       else
 213         ACE_DEBUG ((LM_DEBUG,
 214                     "Final priority of the servant thread"
 215                     " == its initial priority\n"));
 216
 217     }
 218   catch (const ::CORBA::Exception & ex)
 219     {
 220       ex._tao_print_exception(
 221                            "Exception caught:");
 222       return -1;
 223     }
 224
 225   return 0;
 226 }
 227
 228 int
 229 ACE_TMAIN (int argc, ACE_TCHAR *argv[])
 230 {
 231   int result = 0;
 232
 233   try
 234     {
 235       // Standard initialization:
 236       // parse arguments and get all the references (ORB,
 237       // RootPOA, RTORB, RTCurrent, POAManager).
 238       CORBA::ORB_var orb =
 239         CORBA::ORB_init (argc, argv);
 240
 241       if (parse_args (argc, argv) != 0)
 242         return -1;
 243
 244       // Make sure we can support multiple priorities that are required
 245       // for this test.
 246       if (!check_supported_priorities (orb.in ()))
 247         return 2;
 248
 249       // Thread Manager for managing task.
 250       ACE_Thread_Manager thread_manager;
 251
 252       // Create task.
 253       Task task (thread_manager,
 254                  orb.in ());
 255
 256       // Task activation flags.
 257       long flags =
 258         THR_NEW_LWP |
 259         THR_JOINABLE |
 260         orb->orb_core ()->orb_params ()->thread_creation_flags ();
 261
 262       // Activate task.
 263       result =
 264         task.activate (flags);
 265       if (result == -1)
 266         {
 267           if (errno == EPERM)
 268             {
 269               ACE_ERROR_RETURN ((LM_ERROR,
 270                                  "Cannot create thread with scheduling policy %s\n"
 271                                  "because the user does not have the appropriate privileges, terminating program....\n"
 272                                  "Check svc.conf options and/or run as root\n",
 273                                  sched_policy_name (orb->orb_core ()->orb_params ()->ace_sched_policy ())),
 274                                 2);
 275             }
 276           else
 277             // Unexpected error.
 278             ACE_ERROR_RETURN ((LM_ERROR,
 279                                  "ERROR: Cannot create thread. errno = %d\n",
 280                                  ACE_ERRNO_GET),
 281                                 -1);
 282         }
 283
 284       // Wait for task to exit.
 285       result =
 286         thread_manager.wait ();
 287     }
 288   catch (const ::CORBA::Exception & ex)
 289     {
 290       ex._tao_print_exception(
 291                            "Exception caught:");
 292       return -1;
 293     }
 294
 295   return result;
 296 }