void BatchRequestQueue::destroy(const Ice::LocalException& ex) { Lock sync(*this); #ifdef ICE_CPP11_MAPPING _exception = ex.ice_clone(); #else _exception.reset(ex.ice_clone()); #endif }
void IceInternal::BatchOutgoing::finished(const Ice::LocalException& ex, bool) { IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor); _remoteObserver.failed(ex.ice_name()); _remoteObserver.detach(); _exception.reset(ex.ice_clone()); _monitor.notify(); }
void IceBT::TransceiverI::connectFailed(const Ice::LocalException& ex) { IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_lock); // // Save the exception - it will be raised in initialize(). // ICE_SET_EXCEPTION_FROM_CLONE(_exception, ex.ice_clone()); // // Triggers a call to write() from a different thread. // _stream->ready(IceInternal::SocketOperationConnect, true); }
void OutgoingAsyncBase::cancel(const Ice::LocalException& ex) { CancellationHandlerPtr handler; { Lock sync(_m); ICE_SET_EXCEPTION_FROM_CLONE(_cancellationException, ex.ice_clone()); if(!_cancellationHandler) { return; } handler = _cancellationHandler; } handler->asyncRequestCanceled(ICE_SHARED_FROM_THIS, ex); }
void AsyncResult::cancel(const Ice::LocalException& ex) { CancellationHandlerPtr handler; { IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor); _cancellationException.reset(ex.ice_clone()); if(!_cancellationHandler) { return; } handler = _cancellationHandler; } handler->asyncRequestCanceled(OutgoingAsyncBasePtr::dynamicCast(this), ex); }
void ConnectRequestHandler::setException(const Ice::LocalException& ex) { Lock sync(*this); assert(!_initialized && !_exception); ICE_SET_EXCEPTION_FROM_CLONE(_exception, ex.ice_clone()); _proxies.clear(); _proxy = 0; // Break cyclic reference count. // // NOTE: remove the request handler *before* notifying the // requests that the connection failed. It's important to ensure // that future invocations will obtain a new connect request // handler once invocations are notified. // try { _reference->getInstance()->requestHandlerFactory()->removeRequestHandler(_reference, ICE_SHARED_FROM_THIS); } catch(const Ice::CommunicatorDestroyedException&) { // Ignore } for(deque<ProxyOutgoingAsyncBasePtr>::const_iterator p = _requests.begin(); p != _requests.end(); ++p) { if((*p)->exception(ex)) { (*p)->invokeExceptionAsync(); } } _requests.clear(); notifyAll(); }
void ConnectRequestHandler::setException(const Ice::LocalException& ex) { Lock sync(*this); assert(!_initialized && !_exception.get()); assert(_updateRequestHandler || _requests.empty()); _exception.reset(ex.ice_clone()); _proxy = 0; // Break cyclic reference count. _delegate = 0; // Break cyclic reference count. // // If some requests were queued, we notify them of the failure. This is done from a thread // from the client thread pool since this will result in ice_exception callbacks to be // called. // if(!_requests.empty()) { const InstancePtr instance = _reference->getInstance(); instance->clientThreadPool()->execute(new FlushRequestsWithException(instance, this, ex)); } notifyAll(); }
void ConnectRequestHandler::setException(const Ice::LocalException& ex) { Lock sync(*this); assert(!_initialized && !ICE_EXCEPTION_GET(_exception)); ICE_RESET_EXCEPTION(_exception, ex.ice_clone()); _proxies.clear(); _proxy = 0; // Break cyclic reference count. // // NOTE: remove the request handler *before* notifying the // requests that the connection failed. It's important to ensure // that future invocations will obtain a new connect request // handler once invocations are notified. // try { _reference->getInstance()->requestHandlerFactory()->removeRequestHandler(_reference, ICE_SHARED_FROM_THIS); } catch(const Ice::CommunicatorDestroyedException&) { // Ignore } #ifdef ICE_CPP11_MAPPING try { rethrow_exception(_exception); } catch(const Ice::LocalException& ex) { for(deque<Request>::const_iterator p = _requests.begin(); p != _requests.end(); ++p) { if(p->out) { p->out->completed(ex); } else { if(p->outAsync->completed(ex)) { p->outAsync->invokeCompletedAsync(); } } } } #else for(deque<Request>::const_iterator p = _requests.begin(); p != _requests.end(); ++p) { if(p->out) { p->out->completed(*_exception.get()); } else { if(p->outAsync->completed(*_exception.get())) { p->outAsync->invokeCompletedAsync(); } } } #endif _requests.clear(); notifyAll(); }
RetryException::RetryException(const Ice::LocalException& ex) { _ex.reset(ex.ice_clone()); }
void BatchRequestQueue::destroy(const Ice::LocalException& ex) { Lock sync(*this); _exception.reset(ex.ice_clone()); }