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());
}