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 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 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(); }
static void convertLocalException(const Ice::LocalException& ex, PyObject* p) { // // Transfer data members from Ice exception to Python exception. // try { ex.ice_throw(); } catch(const Ice::InitializationException& e) { IcePy::PyObjectHandle m = IcePy::createString(e.reason); PyObject_SetAttrString(p, STRCAST("reason"), m.get()); } catch(const Ice::PluginInitializationException& e) { IcePy::PyObjectHandle m = IcePy::createString(e.reason); PyObject_SetAttrString(p, STRCAST("reason"), m.get()); } catch(const Ice::AlreadyRegisteredException& e) { IcePy::PyObjectHandle m; m = IcePy::createString(e.kindOfObject); PyObject_SetAttrString(p, STRCAST("kindOfObject"), m.get()); m = IcePy::createString(e.id); PyObject_SetAttrString(p, STRCAST("id"), m.get()); } catch(const Ice::NotRegisteredException& e) { IcePy::PyObjectHandle m; m = IcePy::createString(e.kindOfObject); PyObject_SetAttrString(p, STRCAST("kindOfObject"), m.get()); m = IcePy::createString(e.id); PyObject_SetAttrString(p, STRCAST("id"), m.get()); } catch(const Ice::TwowayOnlyException& e) { IcePy::PyObjectHandle m = IcePy::createString(e.operation); PyObject_SetAttrString(p, STRCAST("operation"), m.get()); } catch(const Ice::UnknownException& e) { IcePy::PyObjectHandle m = IcePy::createString(e.unknown); PyObject_SetAttrString(p, STRCAST("unknown"), m.get()); } catch(const Ice::ObjectAdapterDeactivatedException& e) { IcePy::PyObjectHandle m = IcePy::createString(e.name); PyObject_SetAttrString(p, STRCAST("name"), m.get()); } catch(const Ice::ObjectAdapterIdInUseException& e) { IcePy::PyObjectHandle m = IcePy::createString(e.id); PyObject_SetAttrString(p, STRCAST("id"), m.get()); } catch(const Ice::NoEndpointException& e) { IcePy::PyObjectHandle m = IcePy::createString(e.proxy); PyObject_SetAttrString(p, STRCAST("proxy"), m.get()); } catch(const Ice::EndpointParseException& e) { IcePy::PyObjectHandle m = IcePy::createString(e.str); PyObject_SetAttrString(p, STRCAST("str"), m.get()); } catch(const Ice::IdentityParseException& e) { IcePy::PyObjectHandle m = IcePy::createString(e.str); PyObject_SetAttrString(p, STRCAST("str"), m.get()); } catch(const Ice::ProxyParseException& e) { IcePy::PyObjectHandle m = IcePy::createString(e.str); PyObject_SetAttrString(p, STRCAST("str"), m.get()); } catch(const Ice::IllegalIdentityException& e) { IcePy::PyObjectHandle m = IcePy::createIdentity(e.id); PyObject_SetAttrString(p, STRCAST("id"), m.get()); } catch(const Ice::RequestFailedException& e) { IcePy::PyObjectHandle m; m = IcePy::createIdentity(e.id); PyObject_SetAttrString(p, STRCAST("id"), m.get()); m = IcePy::createString(e.facet); PyObject_SetAttrString(p, STRCAST("facet"), m.get()); m = IcePy::createString(e.operation); PyObject_SetAttrString(p, STRCAST("operation"), m.get()); } catch(const Ice::FileException& e) { IcePy::PyObjectHandle m = PyLong_FromLong(e.error); PyObject_SetAttrString(p, STRCAST("error"), m.get()); m = IcePy::createString(e.path); PyObject_SetAttrString(p, STRCAST("path"), m.get()); } catch(const Ice::SyscallException& e) // This must appear after all subclasses of SyscallException. { IcePy::PyObjectHandle m = PyLong_FromLong(e.error); PyObject_SetAttrString(p, STRCAST("error"), m.get()); } catch(const Ice::DNSException& e) { IcePy::PyObjectHandle m; m = PyLong_FromLong(e.error); PyObject_SetAttrString(p, STRCAST("error"), m.get()); m = IcePy::createString(e.host); PyObject_SetAttrString(p, STRCAST("host"), m.get()); } catch(const Ice::UnsupportedProtocolException& e) { IcePy::PyObjectHandle m; m = IcePy::createProtocolVersion(e.bad); PyObject_SetAttrString(p, STRCAST("bad"), m.get()); m = IcePy::createProtocolVersion(e.supported); PyObject_SetAttrString(p, STRCAST("supported"), m.get()); } catch(const Ice::UnsupportedEncodingException& e) { IcePy::PyObjectHandle m; m = IcePy::createEncodingVersion(e.bad); PyObject_SetAttrString(p, STRCAST("bad"), m.get()); m = IcePy::createEncodingVersion(e.supported); PyObject_SetAttrString(p, STRCAST("supported"), m.get()); } catch(const Ice::NoValueFactoryException& e) { IcePy::PyObjectHandle m; m = IcePy::createString(e.reason); PyObject_SetAttrString(p, STRCAST("reason"), m.get()); m = IcePy::createString(e.type); PyObject_SetAttrString(p, STRCAST("type"), m.get()); } catch(const Ice::UnexpectedObjectException& e) { IcePy::PyObjectHandle m; m = IcePy::createString(e.reason); PyObject_SetAttrString(p, STRCAST("reason"), m.get()); m = IcePy::createString(e.type); PyObject_SetAttrString(p, STRCAST("type"), m.get()); m = IcePy::createString(e.expectedType); PyObject_SetAttrString(p, STRCAST("expectedType"), m.get()); } catch(const Ice::ProtocolException& e) // This must appear after all subclasses of ProtocolException. { IcePy::PyObjectHandle m = IcePy::createString(e.reason); PyObject_SetAttrString(p, STRCAST("reason"), m.get()); } catch(const Ice::FeatureNotSupportedException& e) { IcePy::PyObjectHandle m = IcePy::createString(e.unsupportedFeature); PyObject_SetAttrString(p, STRCAST("unsupportedFeature"), m.get()); } catch(const Ice::SecurityException& e) { IcePy::PyObjectHandle m = IcePy::createString(e.reason); PyObject_SetAttrString(p, STRCAST("reason"), m.get()); } catch(const Ice::IllegalServantException& e) { IcePy::PyObjectHandle m = IcePy::createString(e.reason); PyObject_SetAttrString(p, STRCAST("reason"), m.get()); } catch(const Ice::ConnectionManuallyClosedException& e) { PyObject_SetAttrString(p, STRCAST("graceful"), e.graceful ? IcePy::getTrue() : IcePy::getFalse()); } catch(const Ice::LocalException&) { // // Nothing to do. // } }
RetryException::RetryException(const Ice::LocalException& ex) { _ex.reset(ex.ice_clone()); }
static bool convertLocalException(const Ice::LocalException& ex, zval* zex) { zend_class_entry* cls = Z_OBJCE_P(zex); assert(cls); // // Transfer data members from Ice exception to PHP object. // try { ex.ice_throw(); } catch(const Ice::InitializationException& e) { setStringMember(zex, "reason", e.reason); } catch(const Ice::PluginInitializationException& e) { setStringMember(zex, "reason", e.reason); } catch(const Ice::AlreadyRegisteredException& e) { setStringMember(zex, "kindOfObject", e.kindOfObject); setStringMember(zex, "id", e.id); } catch(const Ice::NotRegisteredException& e) { setStringMember(zex, "kindOfObject", e.kindOfObject); setStringMember(zex, "id", e.id); } catch(const Ice::TwowayOnlyException& e) { setStringMember(zex, "operation", e.operation); } catch(const Ice::UnknownException& e) { setStringMember(zex, "unknown", e.unknown); } catch(const Ice::ObjectAdapterDeactivatedException& e) { setStringMember(zex, "name", e.name); } catch(const Ice::ObjectAdapterIdInUseException& e) { setStringMember(zex, "id", e.id); } catch(const Ice::NoEndpointException& e) { setStringMember(zex, "proxy", e.proxy); } catch(const Ice::EndpointParseException& e) { setStringMember(zex, "str", e.str); } catch(const Ice::IdentityParseException& e) { setStringMember(zex, "str", e.str); } catch(const Ice::ProxyParseException& e) { setStringMember(zex, "str", e.str); } catch(const Ice::IllegalIdentityException& e) { zval id; if(!createIdentity(&id, e.id)) { zval_ptr_dtor(&id); return false; } zend_update_property(cls, zex, const_cast<char*>("id"), sizeof("id") - 1, &id); zval_ptr_dtor(&id); } catch(const Ice::RequestFailedException& e) { zval id; if(!createIdentity(&id, e.id)) { zval_ptr_dtor(&id); return false; } zend_update_property(cls, zex, const_cast<char*>("id"), sizeof("id") - 1, &id); zval_ptr_dtor(&id); setStringMember(zex, "facet", e.facet); setStringMember(zex, "operation", e.operation); } catch(const Ice::FileException& e) { zend_update_property_long(cls, zex, const_cast<char*>("error"), sizeof("error") - 1, e.error); setStringMember(zex, "path", e.path); } catch(const Ice::SyscallException& e) // This must appear after all subclasses of SyscallException. { zend_update_property_long(cls, zex, const_cast<char*>("error"), sizeof("error") - 1, e.error); } catch(const Ice::DNSException& e) { zend_update_property_long(cls, zex, const_cast<char*>("error"), sizeof("error") - 1, e.error); setStringMember(zex, "host", e.host); } catch(const Ice::UnsupportedProtocolException& e) { zval v; if(!createProtocolVersion(&v, e.bad)) { zval_ptr_dtor(&v); return false; } zend_update_property(cls, zex, const_cast<char*>("bad"), sizeof("bad") - 1, &v); zval_ptr_dtor(&v); if(!createProtocolVersion(&v, e.supported)) { zval_ptr_dtor(&v); return false; } zend_update_property(cls, zex, const_cast<char*>("supported"), sizeof("supported") - 1, &v); zval_ptr_dtor(&v); } catch(const Ice::UnsupportedEncodingException& e) { zval v; if(!createEncodingVersion(&v, e.bad)) { zval_ptr_dtor(&v); return false; } zend_update_property(cls, zex, const_cast<char*>("bad"), sizeof("bad") - 1, &v); zval_ptr_dtor(&v); if(!createEncodingVersion(&v, e.supported)) { zval_ptr_dtor(&v); return false; } zend_update_property(cls, zex, const_cast<char*>("supported"), sizeof("supported") - 1, &v); zval_ptr_dtor(&v); } catch(const Ice::NoValueFactoryException& e) { setStringMember(zex, "reason", e.reason); setStringMember(zex, "type", e.type); } catch(const Ice::UnexpectedObjectException& e) { setStringMember(zex, "reason", e.reason); setStringMember(zex, "type", e.type); setStringMember(zex, "expectedType", e.expectedType); } catch(const Ice::ProtocolException& e) // This must appear after all subclasses of ProtocolException. { setStringMember(zex, "reason", e.reason); } catch(const Ice::FeatureNotSupportedException& e) { setStringMember(zex, "unsupportedFeature", e.unsupportedFeature); } catch(const Ice::SecurityException& e) { setStringMember(zex, "reason", e.reason); } catch(const Ice::ConnectionManuallyClosedException& e) { add_property_bool(zex, "graceful", e.graceful ? 1 : 0); } catch(const Ice::LocalException&) { // // Nothing to do. // } return true; }
void BatchRequestQueue::destroy(const Ice::LocalException& ex) { Lock sync(*this); _exception.reset(ex.ice_clone()); }