public void RetryException()
{
try
{
//
// It's important to let the retry queue do the retry. This is
// called from the connect request handler and the retry might
// require could end up waiting for the flush of the
// connection to be done.
//
// Clear request handler and always retry.
if (!Proxy.IceReference.IsFixed)
{
Proxy.IceReference.UpdateRequestHandler(Handler, null);
}
Communicator.AddRetryTask(this, 0);
}
catch (Exception ex)
{
if (Exception(ex))
{
Task.Run(InvokeException);
}
}
}
public override bool Exception(Exception exc)
{
if (ChildObserver != null)
{
ChildObserver.Failed(exc.GetType().FullName ?? "System.Exception");
ChildObserver.Detach();
ChildObserver = null;
}
CachedConnection = null;
//
// NOTE: at this point, synchronization isn't needed, no other threads should be
// calling on the callback.
//
try
{
//
// It's important to let the retry queue do the retry even if
// the retry interval is 0. This method can be called with the
// connection locked so we can't just retry here.
//
Communicator.AddRetryTask(this, Proxy.IceHandleException(exc, Handler, IsIdempotent, _sent, ref _cnt));
return(false);
}
catch (Exception ex)
{
return(ExceptionImpl(ex)); // No retries, we're done
}
}
protected void InvokeImpl(bool userThread)
{
try
{
if (userThread)
{
int invocationTimeout = Proxy.IceReference.InvocationTimeout;
if (invocationTimeout > 0)
{
Communicator.Timer().Schedule(this, invocationTimeout);
}
}
else if (Observer != null)
{
Observer.Retried();
}
while (true)
{
try
{
_sent = false;
Handler = Proxy.IceReference.GetRequestHandler();
Handler.SendAsyncRequest(this);
return; // We're done!
}
catch (RetryException)
{
// Clear request handler and always retry.
if (!Proxy.IceReference.IsFixed)
{
Proxy.IceReference.UpdateRequestHandler(Handler, null);
}
}
catch (Exception ex)
{
if (ChildObserver != null)
{
ChildObserver.Failed(ex.GetType().FullName ?? "System.Exception");
ChildObserver.Detach();
ChildObserver = null;
}
int interval = Proxy.IceHandleException(ex, Handler, IsIdempotent, _sent, ref _cnt);
if (interval > 0)
{
Communicator.AddRetryTask(this, interval);
return;
}
else if (Observer != null)
{
Observer.Retried();
}
}
}
}
catch (Exception ex)
{
//
// If called from the user thread we re-throw, the exception
// will be caught by the caller and abort() will be called.
//
if (userThread)
{
throw;
}
else if (ExceptionImpl(ex)) // No retries, we're done
{
Task.Run(InvokeException);
}
}
}
