TAO/tests/RTCORBA/Bug_3382_Regression/client.cpp

   1 #include "testC.h"
   2 #include "ace/Task.h"
   3 #include "tao/ORB_Core.h"
   4 #include "Client_ORBInitializer.h"
   5 #include "tao/ORBInitializer_Registry.h"
   6 #include "tao/RTCORBA/RTCORBA.h"
   7 #include "tao/RTCORBA/Priority_Mapping_Manager.h"
   8 #include "ace/Get_Opt.h"
   9 #include "../check_supported_priorities.cpp"
  10
  11 const ACE_TCHAR *ior = ACE_TEXT("file://test.ior");
  12
  13 int
  14 parse_args (int argc, ACE_TCHAR *argv[])
  15 {
  16   ACE_Get_Opt get_opts (argc, argv, "k:");
  17   int c;
  18
  19   while ((c = get_opts ()) != -1)
  20     switch (c)
  21       {
  22       case 'k':
  23         ior = get_opts.opt_arg ();
  24         break;
  25       case '?':
  26       default:
  27         ACE_ERROR_RETURN ((LM_ERROR,
  28                            "usage:  %s "
  29                            "-k <ior> "
  30                            "\n",
  31                            argv [0]),
  32                           -1);
  33       }
  34
  35   return 0;
  36 }
  37
  38 class Task : public ACE_Task_Base
  39 {
  40 public:
  41
  42   Task (ACE_Thread_Manager &thread_manager,
  43         CORBA::ORB_ptr orb);
  44
  45   int svc (void);
  46
  47   CORBA::ORB_var orb_;
  48 };
  49
  50 Task::Task (ACE_Thread_Manager &thread_manager,
  51             CORBA::ORB_ptr orb)
  52   : ACE_Task_Base (&thread_manager),
  53     orb_ (CORBA::ORB::_duplicate (orb))
  54 {
  55 }
  56
  57 int
  58 Task::svc (void)
  59 {
  60
  61   int result = 0;
  62   try
  63     {
  64       CORBA::Object_var object =
  65         this->orb_->string_to_object (ior);
  66
  67       Test_var server =
  68         Test::_narrow (object.in ());
  69
  70       if (CORBA::is_nil (server.in ()))
  71         {
  72           ACE_ERROR_RETURN ((LM_ERROR,
  73                              "ERROR: Object reference <%s> is nil\n",
  74                              ior),
  75                             -1);
  76         }
  77
  78       // Check that the object is configured with CLIENT_PROPAGATED
  79       // PriorityModelPolicy.
  80       CORBA::Policy_var policy =
  81         server->_get_policy (RTCORBA::PRIORITY_MODEL_POLICY_TYPE);
  82
  83       RTCORBA::PriorityModelPolicy_var priority_policy =
  84         RTCORBA::PriorityModelPolicy::_narrow (policy.in ());
  85
  86       if (CORBA::is_nil (priority_policy.in ()))
  87         ACE_ERROR_RETURN ((LM_ERROR,
  88                            "ERROR: Priority Model Policy not exposed!\n"),
  89                           -1);
  90
  91       RTCORBA::PriorityModel priority_model =
  92         priority_policy->priority_model ();
  93
  94       if (priority_model != RTCORBA::CLIENT_PROPAGATED)
  95         ACE_ERROR_RETURN ((LM_ERROR,
  96                            "ERROR: priority_model != "
  97                            "RTCORBA::CLIENT_PROPAGATED!\n"),
  98                           -1);
  99
 100       // Make several invocations, changing the priority of this thread
 101       // for each.
 102       object =
 103         this->orb_->resolve_initial_references ("RTCurrent");
 104
 105       RTCORBA::Current_var current =
 106         RTCORBA::Current::_narrow (object.in ());
 107
 108       object = this->orb_->resolve_initial_references ("PriorityMappingManager");
 109
 110       RTCORBA::PriorityMappingManager_var mapping_manager =
 111         RTCORBA::PriorityMappingManager::_narrow (object.in ());
 112
 113       RTCORBA::PriorityMapping *pm =
 114         mapping_manager->mapping ();
 115
 116       int sched_policy =
 117         this->orb_->orb_core ()->orb_params ()->ace_sched_policy ();
 118
 119       int max_priority =
 120         ACE_Sched_Params::priority_max (sched_policy);
 121       int min_priority =
 122         ACE_Sched_Params::priority_min (sched_policy);
 123
 124       CORBA::Short native_priority =
 125         (max_priority - min_priority) / 2;
 126
 127       CORBA::Short desired_priority = 0;
 128
 129       for (int i = 0; i < 3; ++i)
 130         {
 131           if (pm->to_CORBA (native_priority, desired_priority) == 0)
 132             {
 133               ACE_ERROR ((LM_ERROR,
 134                            "ERROR: Cannot convert native priority %d to corba priority\n",
 135                            native_priority));
 136               result = -1;
 137               break;
 138             }
 139
 140           current->the_priority (desired_priority);
 141
 142           CORBA::Short priority =
 143             current->the_priority ();
 144
 145           if (desired_priority != priority)
 146             {
 147               ACE_ERROR ((LM_ERROR,
 148                                "ERROR: No exception setting the priority but mismatch between requested and returned value from Current. "
 149                                "Set to %d but Current::the_priority returns %d\n", desired_priority, priority));
 150               result = -1;
 151             }
 152
 153
 154           server->test_method (priority);
 155
 156           native_priority++;
 157         }
 158
 159       // Shut down Server ORB.
 160       server->shutdown ();
 161     }
 162   catch (const CORBA::DATA_CONVERSION& ex)
 163     {
 164       ex._tao_print_exception (
 165                           "Most likely, this is due to the in-ability "
 166                           "to set the thread priority.");
 167       return -1;
 168     }
 169   catch (const CORBA::Exception & ae)
 170     {
 171       ae._tao_print_exception (
 172                            "Caught exception:");
 173       return -1;
 174     }
 175
 176   return result;
 177 }
 178
 179 int
 180 ACE_TMAIN (int argc, ACE_TCHAR *argv[])
 181 {
 182   int result = 0;
 183   try
 184     {
 185       // Register the interceptors to check for the RTCORBA
 186       // service contexts in the reply messages.
 187       PortableInterceptor::ORBInitializer_ptr temp_initializer;
 188
 189       ACE_NEW_RETURN (temp_initializer,
 190                       Client_ORBInitializer,
 191                       -1);  // No exceptions yet!
 192       PortableInterceptor::ORBInitializer_var initializer =
 193         temp_initializer;
 194
 195       PortableInterceptor::register_orb_initializer (initializer.in ());
 196
 197       // Initialize and obtain reference to the Test object.
 198       CORBA::ORB_var orb =
 199         CORBA::ORB_init (argc, argv);
 200
 201       if (parse_args (argc, argv) != 0)
 202         return -1;
 203
 204       // Make sure we can support multiple priorities that are required
 205       // for this test.
 206       if (!check_supported_priorities (orb.in ()))
 207         return 2;
 208
 209       // Thread Manager for managing task.
 210       ACE_Thread_Manager thread_manager;
 211
 212       // Create task.
 213       Task task (thread_manager,
 214                  orb.in ());
 215
 216       // Task activation flags.
 217       long flags =
 218         THR_NEW_LWP |
 219         THR_JOINABLE |
 220         orb->orb_core ()->orb_params ()->thread_creation_flags ();
 221
 222       // Activate task.
 223       result =
 224         task.activate (flags);
 225       if (result == -1)
 226         {
 227           if (errno == EPERM)
 228             {
 229               ACE_ERROR_RETURN ((LM_ERROR,
 230                                  "Cannot create thread with scheduling policy %s\n"
 231                                  "because the user does not have the appropriate privileges, terminating program....\n"
 232                                  "Check svc.conf options and/or run as root\n",
 233                                  sched_policy_name (orb->orb_core ()->orb_params ()->ace_sched_policy ())),
 234                                 2);
 235             }
 236           else
 237             // Unexpected error.
 238             ACE_ERROR_RETURN ((LM_ERROR,
 239                                  "ERROR: Cannot create thread. errno = %d\n",
 240                                  ACE_ERRNO_GET),
 241                                 -1);
 242         }
 243
 244       // Wait for task to exit.
 245       result =
 246         thread_manager.wait ();
 247     }
 248   catch (const CORBA::Exception & ae)
 249     {
 250       ae._tao_print_exception (
 251                            "Caught exception:");
 252       return -1;
 253     }
 254
 255   return result;
 256 }