internal bool EnqueueRetry(LoadRetryAsyncResult loadRetryAsyncResult)
{
bool flag = false;
if (this.storeLock.IsValid)
{
flag = this.LoadRetryHandler.Enqueue(loadRetryAsyncResult);
}
return(flag);
}
protected internal override bool EndTryCommand(IAsyncResult result)
{
if (result is LoadRetryAsyncResult)
{
return(LoadRetryAsyncResult.End(result));
}
if (result is SqlWorkflowInstanceStoreAsyncResult)
{
return(SqlWorkflowInstanceStoreAsyncResult.End(result));
}
return(base.EndTryCommand(result));
}
internal bool EnqueueRetry(LoadRetryAsyncResult loadRetryAsyncResult)
{
Fx.Assert(this.IsLockRetryEnabled(),
"EnqueueRetry() should not be invoked if retry algorithm is set to NoRetry");
bool result = false;
if (this.storeLock.IsValid)
{
result = this.LoadRetryHandler.Enqueue(loadRetryAsyncResult);
}
return(result);
}
public bool Enqueue(LoadRetryAsyncResult command)
{
bool flag = false;
DateTime key = DateTime.UtcNow.Add(command.RetryTimeout);
lock (this.syncLock)
{
flag = this.retryQueue.Enqueue(key, command);
}
if (flag)
{
this.retryThreadTimer.Set(command.RetryTimeout);
}
return true;
}
static void OnTryCommandCallback(IAsyncResult result)
{
LoadRetryAsyncResult tryCommandAsyncResult = (LoadRetryAsyncResult)(result.AsyncState);
Exception completeException = null;
bool completeFlag = true;
try
{
tryCommandAsyncResult.CompleteTryCommand(result);
}
catch (InstanceLockedException instanceLockedException)
{
TimeSpan retryDelay = tryCommandAsyncResult.InstanceStore.GetNextRetryDelay(++tryCommandAsyncResult.retryCount);
if (retryDelay < tryCommandAsyncResult.commandTimeout.RemainingTime())
{
tryCommandAsyncResult.RetryTimeout = retryDelay;
if (tryCommandAsyncResult.InstanceStore.EnqueueRetry(tryCommandAsyncResult))
{
tryCommandAsyncResult.lastInstanceLockedException = instanceLockedException;
completeFlag = false;
}
}
else if (TD.LockRetryTimeoutIsEnabled())
{
TD.LockRetryTimeout(tryCommandAsyncResult.InstancePersistenceContext.EventTraceActivity, tryCommandAsyncResult.commandTimeout.OriginalTimeout.ToString());
}
if (completeFlag)
{
completeException = instanceLockedException;
}
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
completeException = exception;
}
if (completeFlag)
{
tryCommandAsyncResult.Complete(false, completeException);
}
}
public bool Enqueue(LoadRetryAsyncResult command)
{
bool flag = false;
DateTime key = DateTime.UtcNow.Add(command.RetryTimeout);
lock (this.syncLock)
{
flag = this.retryQueue.Enqueue(key, command);
}
if (flag)
{
this.retryThreadTimer.Set(command.RetryTimeout);
}
return(true);
}
public bool Enqueue(LoadRetryAsyncResult command)
{
bool firstInQueue = false;
DateTime retryTime = DateTime.UtcNow.Add(command.RetryTimeout);
lock (this.syncLock)
{
firstInQueue = this.retryQueue.Enqueue(retryTime, command);
}
if (firstInQueue)
{
this.retryThreadTimer.Set(command.RetryTimeout);
}
return(true);
}
public bool Enqueue(LoadRetryAsyncResult command)
{
bool firstInQueue = false;
DateTime retryTime = DateTime.UtcNow.Add(command.RetryTimeout);
lock (this.syncLock)
{
firstInQueue = this.retryQueue.Enqueue(retryTime, command);
}
if (firstInQueue)
{
this.retryThreadTimer.Set(command.RetryTimeout);
}
return true;
}
private static void OnTryCommandCallback(IAsyncResult result)
{
LoadRetryAsyncResult asyncState = (LoadRetryAsyncResult)result.AsyncState;
Exception exception = null;
bool flag = true;
try
{
asyncState.CompleteTryCommand(result);
}
catch (InstanceLockedException exception2)
{
TimeSpan nextRetryDelay = asyncState.InstanceStore.GetNextRetryDelay(++asyncState.retryCount);
if (nextRetryDelay < asyncState.commandTimeout.RemainingTime())
{
asyncState.RetryTimeout = nextRetryDelay;
if (asyncState.InstanceStore.EnqueueRetry(asyncState))
{
asyncState.lastInstanceLockedException = exception2;
flag = false;
}
}
else if (TD.LockRetryTimeoutIsEnabled())
{
TD.LockRetryTimeout(asyncState.commandTimeout.OriginalTimeout.ToString());
}
if (flag)
{
exception = exception2;
}
}
catch (Exception exception3)
{
if (Fx.IsFatal(exception3))
{
throw;
}
exception = exception3;
}
if (flag)
{
asyncState.Complete(false, exception);
}
}
public void AbortPendingRetries()
{
this.retryThreadTimer.Cancel();
ICollection <KeyValuePair <DateTime, LoadRetryAsyncResult> > result;
lock (this.syncLock)
{
result = this.retryQueue.RemoveAll(x => x.Value != null);
}
foreach (KeyValuePair <DateTime, LoadRetryAsyncResult> value in result)
{
ActionItem.Schedule
(
(data) =>
{
LoadRetryAsyncResult tryCommandResult = data as LoadRetryAsyncResult;
tryCommandResult.AbortRetry();
},
value.Value
);
}
}
internal bool EnqueueRetry(LoadRetryAsyncResult loadRetryAsyncResult)
{
bool flag = false;
if (this.storeLock.IsValid)
{
flag = this.LoadRetryHandler.Enqueue(loadRetryAsyncResult);
}
return flag;
}
public static bool End(IAsyncResult result)
{
LoadRetryAsyncResult thisPtr = AsyncResult.End <LoadRetryAsyncResult>(result);
return(thisPtr.commandSuccess);
}
internal bool EnqueueRetry(LoadRetryAsyncResult loadRetryAsyncResult)
{
Fx.Assert(this.IsLockRetryEnabled(),
"EnqueueRetry() should not be invoked if retry algorithm is set to NoRetry");
bool result = false;
if (this.storeLock.IsValid)
{
result = this.LoadRetryHandler.Enqueue(loadRetryAsyncResult);
}
return result;
}