int
ICE_OBJECT_PRX::__handleException(const Exception& ex,
const RequestHandlerPtr& handler,
OperationMode mode,
bool sent,
int& cnt)
{
__updateRequestHandler(handler, 0); // Clear the request handler
//
// We only retry local exception, system exceptions aren't retried.
//
// A CloseConnectionException indicates graceful server shutdown, and is therefore
// always repeatable without violating "at-most-once". That's because by sending a
// close connection message, the server guarantees that all outstanding requests
// can safely be repeated.
//
// An ObjectNotExistException can always be retried as well without violating
// "at-most-once" (see the implementation of the checkRetryAfterException method
// of the ProxyFactory class for the reasons why it can be useful).
//
// If the request didn't get sent or if it's non-mutating or idempotent it can
// also always be retried if the retry count isn't reached.
//
const LocalException* localEx = dynamic_cast<const LocalException*>(&ex);
if(localEx && (!sent ||
mode == ICE_ENUM(OperationMode, Nonmutating) || mode == ICE_ENUM(OperationMode, Idempotent) ||
dynamic_cast<const CloseConnectionException*>(&ex) ||
dynamic_cast<const ObjectNotExistException*>(&ex)))
{
try
{
return _reference->getInstance()->proxyFactory()->checkRetryAfterException(*localEx, _reference, cnt);
}
catch(const CommunicatorDestroyedException&)
{
//
// The communicator is already destroyed, so we cannot retry.
//
ex.ice_throw();
}
}
else
{
ex.ice_throw(); // Retry could break at-most-once semantics, don't retry.
}
return 0; // Keep the compiler happy.
}
int
ProxyFlushBatch::handleException(const Exception& ex)
{
_proxy->__setRequestHandler(_handler, 0); // Clear request handler
ex.ice_throw(); // No retries, we want to notify the user of potentially lost batch requests
return 0;
}