TAO/tests/AMI_Timeouts/timeout_client.cpp

   1 //=============================================================================
   2 /**
   3  *  @file    timeout_client.cpp
   4  *
   5  *  Tests for proper handling of timeouts with AMI
   6  *
   7  *  @author Michael Kircher <Michael.Kircher@mchp.siemens.de>
   8  */
   9 //=============================================================================
  10
  11 #include "timeout_client.h"
  12 #include "tao/Messaging/Messaging.h"
  13 #include "tao/PolicyC.h"
  14 #include "tao/AnyTypeCode/Any.h"
  15 #include "ace/OS_NS_unistd.h"
  16
  17 TimeoutClient::TimeoutClient (CORBA::ORB_ptr orb,
  18                               TimeoutObj_ptr timeoutObject,
  19                               AMI_TimeoutObjHandler_ptr replyHandlerObject,
  20                               TimeoutHandler_i *timeoutHandler_i,
  21                               unsigned long timeToWait)
  22 : orb_ (CORBA::ORB::_duplicate (orb))
  23   , timeoutObject_ (TimeoutObj::_duplicate (timeoutObject))
  24   , replyHandlerObject_ (AMI_TimeoutObjHandler::_duplicate (replyHandlerObject))
  25   , timeoutHandler_i_ (timeoutHandler_i)
  26   , local_reply_excep_counter_ (0)
  27   , INVOKE_SYNCH (0)
  28   , INVOKE_ASYNCH (1)
  29   , timeToWait_ (timeToWait)
  30 {
  31 }
  32
  33 TimeoutClient::~TimeoutClient ()
  34 {
  35 }
  36
  37 int
  38 TimeoutClient::svc ()
  39 {
  40   this->initialize ();
  41
  42   try
  43     {
  44       // Tests timeouts for synchronous
  45       this->synch_test ();
  46
  47       // Tests AMI timeouts for influences on non-timeout calls
  48       this->none_test ();
  49
  50       // Tests AMI timeouts for accuracy
  51       this->accuracy_test ();
  52
  53       // Tests AMI timeouts for influences on non-timeout calls
  54       this->none_test ();
  55
  56       // shut down remote ORB
  57       timeoutObject_->shutdown ();
  58
  59       ACE_Time_Value tv (0, 20); // wait for the ORB to deliver the shutdown
  60       ACE_OS::sleep (tv);
  61
  62       // shut down local ORB
  63       orb_->shutdown (0);
  64     }
  65   catch (const CORBA::Exception& ex)
  66     {
  67       ex._tao_print_exception ("Caught exception:");
  68       return 1;
  69     }
  70
  71   ACE_DEBUG ((LM_DEBUG,
  72               "TimeoutClient::svc: Done\n\n"));
  73
  74   return 0;
  75 }
  76
  77 int
  78 TimeoutClient::initialize ()
  79 {
  80   try
  81     {
  82       CORBA::Object_var object =
  83         orb_->resolve_initial_references ("ORBPolicyManager");
  84
  85       policy_manager_ =
  86         CORBA::PolicyManager::_narrow (object.in ());
  87     }
  88   catch (const CORBA::Exception& ex)
  89     {
  90       ex._tao_print_exception ("Caught exception:");
  91       return 1;
  92     }
  93
  94   return 0;
  95 }
  96
  97
  98 void
  99 TimeoutClient::send (CORBA::Boolean async,
 100                      unsigned long local_timeout,
 101                      unsigned long remote_sleep)
 102 {
 103   ACE_DEBUG ((LM_DEBUG,
 104               "(%P|%t) Invoking "));
 105   if (async)
 106     ACE_DEBUG ((LM_DEBUG,
 107                 "asynch "));
 108   else
 109     ACE_DEBUG ((LM_DEBUG,
 110                 "synch "));
 111
 112   ACE_DEBUG ((LM_DEBUG,
 113               "local: %dms remote: %dms  ... ",
 114               local_timeout,
 115               remote_sleep));
 116
 117   CORBA::PolicyList policy_list (1);
 118
 119   try
 120     {
 121       if (local_timeout != 0)
 122         {
 123           TimeBase::TimeT timeout = 10000 * local_timeout;
 124
 125           CORBA::Any any_orb;
 126           any_orb <<= timeout;
 127
 128           policy_list.length (1);
 129           policy_list[0] =
 130             orb_->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE,
 131                                  any_orb);
 132
 133           policy_manager_->set_policy_overrides (policy_list,
 134                                                  CORBA::SET_OVERRIDE);
 135         }
 136       else
 137         {
 138           policy_list.length (0);
 139           policy_manager_->set_policy_overrides (policy_list,
 140                                                  CORBA::SET_OVERRIDE);
 141         }
 142
 143
 144       // Start time measurement at the reply handler
 145       timeoutHandler_i_->start ();
 146
 147       if (async)
 148         {
 149           timeoutObject_->sendc_sendTimeToWait (replyHandlerObject_.in (),
 150                                                 remote_sleep);
 151         }
 152       else // synch
 153         {
 154           timeoutObject_->sendTimeToWait (remote_sleep);
 155         }
 156     }
 157   catch (const CORBA::TIMEOUT& )
 158     {
 159       local_reply_excep_counter_++;
 160
 161       // Trap this exception and continue...
 162       ACE_DEBUG ((LM_DEBUG,
 163                   " timeout "));
 164
 165     }
 166
 167   // get rid of the policy, you created before.
 168   try
 169     {
 170       if (local_timeout != 0)
 171         {
 172           policy_list[0]->destroy ();
 173         }
 174     }
 175   catch (const CORBA::Exception&)
 176     {
 177       ACE_DEBUG ((LM_DEBUG,
 178                   "Error: Unexpected exception\n\n"));
 179     }
 180
 181   // wait for responses
 182   ACE_Time_Value tv (0, (local_timeout + remote_sleep)*2000 + 4000);
 183   ACE_OS::sleep (tv);
 184
 185   ACE_Time_Value &elapsed_time = timeoutHandler_i_->elapsed_time ();
 186
 187   if (async)
 188     ACE_DEBUG ((LM_DEBUG,
 189                 " .. needed %dms\n",
 190                 elapsed_time.msec()));
 191   else
 192     ACE_DEBUG ((LM_DEBUG,
 193                 " .. done\n"));
 194 }
 195
 196
 197 int
 198 TimeoutClient::synch_test ()
 199 {
 200   ACE_DEBUG ((LM_DEBUG,
 201               "TimeoutClient::synch_test - Begin\n"));
 202   timeoutHandler_i_->reset_reply_counter ();
 203   timeoutHandler_i_->reset_reply_excep_counter ();
 204   local_reply_excep_counter_ = 0;
 205
 206   this->send (INVOKE_SYNCH,
 207               0,    // local
 208               0);   // remote
 209
 210   this->send (INVOKE_SYNCH,
 211               timeToWait_,    // local
 212               timeToWait_*2); // remote
 213
 214   this->send (INVOKE_SYNCH,
 215               0,    // local
 216               0);   // remote
 217
 218   if (timeoutHandler_i_->reply_counter () != 0
 219    || timeoutHandler_i_->reply_excep_counter () != 0
 220    || local_reply_excep_counter_ != 1)
 221     ACE_DEBUG ((LM_DEBUG,
 222                 "**** Error in replies %d %d %d.\n\n",
 223                 timeoutHandler_i_->reply_counter (),
 224                 timeoutHandler_i_->reply_excep_counter (),
 225                 local_reply_excep_counter_));
 226
 227   ACE_DEBUG ((LM_DEBUG,
 228               "TimeoutClient::synch_test - End\n\n"));
 229
 230   return 0;
 231 }
 232
 233 int
 234 TimeoutClient::accuracy_test ()
 235 {
 236   ACE_DEBUG ((LM_DEBUG,
 237               "TimeoutClient::accuracy_test - Begin\n\n"));
 238
 239   timeoutHandler_i_->reset_reply_counter ();
 240   timeoutHandler_i_->reset_reply_excep_counter ();
 241   local_reply_excep_counter_ = 0;
 242
 243   this->send (INVOKE_ASYNCH,
 244               timeToWait_,
 245               (unsigned long)(timeToWait_*1.5));
 246
 247   this->send (INVOKE_ASYNCH,
 248               timeToWait_,
 249               (unsigned long)(timeToWait_*0.5));
 250
 251   if (timeoutHandler_i_->reply_counter () != 1
 252    || timeoutHandler_i_->reply_excep_counter () != 1
 253    || local_reply_excep_counter_ != 0)
 254     ACE_DEBUG ((LM_DEBUG,
 255                 "**** Error in replies %d %d %d.\n\n",
 256                 timeoutHandler_i_->reply_counter (),
 257                 timeoutHandler_i_->reply_excep_counter (),
 258                 local_reply_excep_counter_));
 259
 260   ACE_DEBUG ((LM_DEBUG,
 261               "TimeoutClient::accuracy_test - End\n\n"));
 262
 263   return 0;
 264 }
 265
 266 int
 267 TimeoutClient::none_test ()
 268 {
 269   ACE_DEBUG ((LM_DEBUG,
 270               "TimeoutClient::none_test - Begin\n\n"));
 271
 272   timeoutHandler_i_->reset_reply_counter ();
 273   timeoutHandler_i_->reset_reply_excep_counter ();
 274   local_reply_excep_counter_ = 0;
 275
 276   this->send (INVOKE_ASYNCH,
 277               0,
 278               0);
 279
 280   this->send (INVOKE_ASYNCH,
 281               timeToWait_,
 282               timeToWait_+10);  // trigger a timeout
 283
 284   this->send (INVOKE_ASYNCH,
 285               timeToWait_,
 286               0);
 287
 288   if (timeoutHandler_i_->reply_counter () != 2
 289    || timeoutHandler_i_->reply_excep_counter () != 1
 290    || local_reply_excep_counter_ != 0)
 291     ACE_DEBUG ((LM_DEBUG,
 292                 "**** Error in replies %d %d %d.\n\n",
 293                 timeoutHandler_i_->reply_counter (),
 294                 timeoutHandler_i_->reply_excep_counter (),
 295                 local_reply_excep_counter_));
 296
 297   ACE_DEBUG ((LM_DEBUG,
 298               "TimeoutClient::none_test - End\n\n"));
 299
 300   return 0;
 301 }