cpp/test/Ice/hold/TestI.cpp

   1 // **********************************************************************
   2 //
   3 // Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.
   4 //
   5 // This copy of Ice is licensed to you under the terms described in the
   6 // ICE_LICENSE file included in this distribution.
   7 //
   8 // **********************************************************************
   9
  10 #include <Ice/Ice.h>
  11 #include <IceUtil/IceUtil.h>
  12 #include <TestI.h>
  13 #include <TestCommon.h>
  14
  15 HoldI::HoldI(const IceUtil::TimerPtr& timer, const Ice::ObjectAdapterPtr& adapter) :
  16     _last(0), _timer(timer), _adapter(adapter)
  17 {
  18 }
  19
  20 void
  21 HoldI::putOnHold(Ice::Int milliSeconds, const Ice::Current&)
  22 {
  23     if(milliSeconds < 0)
  24     {
  25         _adapter->hold();
  26     }
  27     else if(milliSeconds == 0)
  28     {
  29         _adapter->hold();
  30         _adapter->activate();
  31     }
  32     else
  33     {
  34         try
  35         {
  36             _timer->schedule(this, IceUtil::Time::milliSeconds(milliSeconds));
  37         }
  38         catch(const IceUtil::IllegalArgumentException&)
  39         {
  40         }
  41     }
  42 }
  43
  44 void
  45 HoldI::waitForHold(const Ice::Current& current)
  46 {
  47     class WaitForHold : public IceUtil::TimerTask
  48     {
  49     public:
  50
  51         WaitForHold(const Ice::ObjectAdapterPtr& adapter) : _adapter(adapter)
  52         {
  53         }
  54
  55         void
  56         runTimerTask()
  57         {
  58             try
  59             {
  60                 _adapter->waitForHold();
  61                 _adapter->activate();
  62             }
  63             catch(const Ice::ObjectAdapterDeactivatedException&)
  64             {
  65                 //
  66                 // This shouldn't occur. The test ensures all the waitForHold timers are
  67                 // finished before shutting down the communicator.
  68                 //
  69                 test(false);
  70             }
  71         }
  72
  73     private:
  74
  75         const Ice::ObjectAdapterPtr _adapter;
  76     };
  77
  78     try
  79     {
  80         _timer->schedule(new WaitForHold(current.adapter), IceUtil::Time());
  81     }
  82     catch(const IceUtil::IllegalArgumentException&)
  83     {
  84     }
  85 }
  86
  87 Ice::Int
  88 HoldI::set(Ice::Int value, Ice::Int delay, const Ice::Current&)
  89 {
  90     IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(delay));
  91
  92     Lock sync(*this);
  93     Ice::Int tmp = _last;
  94     _last = value;
  95     return tmp;
  96 }
  97
  98 void
  99 HoldI::setOneway(Ice::Int value, Ice::Int expected, const Ice::Current&)
 100 {
 101     Lock sync(*this);
 102     test(_last == expected);
 103     _last = value;
 104 }
 105
 106 void
 107 HoldI::shutdown(const Ice::Current&)
 108 {
 109     _adapter->hold();
 110     _adapter->getCommunicator()->shutdown();
 111 }
 112
 113 void
 114 HoldI::runTimerTask()
 115 {
 116     try
 117     {
 118         _adapter->hold();
 119         _adapter->activate();
 120     }
 121     catch(const Ice::ObjectAdapterDeactivatedException&)
 122     {
 123     }
 124 }