cpp/test/Ice/interceptor/AMDInterceptorI.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 <AMDInterceptorI.h>
  11 #include <Test.h>
  12 #include <TestCommon.h>
  13
  14 AMDInterceptorI::AMDInterceptorI(const Ice::ObjectPtr& servant) :
  15     InterceptorI(servant),
  16     _defaultCb(new DispatchInterceptorAsyncCallbackI(*this)),
  17     _actualStatus(Ice::DispatchAsync)
  18
  19 {
  20 }
  21
  22
  23 Ice::DispatchStatus
  24 AMDInterceptorI::dispatch(Ice::Request& request)
  25 {
  26     class CallbackI : public Ice::DispatchInterceptorAsyncCallback
  27     {
  28     public:
  29
  30         CallbackI(AMDInterceptorI& interceptor) :
  31             _interceptor(interceptor)
  32         {
  33         }
  34
  35         virtual bool response(bool ok)
  36         {
  37             test(ok);
  38             return false;
  39         }
  40
  41         virtual bool exception(const std::exception& ex)
  42         {
  43             test(dynamic_cast<const Test::RetryException*>(&ex) != 0);
  44             return false;
  45         }
  46
  47         virtual bool exception()
  48         {
  49             //
  50             // Unexpected
  51             //
  52             test(false);
  53             return false;
  54         }
  55
  56     private:
  57
  58         AMDInterceptorI& _interceptor;
  59     };
  60
  61
  62     Ice::Current& current = const_cast<Ice::Current&>(request.getCurrent());
  63     _lastOperation = current.operation;
  64
  65     Ice::DispatchInterceptorAsyncCallbackPtr cb = new CallbackI(*this);
  66
  67     if(_lastOperation == "amdAddWithRetry")
  68     {
  69         for(int i = 0; i < 10; ++i)
  70         {
  71             _lastStatus =  _servant->ice_dispatch(request, cb);
  72             test(_lastStatus == Ice::DispatchAsync);
  73         }
  74
  75         current.ctx["retry"] = "no";
  76     }
  77
  78     _lastStatus = _servant->ice_dispatch(request, _defaultCb);
  79     return _lastStatus;
  80 }
  81
  82 void
  83 AMDInterceptorI::setActualStatus(Ice::DispatchStatus status)
  84 {
  85     IceUtil::Mutex::Lock lock(_mutex);
  86     _actualStatus = status;
  87 }
  88
  89 void
  90 AMDInterceptorI::setActualStatus(const IceUtil::Exception& e)
  91 {
  92     IceUtil::Mutex::Lock lock(_mutex);
  93     _exception.reset(e.ice_clone());
  94     _actualStatus = Ice::DispatchAsync;
  95 }
  96
  97 Ice::DispatchStatus
  98 AMDInterceptorI::getActualStatus() const
  99 {
 100     IceUtil::Mutex::Lock lock(_mutex);
 101     return _actualStatus;
 102 }
 103
 104 IceUtil::Exception*
 105 AMDInterceptorI::getException() const
 106 {
 107     IceUtil::Mutex::Lock lock(_mutex);
 108     return _exception.get();
 109 }
 110
 111 void
 112 AMDInterceptorI::clear()
 113 {
 114     InterceptorI::clear();
 115     IceUtil::Mutex::Lock lock(_mutex);
 116     _actualStatus = Ice::DispatchAsync;
 117     _exception.reset();
 118 }
 119
 120
 121 DispatchInterceptorAsyncCallbackI::DispatchInterceptorAsyncCallbackI(AMDInterceptorI& interceptor) :
 122     _interceptor(interceptor)
 123 {
 124 }
 125
 126 bool
 127 DispatchInterceptorAsyncCallbackI::response(bool ok)
 128 {
 129     _interceptor.setActualStatus(ok ? Ice::DispatchOK : Ice::DispatchUserException);
 130     return true;
 131 }
 132
 133
 134 bool
 135 DispatchInterceptorAsyncCallbackI::exception(const std::exception& ex)
 136 {
 137     //
 138     // Only Ice exceptions are raised by this test
 139     //
 140     const IceUtil::Exception& ue = dynamic_cast<const IceUtil::Exception&>(ex);
 141      _interceptor.setActualStatus(ue);
 142     return true;
 143
 144 }
 145
 146 bool
 147 DispatchInterceptorAsyncCallbackI::exception()
 148 {
 149     //
 150     // Unexpected
 151     //
 152     test(false);
 153     return true;
 154 }