TAO/orbsvcs/tests/Notify/RT_lib/RT_POA_Command.cpp

   1 #include "RT_POA_Command.h"
   2
   3
   4 #include "tao/debug.h"
   5 #include "../lib/LookupManager.h"
   6 #include "../lib/Name.h"
   7
   8 TAO_Notify_Tests_RT_POA_Command::TAO_Notify_Tests_RT_POA_Command ()
   9   :priority_model_ (RTCORBA::CLIENT_PROPAGATED)
  10   , server_priority_ (0)
  11   , thread_pool_static_threads_ (0)
  12   , thread_pool_default_priority_ (0)
  13 {
  14 }
  15
  16 TAO_Notify_Tests_RT_POA_Command::~TAO_Notify_Tests_RT_POA_Command ()
  17 {
  18 }
  19
  20 const char*
  21 TAO_Notify_Tests_RT_POA_Command::get_name ()
  22 {
  23   return TAO_Notify_Tests_RT_POA_Command::name ();
  24 }
  25
  26 const char*
  27 TAO_Notify_Tests_RT_POA_Command::name ()
  28 {
  29   return TAO_Notify_Tests_Name::poa_command;
  30 }
  31
  32 void
  33 TAO_Notify_Tests_RT_POA_Command::init (ACE_Arg_Shifter& arg_shifter)
  34 {
  35   const ACE_TCHAR *current_arg = 0;
  36
  37   if (arg_shifter.is_anything_left ())
  38     {
  39       if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-Create")) == 0)
  40         {
  41           this->command_ = CREATE;
  42
  43           arg_shifter.consume_arg ();
  44
  45           this->POA_name_ = ACE_TEXT_ALWAYS_CHAR(arg_shifter.get_current ());
  46
  47           arg_shifter.consume_arg ();
  48
  49           while (arg_shifter.is_anything_left ())
  50             {
  51               if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-PriorityModel"))))
  52                 {
  53                   if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("CLIENT")) == 0)
  54                     priority_model_ = RTCORBA::CLIENT_PROPAGATED;
  55                   else
  56                     priority_model_ = RTCORBA::SERVER_DECLARED;
  57                   arg_shifter.consume_arg ();
  58
  59                   server_priority_ = ACE_OS::atoi (current_arg);
  60                   arg_shifter.consume_arg ();
  61
  62                   continue;
  63                 }
  64               // -Lanes lane-count -Lane prio statc_thr dyn_thr
  65               if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-Lanes"))))
  66                 {
  67                   int lanecount = ACE_OS::atoi (current_arg);
  68                   lanes_.length (lanecount);
  69                   arg_shifter.consume_arg ();
  70
  71                   int l_index = 0;
  72                   //parse lane values ...
  73                   while (arg_shifter.is_anything_left ())
  74                     {
  75                       if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-Lane")) == 0)
  76                         {
  77                           arg_shifter.consume_arg ();
  78
  79                           // read priority
  80                           lanes_[l_index].lane_priority = ACE_OS::atoi (arg_shifter.get_current ());
  81                           arg_shifter.consume_arg ();
  82
  83                           // static thread count
  84                           lanes_[l_index].static_threads = ACE_OS::atoi (arg_shifter.get_current ());
  85                           arg_shifter.consume_arg ();
  86
  87                           // dynamic thread count
  88                           lanes_[l_index].dynamic_threads = ACE_OS::atoi (arg_shifter.get_current ());
  89                           arg_shifter.consume_arg ();
  90
  91                           if (TAO_debug_level > 0)
  92                             ACE_DEBUG ((LM_DEBUG, "POA Create: lane parsed - %d, %d, %d\n",
  93                                         lanes_[l_index].lane_priority, lanes_[l_index].static_threads, lanes_[l_index].dynamic_threads));
  94                           l_index++;
  95                         }
  96                       else
  97                         break;
  98                     } /* while -- lane values */
  99
 100                   continue;
 101                 } /* if -Lanes */
 102
 103               if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-Bands"))))
 104                 {
 105                   int bandcount = ACE_OS::atoi (current_arg);
 106                   bands_.length (bandcount);
 107                   arg_shifter.consume_arg ();
 108
 109                   int b_index = 0;
 110                   //parse band values ...
 111                   while (arg_shifter.is_anything_left ())
 112                     {
 113                       if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-Band")) == 0)
 114                         {
 115                           arg_shifter.consume_arg ();
 116
 117                           // read low
 118                           bands_[b_index].low = ACE_OS::atoi (arg_shifter.get_current ());
 119                           arg_shifter.consume_arg ();
 120
 121                           // read high
 122                           bands_[b_index].high = ACE_OS::atoi (arg_shifter.get_current ());
 123                           arg_shifter.consume_arg ();
 124
 125                           if (TAO_debug_level > 0)
 126                             ACE_DEBUG ((LM_DEBUG, "POA Create: band parsed - %d, %d\n",
 127                                         bands_[b_index].low, bands_[b_index].high));
 128                           b_index++;
 129                         }
 130                       else
 131                         break;
 132                     } /* while -- Band values */
 133
 134                   continue;
 135                 } /* if -Bands */
 136
 137               // -ThreadPool thread_pool_count thread_pool_default_priority
 138               if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-ThreadPool")) == 0)
 139                 {
 140                   arg_shifter.consume_arg ();
 141
 142                   current_arg = arg_shifter.get_current ();
 143                   this->thread_pool_static_threads_ = ACE_OS::atoi (current_arg);
 144
 145                   arg_shifter.consume_arg ();
 146
 147                   current_arg = arg_shifter.get_current ();
 148                   this->thread_pool_default_priority_ = ACE_OS::atoi (current_arg);
 149
 150                   arg_shifter.consume_arg ();
 151
 152                   if (TAO_debug_level > 0)
 153                     ACE_DEBUG ((LM_DEBUG, "ThreadPool parsed - static threads = %d, prio = %d\n",
 154                                 this->thread_pool_static_threads_, this->thread_pool_default_priority_));
 155
 156                   continue;
 157                 } /* ThreadPool */
 158
 159               // none of the matched so break out...
 160               break;
 161             } /* while */
 162         }
 163       else if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-Destroy")) == 0)
 164         {
 165           this->command_ = DESTROY;
 166
 167           arg_shifter.consume_arg ();
 168
 169           this->POA_name_ = ACE_TEXT_ALWAYS_CHAR(arg_shifter.get_current ());
 170
 171           arg_shifter.consume_arg ();
 172         }
 173     } /* if */
 174 }
 175
 176 void
 177 TAO_Notify_Tests_RT_POA_Command::execute_i ()
 178 {
 179   if (this->command_ == CREATE)
 180     {
 181       // Resolve ORB
 182       CORBA::ORB_var orb;
 183
 184       LOOKUP_MANAGER->resolve (orb);
 185
 186       // Resolve RTORB
 187       CORBA::Object_var object =
 188         orb->resolve_initial_references ("RTORB");
 189
 190       RTCORBA::RTORB_var rt_orb =
 191         RTCORBA::RTORB::_narrow (object.in ());
 192
 193       // Resolve parent poa.
 194       PortableServer::POA_var parent_poa;
 195
 196       LOOKUP_MANAGER->resolve (parent_poa);
 197
 198       // Create the POA.
 199       this->create (rt_orb.in (), parent_poa.in ());
 200
 201       ACE_DEBUG ((LM_DEBUG, "Created RT POA %s\n", this->POA_name_.c_str ()));
 202     }
 203   else if (this->command_ == DESTROY)
 204     {
 205       PortableServer::POA_var poa;
 206
 207       LOOKUP_MANAGER->resolve (poa, this->POA_name_.c_str ());
 208
 209       poa->destroy (1,0);
 210
 211       ACE_DEBUG ((LM_DEBUG, "Destroyed RT POA %s\n", this->POA_name_.c_str ()));
 212     }
 213 }
 214
 215 void
 216 TAO_Notify_Tests_RT_POA_Command::create (RTCORBA::RTORB_ptr rt_orb, PortableServer::POA_ptr parent_poa)
 217 {
 218   /*
 219     lanes bands priomodel
 220
 221     if lanes create lanespolicy
 222     if bands create bands policy
 223
 224     if lanes and bands , policy_list_length = 3
 225     else
 226     if lanes policy_list_length = 2
 227     else
 228     if threadpool and bands , policy_list_length = 3
 229     else
 230     if threadpool policy_list_length = 2
 231     else
 232     if bands policy_list_length = 2
 233     else
 234     policy_list_length = 1
 235
 236    */
 237
 238   CORBA::Policy_var priority_model_policy;
 239   CORBA::Policy_var lanes_policy;
 240   CORBA::Policy_var thread_pool_policy;
 241   CORBA::Policy_var bands_policy;
 242
 243   // Create a priority model policy.
 244   priority_model_policy =
 245     rt_orb->create_priority_model_policy (priority_model_,
 246                                           server_priority_);
 247
 248   if (lanes_.length () != 0)
 249     {
 250       // Create a thread-pool.
 251       CORBA::ULong stacksize = 0;
 252       CORBA::Boolean allow_request_buffering = 0;
 253       CORBA::ULong max_buffered_requests = 0;
 254       CORBA::ULong max_request_buffer_size = 0;
 255       CORBA::Boolean allow_borrowing = 0;
 256       // CORBA::ULong static_threads = 1;
 257       // CORBA::ULong dynamic_threads = 0;
 258
 259       // Create the thread-pool.
 260       RTCORBA::ThreadpoolId threadpool_id =
 261         rt_orb->create_threadpool_with_lanes (stacksize,
 262                                               lanes_,
 263                                               allow_borrowing,
 264                                               allow_request_buffering,
 265                                               max_buffered_requests,
 266                                               max_request_buffer_size);
 267
 268
 269       // Create a thread-pool policy.
 270       lanes_policy =
 271         rt_orb->create_threadpool_policy (threadpool_id);
 272     }
 273   else if (thread_pool_static_threads_ > 0)
 274     {
 275       CORBA::ULong stacksize = 0;
 276       CORBA::ULong static_threads = this->thread_pool_static_threads_;
 277       CORBA::ULong dynamic_threads = 0;
 278       RTCORBA::Priority default_priority = this->thread_pool_default_priority_;
 279       CORBA::Boolean allow_request_buffering = 0;
 280       CORBA::ULong max_buffered_requests = 0;
 281       CORBA::ULong max_request_buffer_size = 0;
 282
 283        // Create the thread-pool.
 284       RTCORBA::ThreadpoolId threadpool_id =
 285       rt_orb->create_threadpool (stacksize,
 286                                  static_threads,
 287                                  dynamic_threads,
 288                                  default_priority,
 289                                  allow_request_buffering,
 290                                  max_buffered_requests,
 291                                  max_request_buffer_size);
 292
 293       thread_pool_policy =
 294                 rt_orb->create_threadpool_policy (threadpool_id);
 295     }
 296
 297   if (bands_.length () != 0)
 298     {
 299       // Create a bands policy.
 300       bands_policy =
 301         rt_orb->create_priority_banded_connection_policy (this->bands_);
 302     }
 303
 304   CORBA::PolicyList poa_policy_list;
 305
 306   CORBA::Policy_var activation_policy =
 307     parent_poa->create_implicit_activation_policy (PortableServer::IMPLICIT_ACTIVATION);
 308
 309   if (lanes_.length () == 0 && thread_pool_static_threads_ == 0 && bands_.length () == 0)
 310     {
 311       poa_policy_list.length (1);
 312       poa_policy_list[0] = priority_model_policy;
 313     }
 314   else if (lanes_.length () == 0 && thread_pool_static_threads_ == 0 && bands_.length () > 0)
 315     {
 316       poa_policy_list.length (2);
 317       poa_policy_list[0] = priority_model_policy;
 318       poa_policy_list[1] = bands_policy;
 319     }
 320   else if (lanes_.length () == 0 && thread_pool_static_threads_ > 0 && bands_.length () == 0)
 321     {
 322       poa_policy_list.length (2);
 323       poa_policy_list[0] = priority_model_policy;
 324       poa_policy_list[1] = thread_pool_policy;
 325     }
 326   else if (lanes_.length () == 0 && thread_pool_static_threads_ > 0 && bands_.length () > 0)
 327     {
 328       poa_policy_list.length (3);
 329       poa_policy_list[0] = priority_model_policy;
 330       poa_policy_list[1] = bands_policy;
 331       poa_policy_list[2] = thread_pool_policy;
 332     }
 333   else if (lanes_.length () > 0 && thread_pool_static_threads_ == 0 && bands_.length () == 0)
 334     {
 335       poa_policy_list.length (2);
 336       poa_policy_list[0] = priority_model_policy;
 337       poa_policy_list[1] = lanes_policy;
 338     }
 339   else if (lanes_.length () > 0 && thread_pool_static_threads_ == 0 && bands_.length () > 0)
 340     {
 341       poa_policy_list.length (3);
 342       poa_policy_list[0] = priority_model_policy;
 343       poa_policy_list[1] = bands_policy;
 344       poa_policy_list[2] = lanes_policy;
 345     }
 346
 347   // Add the activation policy
 348   int act_index = poa_policy_list.length ();
 349   poa_policy_list.length (act_index + 1);
 350
 351   poa_policy_list[act_index] = activation_policy;
 352
 353   if (TAO_debug_level > 0)
 354     ACE_DEBUG ((LM_DEBUG, "creating POA %C\n", POA_name_.c_str ()));
 355
 356   // Get the POA Manager.
 357   PortableServer::POAManager_var poa_manager =
 358     parent_poa->the_POAManager ();
 359
 360   parent_poa->create_POA (POA_name_.c_str (),
 361                           poa_manager.in (),
 362                           poa_policy_list);
 363 }