TAO/tests/Policies/Manipulation.cpp

   1 #include "testC.h"
   2
   3 #include "tao/Messaging/Messaging.h"
   4 #include "tao/AnyTypeCode/Any.h"
   5 #include "tao/AnyTypeCode/TAOA.h"
   6 #include "tao/TAOC.h"
   7 #include "tao/Object_T.h"
   8 #include "ace/Get_Opt.h"
   9 #include "ace/Task.h"
  10 #include "ace/OS_NS_time.h"
  11
  12 int nthreads = 5;
  13 int niterations = 100;
  14
  15 int
  16 parse_args (int argc, ACE_TCHAR *argv[])
  17 {
  18   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("n:i:"));
  19   int c;
  20
  21   while ((c = get_opts ()) != -1)
  22     switch (c)
  23       {
  24       case 'n':
  25         nthreads = ACE_OS::atoi (get_opts.opt_arg ());
  26         break;
  27       case 'i':
  28         niterations = ACE_OS::atoi (get_opts.opt_arg ());
  29         break;
  30       case '?':
  31       default:
  32         ACE_ERROR_RETURN ((LM_ERROR,
  33                            "usage:  %s "
  34                            "-n <nthreads> "
  35                            "-i <niterations> "
  36                            "\n",
  37                            argv [0]),
  38                           -1);
  39       }
  40   // Indicates successful parsing of the command line
  41   return 0;
  42 }
  43
  44 /**
  45  * Run the client thread
  46  *
  47  * Use the ACE_Task_Base class to run the client threads.
  48  */
  49 class Manipulation : public ACE_Task_Base
  50 {
  51 public:
  52   Manipulation (CORBA::ORB_ptr orb,
  53                 Test_ptr test,
  54                 int niterations);
  55
  56   /// The thread entry point.
  57   virtual int svc ();
  58
  59 private:
  60   void perform_iteration (unsigned int *seed,
  61                           CORBA::PolicyList_var &policies,
  62                           CORBA::PolicyManager_ptr policy_manager,
  63                           CORBA::PolicyCurrent_ptr policy_current);
  64
  65 private:
  66   /// The ORB pointer
  67   CORBA::ORB_var orb_;
  68
  69   /// The test object reference
  70   Test_var test_;
  71
  72   /// The number of iterations on this thread
  73   int niterations_;
  74 };
  75
  76 int
  77 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
  78 {
  79   try
  80     {
  81       CORBA::ORB_var orb =
  82         CORBA::ORB_init (argc, argv);
  83
  84       if (parse_args (argc, argv) != 0)
  85         return 1;
  86
  87       CORBA::Object_var object =
  88         orb->string_to_object ("corbaloc:iiop:localhost:12345/FakeIOR");
  89
  90       Test_var test =
  91         TAO::Narrow_Utils<Test>::unchecked_narrow (object.in ());
  92
  93       if (CORBA::is_nil (test.in ()))
  94         {
  95           ACE_ERROR_RETURN ((LM_ERROR,
  96                              "Object reference is nil\n"),
  97                             1);
  98         }
  99
 100       Manipulation manipulation (orb.in (),
 101                      test.in (),
 102                      niterations);
 103       if (manipulation.activate (THR_NEW_LWP | THR_JOINABLE,
 104                            nthreads) != 0)
 105         ACE_ERROR_RETURN ((LM_ERROR,
 106                            "Cannot activate manipulation threads\n"),
 107                           1);
 108
 109       manipulation.thr_mgr ()->wait ();
 110
 111       ACE_DEBUG ((LM_DEBUG, "threads finished\n"));
 112
 113       orb->destroy ();
 114     }
 115   catch (const CORBA::Exception& ex)
 116     {
 117       ex._tao_print_exception ("Caught exception:");
 118       return 1;
 119     }
 120
 121   return 0;
 122 }
 123
 124 // ****************************************************************
 125
 126 Manipulation::Manipulation (CORBA::ORB_ptr orb,
 127                 Test_ptr test,
 128                 int niterations)
 129   :  orb_ (CORBA::ORB::_duplicate (orb)),
 130      test_ (Test::_duplicate (test)),
 131      niterations_ (niterations)
 132 {
 133 }
 134
 135 void
 136 Manipulation::perform_iteration (unsigned int *seed,
 137                                  CORBA::PolicyList_var &policies,
 138                                  CORBA::PolicyManager_ptr policy_manager,
 139                                  CORBA::PolicyCurrent_ptr policy_current)
 140 {
 141   try
 142     {
 143       int r = ACE_OS::rand_r (seed);
 144
 145       const int ADD_OBJECT_POLICY  = 0;
 146       const int ADD_CURRENT_POLICY = 1;
 147       const int ADD_MANAGER_POLICY = 2;
 148
 149       const int SET_OBJECT_POLICY  = 3;
 150       const int SET_CURRENT_POLICY = 4;
 151       const int SET_MANAGER_POLICY = 5;
 152
 153       const int SAVE_CURRENT_POLICIES    = 6;
 154       const int RESTORE_CURRENT_POLICIES = 7;
 155       const int SAVE_MANAGER_POLICIES    = 8;
 156       // const int RESTORE_MANAGER_POLICIES = 9;
 157       const int LAST_OPERATION   = 10;
 158       int operation = r % LAST_OPERATION;
 159
 160       if (operation == ADD_OBJECT_POLICY
 161           || operation == ADD_CURRENT_POLICY
 162           || operation == ADD_MANAGER_POLICY
 163           || operation ==  SET_OBJECT_POLICY
 164           || operation ==  SET_CURRENT_POLICY
 165           || operation ==  SET_MANAGER_POLICY)
 166         {
 167           CORBA::Policy_var policy;
 168
 169           CORBA::Any any;
 170           CORBA::ULong policy_type = 0;
 171
 172           int type = ACE_OS::rand_r (seed) % 3;
 173           if (type == 0)
 174             {
 175               TimeBase::TimeT value = 0;
 176               any <<= value;
 177
 178               policy_type =
 179                 Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE;
 180             }
 181           else if (type == 1)
 182             {
 183               TAO::BufferingConstraint value;
 184               any <<= value;
 185
 186               policy_type =
 187                 TAO::BUFFERING_CONSTRAINT_POLICY_TYPE;
 188             }
 189           else // type == 2 (or something else)
 190             {
 191               Messaging::SyncScope value = 0;
 192               any <<= value;
 193
 194               policy_type =
 195                 Messaging::SYNC_SCOPE_POLICY_TYPE;
 196             }
 197
 198           policy = this->orb_->create_policy (policy_type,
 199                                               any);
 200
 201           CORBA::SetOverrideType override_type = CORBA::SET_OVERRIDE;
 202           if (operation == ADD_OBJECT_POLICY
 203               || operation == ADD_CURRENT_POLICY
 204               || operation == ADD_MANAGER_POLICY)
 205             {
 206               override_type = CORBA::ADD_OVERRIDE;
 207             }
 208
 209           CORBA::PolicyList policy_list (1);
 210           policy_list.length (1);
 211           policy_list[0] = CORBA::Policy::_duplicate (policy.in ());
 212
 213           if (operation == ADD_OBJECT_POLICY
 214               || operation == SET_OBJECT_POLICY)
 215             {
 216               CORBA::Object_var tmp =
 217                 this->test_->_set_policy_overrides (policy_list,
 218                                                     override_type);
 219             }
 220           else if (operation == ADD_CURRENT_POLICY
 221                    || operation == SET_CURRENT_POLICY)
 222             {
 223               policy_current->set_policy_overrides (policy_list,
 224                                                     override_type);
 225             }
 226           else
 227             {
 228               // operation == ADD_CURRENT_POLICY
 229               // || operation == SET_CURRENT_POLICY)
 230               policy_manager->set_policy_overrides (policy_list,
 231                                                     override_type);
 232             }
 233           policy_list[0]->destroy ();
 234         }
 235       else if (operation == SAVE_CURRENT_POLICIES)
 236         {
 237           CORBA::PolicyTypeSeq types;
 238           policies =
 239             policy_current->get_policy_overrides (types);
 240         }
 241       else if (operation == SAVE_MANAGER_POLICIES)
 242         {
 243           CORBA::PolicyTypeSeq types;
 244           policies =
 245             policy_manager->get_policy_overrides (types);
 246         }
 247       else if (operation == RESTORE_CURRENT_POLICIES)
 248         {
 249           if (policies.ptr () != 0)
 250             {
 251               policy_current->set_policy_overrides (policies.in (),
 252                                                     CORBA::SET_OVERRIDE);
 253             }
 254         }
 255       else // operation == RESTORE_MANAGER_POLICIES)
 256         {
 257           if (policies.ptr () != 0)
 258             {
 259               policy_manager->set_policy_overrides (policies.in (),
 260                                                     CORBA::SET_OVERRIDE);
 261             }
 262         }
 263     }
 264   catch (const CORBA::Exception&)
 265     {
 266       // Ignore all exceptions
 267     }
 268 }
 269
 270
 271 int
 272 Manipulation::svc ()
 273 {
 274   try
 275     {
 276       unsigned int seed =
 277         static_cast<unsigned int> (ACE_OS::gethrtime ());
 278       CORBA::Object_var object =
 279         this->orb_->resolve_initial_references ("ORBPolicyManager");
 280
 281       CORBA::PolicyManager_var policy_manager =
 282         CORBA::PolicyManager::_narrow (object.in ());
 283
 284       object =
 285         this->orb_->resolve_initial_references ("PolicyCurrent");
 286
 287       CORBA::PolicyCurrent_var policy_current =
 288         CORBA::PolicyCurrent::_narrow (object.in ());
 289
 290       for (int i = 0; i != this->niterations_; ++i)
 291         {
 292           CORBA::PolicyList_var policies;
 293           this->perform_iteration (&seed,
 294                                    policies,
 295                                    policy_manager.in (),
 296                                    policy_current.in ());
 297         }
 298     }
 299   catch (const CORBA::Exception& ex)
 300     {
 301       ex._tao_print_exception ("Manipulation: exception raised");
 302     }
 303   return 0;
 304 }