TAO/tests/Mixed_Sync_ASync_Events/test_i.cpp

   1 //=============================================================================
   2 /**
   3  *  @file    test_i.cpp
   4  *
   5  *  Implementation of the Test interface.
   6  */
   7 //=============================================================================
   8
   9 #include "test_i.h"
  10 #include "tao/debug.h"
  11 #include "tao/ORB_Core.h"
  12 #include "ace/Reactor.h"
  13 #include "ace/OS_NS_time.h"
  14
  15 Test_i::Test_i (CORBA::ORB_ptr orb,
  16                 A::AMI_TestHandler_ptr rh,
  17                 A::RunMode mode)
  18   :  orb_ (CORBA::ORB::_duplicate (orb)),
  19      rh_ (A::AMI_TestHandler::_duplicate (rh)),
  20      mode_(mode)
  21 {
  22   time_t _tm = ACE_OS::time ();
  23   this->seed_ = (unsigned int)_tm;
  24 }
  25
  26 void
  27 Test_i::set_opponent (A::Test_ptr opp)
  28 {
  29   this->opponent_ = A::Test::_duplicate (opp);
  30 }
  31
  32 void
  33 Test_i::request (
  34   ::A::RequestMode reqmode,
  35   ::CORBA::ULong & counter,
  36   ::A::FollowUp_out follow_up)
  37 {
  38   ++counter;
  39
  40   ACE_DEBUG ((LM_DEBUG,
  41               "%N:%l:(%P:%t):Test_i::request: (%C)  %C - %d\n",
  42               (reqmode == A::RQM_SYNCH ? "SYNCH" : "ASYNCH"),
  43               (this->mode_ == A::RM_MASTER ? "master" : "slave"),
  44               counter));
  45
  46   const char* follow_up_str;
  47   switch (ACE_OS::rand_r (&this->seed_) % 2)
  48   {
  49   case 0:
  50     follow_up = (reqmode == A::RQM_SYNCH ? A::FU_TIMER : A::FU_NOTIFICATION);
  51     follow_up_str = (reqmode == A::RQM_SYNCH ? "TIMER" : "NOTIFICATION");
  52     break;
  53   case 1:
  54   default:
  55     follow_up = (reqmode == A::RQM_ASYNCH ? A::FU_TIMER : A::FU_NOTIFICATION);
  56     follow_up_str = (reqmode == A::RQM_ASYNCH ? "TIMER" : "NOTIFICATION");
  57     break;
  58   }
  59
  60   if (!CORBA::is_nil(this->opponent_.in ()))
  61   {
  62     char buf[1024];
  63     ACE_OS::snprintf (buf, sizeof(buf), "request #%d followup [%s]", counter, follow_up_str);
  64
  65     if (reqmode == A::RQM_SYNCH)
  66     {
  67       if (!CORBA::is_nil (this->rh_.in ()))
  68         this->opponent_->sendc_report(this->rh_.in (), buf);
  69     }
  70     else
  71     {
  72       this->opponent_->report (buf);
  73     }
  74   }
  75 }
  76
  77 void
  78 Test_i::report (
  79   const char * msg)
  80 {
  81   ACE_DEBUG ((LM_DEBUG,
  82               "%N:%l:(%P:%t):Test_i::report: %C - %C\n",
  83               (this->mode_ == A::RM_MASTER ? "master" : "slave"),
  84               msg));
  85 }
  86
  87 void
  88 Test_i::shutdown ()
  89 {
  90   if (this->mode_ == A::RM_SLAVE && !CORBA::is_nil (this->opponent_.in ()))
  91   {
  92     this->opponent_->shutdown ();
  93   }
  94   this->orb_->shutdown (false);
  95 }
  96
  97 Test_Reply_i::Test_Reply_i (CORBA::ORB_ptr orb,
  98     CORBA::ULong max_count,
  99     A::RunMode mode)
 100   : evh_ (orb, max_count, mode)
 101 {
 102 }
 103
 104 void
 105 Test_Reply_i::request (
 106   ::CORBA::ULong counter,
 107   ::A::FollowUp follow_up)
 108 {
 109   if (TAO_debug_level > 0)
 110     ACE_DEBUG ((LM_DEBUG,
 111                 "%N:%l:(%P:%t):Test_Reply_i::request\n"));
 112
 113   this->evh_.handle_followup (follow_up, counter);
 114 }
 115
 116 void Test_Reply_i::request_excep (
 117   ::Messaging::ExceptionHolder * )
 118 {
 119   ACE_DEBUG ((LM_ERROR,
 120               "%N:%l:(%P:%t):Test_Reply_i::request_excep: %C - unexpected exception\n",
 121               (this->evh_.mode () == A::RM_MASTER ? "master" : "slave")));
 122   if (!CORBA::is_nil (this->evh_.opponent ()))
 123     this->evh_.opponent ()->shutdown ();
 124   if (this->evh_.mode () == A::RM_SLAVE)
 125     this->evh_.orb ()->shutdown (0);
 126 }
 127
 128 void
 129 Test_Reply_i::report (
 130   void)
 131 {
 132   if (TAO_debug_level > 0)
 133     ACE_DEBUG ((LM_DEBUG,
 134                 "%N:%l:(%P:%t):Test_Reply_i::report\n"));
 135 }
 136
 137 void
 138 Test_Reply_i::report_excep (
 139   ::Messaging::ExceptionHolder * )
 140 {
 141   ACE_DEBUG ((LM_ERROR,
 142               "%N:%l:(%P:%t):Test_Reply_i::report_excep: %C - unexpected exception\n",
 143               (this->evh_.mode () == A::RM_MASTER ? "master" : "slave")));
 144   if (!CORBA::is_nil (this->evh_.opponent ()))
 145     this->evh_.opponent ()->shutdown ();
 146   if (this->evh_.mode () == A::RM_SLAVE)
 147     this->evh_.orb ()->shutdown (0);
 148 }
 149
 150 TestHandler::TestHandler (CORBA::ORB_ptr orb,
 151                           CORBA::ULong max_count,
 152                           A::RunMode mode)
 153   : orb_ (CORBA::ORB::_duplicate (orb)),
 154     max_count_ (max_count),
 155     mode_ (mode),
 156     counter_ (0)
 157 {
 158   time_t _tm = ACE_OS::time ();
 159   this->seed_ = (unsigned int)_tm;
 160 }
 161
 162 void
 163 TestHandler::set_counter (CORBA::ULong counter)
 164 {
 165   this->counter_ = counter;
 166 }
 167
 168 void
 169 TestHandler::set_opponent (A::Test_ptr opp)
 170 {
 171   this->opponent_ = A::Test::_duplicate (opp);
 172 }
 173
 174 void
 175 TestHandler::set_reply_handler (A::AMI_TestHandler_ptr rh)
 176 {
 177   this->rh_ = A::AMI_TestHandler::_duplicate (rh);
 178 }
 179
 180 int
 181 TestHandler::handle_timeout (const ACE_Time_Value &,
 182                             const void *)
 183 {
 184   this->orb_->orb_core ()->reactor ()->cancel_timer (this);
 185   if ((ACE_OS::rand_r (&this->seed_) % 2) == 0)
 186   {
 187     A::FollowUp followup;
 188     if (!CORBA::is_nil (this->opponent_.in ()))
 189     {
 190       this->opponent_->request(A::RQM_SYNCH, this->counter_, followup);
 191       this->handle_followup (followup, this->counter_);
 192     }
 193   }
 194   else
 195   {
 196     if (!CORBA::is_nil (this->opponent_.in ()))
 197     {
 198       this->opponent_->sendc_request(this->rh_.in (), A::RQM_ASYNCH, this->counter_);
 199     }
 200   }
 201   return 0;
 202 }
 203
 204 int
 205 TestHandler::handle_exception (ACE_HANDLE)
 206 {
 207   if ((ACE_OS::rand_r (&this->seed_) % 2) == 0)
 208   {
 209     A::FollowUp followup;
 210     if (!CORBA::is_nil (this->opponent_.in ()))
 211     {
 212       this->opponent_->request(A::RQM_SYNCH, this->counter_, followup);
 213       this->handle_followup (followup, this->counter_);
 214     }
 215   }
 216   else
 217   {
 218     if (!CORBA::is_nil (this->opponent_.in ()))
 219     {
 220       this->opponent_->sendc_request(this->rh_.in (), A::RQM_ASYNCH, this->counter_);
 221     }
 222   }
 223   return 0;
 224 }
 225
 226 void TestHandler::start ()
 227 {
 228   this->orb_->orb_core ()->reactor ()->notify (this);
 229 }
 230
 231 void
 232 TestHandler::handle_followup (A::FollowUp fup, CORBA::ULong counter)
 233 {
 234   if (counter > this->max_count_)
 235   {
 236     if (this->mode_ == A::RM_MASTER && !CORBA::is_nil (this->opponent_.in ()))
 237     {
 238       this->opponent_->shutdown ();
 239     }
 240   }
 241   else
 242   {
 243     if (this->mode_ == A::RM_MASTER && !CORBA::is_nil (this->opponent_.in ()))
 244     {
 245       char buf[1024];
 246       ACE_OS::snprintf (buf, sizeof(buf), "request #%d followup [%s]",
 247                                           counter,
 248                                           (fup == A::FU_TIMER ? "TIMER" : "NOTIFICATION"));
 249       this->opponent_->report (buf);
 250     }
 251
 252     if (TAO_debug_level > 0)
 253     {
 254       ACE_DEBUG ((LM_DEBUG,
 255                   "%N:%l:(%P:%t):TestHandler::handle_followup\n"));
 256     }
 257
 258     this->set_counter (counter);
 259     if (fup == A::FU_TIMER)
 260     {
 261       this->orb_->orb_core ()->reactor ()->schedule_timer (this, 0,
 262                                                            ACE_Time_Value (0, 100),
 263                                                            ACE_Time_Value (0, 100));
 264     }
 265     else
 266     {
 267       this->orb_->orb_core ()->reactor ()->notify (this);
 268     }
 269   }
 270 }