/**
* Try to cancel an asynchronous request identified by its task.
*/
public bool TryCancelWaitAsync(Task <bool> awaiterTask)
{
AsyncWaiter awaiter = null;
lock (theLock) {
foreach (AsyncWaiter _awaiter in asyncWaiters)
{
if (_awaiter.Task == awaiterTask)
{
awaiter = _awaiter;
asyncWaiters.Remove(awaiter);
awaiter.done = true;
break;
}
}
}
// Complete cancelled async wait with TaskCanceledException
if (awaiter != null)
{
// Release the resources associated with the async waiter, and
// complete the TaskCompletionSource with TaskCanceledException.
awaiter.Dispose(false);
awaiter.SetCanceled();
}
return(awaiter != null);
}
private async Task InvokeAndValidateFaultAsync(
string actionText,
Func <Task> action,
CancellationToken token)
{
for (int i = 0; i < 5; i++)
{
if (this.failoverTestScenarioParameters.TimeToRun - this.GetElapsedTime() > TimeSpan.Zero && !token.IsCancellationRequested)
{
this.ReportProgress("Executing FailoverScenario fault - '{0}'", actionText);
Log.WriteInfo(TraceType, "Testing Failover Scenario by '{0}'. Iteration {1}", actionText, i);
Task testActionTask = action().ContinueWith(t =>
{
this.HandleTaskComplete(t, "FaultAction", actionText);
});
await testActionTask;
Log.WriteInfo(TraceType, "Validating Service health and availability after '{0}'", actionText);
await this.FabricClient.TestManager.ValidateServiceAsync(
this.failoverTestScenarioParameters.PartitionSelector.ServiceName,
this.failoverTestScenarioParameters.MaxServiceStabilizationTimeout,
token).ContinueWith(t =>
{
this.HandleTaskComplete(t, "ValidateServiceAsync", actionText);
});
Log.WriteInfo(TraceType, "Waiting {0} seconds before next fault", this.failoverTestScenarioParameters.WaitTimeBetweenFaults.TotalSeconds);
await AsyncWaiter.WaitAsync(this.failoverTestScenarioParameters.WaitTimeBetweenFaults, token);
}
}
}
public void Exit()
{
AsyncWaiter waiter = null;
lock (this.syncRoot)
{
if (this.count == 0)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Resources.Error_SemaphoreCountAlreadyReachedZero));
}
this.count--;
if (this.waiters.Count > 0)
{
waiter = this.waiters.Dequeue();
this.count++;
}
}
if (waiter != null)
{
waiter.Signal();
}
}
public void Exit()
{
AsyncWaiter waiter = null;
lock (this.syncRoot)
{
if (this.count == 0)
{
throw new InvalidOperationException(
"Semaphore's count has already reached zero before this operaiton. Make sure Exit() is called only after successfully entered the semaphore");
}
this.count--;
if (this.waiters.Count > 0)
{
waiter = this.waiters.Dequeue();
this.count++;
}
}
if (waiter != null)
{
waiter.Signal();
}
}
public bool WaitAsync(Action <object, TimeoutException> callback, object state, TimeSpan timeout)
{
if (!this.isSignaled || (this.isSignaled && (this.resetMode == EventResetMode.AutoReset)))
{
lock (this.syncObject)
{
if (this.isSignaled && (this.resetMode == EventResetMode.AutoReset))
{
this.isSignaled = false;
}
else if (!this.isSignaled)
{
AsyncWaiter item = new AsyncWaiter(this, callback, state);
if (this.asyncWaiters == null)
{
this.asyncWaiters = new List <AsyncWaiter>();
}
this.asyncWaiters.Add(item);
if (timeout != TimeSpan.MaxValue)
{
if (timerCompleteCallback == null)
{
timerCompleteCallback = new Action <object>(AsyncWaitHandle.OnTimerComplete);
}
item.SetTimer(timerCompleteCallback, item, timeout);
}
return(false);
}
}
}
return(true);
}
/**
* Auxiliary methods
*/
/**
* Common code when cancelling an async waiter.
*/
private void WaitCancellationHandler(object _awaiterNode, bool canceling)
{
LinkedListNode <AsyncWaiter> awaiterNode = (LinkedListNode <AsyncWaiter>)_awaiterNode;
AsyncWaiter awaiter = awaiterNode.Value;
bool complete = false;
lock (theLock) {
if (!awaiter.done)
{
asyncWaiters.Remove(awaiterNode);
complete = awaiter.done = true;
}
}
if (complete)
{
awaiter.Dispose(canceling);
if (canceling)
{
awaiter.SetCanceled();
}
else
{
awaiter.SetResult(false);
}
}
}
/**
* Asynchronous Task-based Asynchronous Pattern (TAP) interface.
*/
/**
* Wait asynchronously for the latch to open enabling, optionally, a timeout
* and/or cancellation.
*/
public Task <bool> WaitAsync(int timeout = Timeout.Infinite,
CancellationToken cToken = default(CancellationToken))
{
// The "open" field is volatile, so the visibility is guaranteed
if (open)
{
return(trueTask);
}
lock (theLock) {
// After acquire the lock we must re-check the latch state, because
// however it may have been opened by another thread.
if (open)
{
return(trueTask);
}
// If the wait was specified as immediate, return failure
if (timeout == 0)
{
return(falseTask);
}
// If a cancellation was already requested return a task in the Canceled state
if (cToken.IsCancellationRequested)
{
return(Task.FromCanceled <bool>(cToken));
}
// Create a request node and insert it in requests queue
AsyncWaiter awaiter = new AsyncWaiter(cToken);
LinkedListNode <AsyncWaiter> awaiterNode = asyncWaiters.AddLast(awaiter);
/**
* Activate the specified cancelers owning the lock.
*/
/**
* Since the timeout handler, that runs on a thread pool's worker thread,
* acquires the lock before access the "request.timer" and "request.cTokenRegistration"
* these assignements will be visible to timer handler.
*/
if (timeout != Timeout.Infinite)
{
awaiter.timer = new Timer(timeoutHandler, awaiterNode, timeout, Timeout.Infinite);
}
/**
* If the cancellation token is already in the canceled state, the cancellation
* delegate will run immediately and synchronously, which *causes no damage* because
* this processing is terminal and the implicit locks can be acquired recursively.
*/
if (cToken.CanBeCanceled)
{
awaiter.cTokenRegistration = cToken.Register(cancellationHandler, awaiterNode);
}
// Return the Task<bool> that represents the async wait
return(awaiter.Task);
}
}
public Task<bool> WaitAsync(Int32 duration, CancellationToken token)
{
VerboseLog("{0:000}|{1}|async wait requested", Thread.CurrentThread.Id, _id);
CheckDisposed();
token.ThrowIfCancellationRequested();
if (_sem.TryAcquire())
{
VerboseLog("{0:000}|{1}|async wait immediate success", Thread.CurrentThread.Id,_id);
return Task.FromResult(true);
}
if(duration == 0)
return Task.FromResult(false);
if (_asyncWaiters == null)
{
lock (this)
{
if (_asyncWaiters == null)
_asyncWaiters = new ConcurrentLinkedQueue<AsyncWaiter>();
}
}
AsyncWaiter waiter = new AsyncWaiter();
TaskCompletionSource<bool> task = new TaskCompletionSource<bool>();
waiter.Task = task;
if (duration != -1)
{
waiter.CancelDelay = new CancellationTokenSource();
waiter.Delay = Task.Delay(duration, waiter.CancelDelay.Token);
waiter.Delay.ContinueWith(new ActionContinuation(() => TimeoutAsync(waiter)));
}
if (token != CancellationToken.None)
{
waiter.CancelRegistration = token.Register(() => CancelAsync(waiter));
}
_asyncWaiters.Add(waiter);
VerboseLog("{0:000}|{1}|async wait enqued: {2:X}; {3}", Thread.CurrentThread.Id, _id, waiter.GetHashCode(), waiter.Task.Task.Id);
if (_wasDisposed || token.IsCancellationRequested || waiter.Delay != null && waiter.Delay.IsCompleted)
{
// Mitigate the above race where a finishing condition occured
// before where able to add our waiter to the waiters list.
if (_asyncWaiters.Remove(waiter))
{
CleanUpWaiter(waiter);
}
}
return task.Task;
}
public void LoadHttpDataFollowedByCancel()
{
var request = new HttpDataSource("https://www.google.com?q=a");
var waiter = new AsyncWaiter();
request.SendRequestAsync(HttpDataSource.MethodGet, HttpDataSourceResponseType.AsString);
request.Cancel();
request.SendRequestAsync(HttpDataSource.MethodGet, HttpDataSourceResponseType.AsString);
Assert.AreEqual(WaiterResults.Success, waiter.Wait(10, request), "Couldn't load data");
}
public bool EndEnter(IAsyncResult asyncResult)
{
AsyncWaiter asyncWaiter = asyncResult as AsyncWaiter;
if (asyncWaiter != null)
{
return(AsyncWaiter.End(asyncResult));
}
return(CompletedAsyncResult <bool> .End(asyncResult));
}
public void TestInit()
{
connection = new BayeuxConnection("http://192.168.2.179:8080/cometd/");
connection.DataReceived += LogDataReceived;
connection.DataFailed += LogDataFailed;
connection.ConnectionFailed += LogConnectionFailed;
connection.Timeout = 2000;
waiter = new AsyncWaiter();
waiter.Reset();
}
public void Set()
{
List <AsyncWaiter> toCallList = null;
AsyncWaiter toCall = null;
if (!_isSignaled)
{
lock (_syncObject)
{
if (!_isSignaled)
{
if (_resetMode == EventResetMode.ManualReset)
{
_isSignaled = true;
Monitor.PulseAll(_syncObject);
toCallList = _asyncWaiters;
_asyncWaiters = null;
}
else
{
if (_syncWaiterCount > 0)
{
Monitor.Pulse(_syncObject);
}
else if (_asyncWaiters != null && _asyncWaiters.Count > 0)
{
toCall = _asyncWaiters[0];
_asyncWaiters.RemoveAt(0);
}
else
{
_isSignaled = true;
}
}
}
}
}
if (toCallList != null)
{
foreach (var waiter in toCallList)
{
waiter.CancelTimer();
waiter.Call();
}
}
if (toCall != null)
{
toCall.CancelTimer();
toCall.Call();
}
}
private static void OnWaiterCompleted(IAsyncResult result)
{
PendingOperationTracker.WaitPendingOperationsAsyncResult asyncState = (PendingOperationTracker.WaitPendingOperationsAsyncResult)result.AsyncState;
if (AsyncWaiter.End(result))
{
asyncState.Complete(result.CompletedSynchronously);
return;
}
TimeoutException timeoutException = new TimeoutException(SRCore.TimeoutOnOperation(asyncState.timeout));
asyncState.Complete(result.CompletedSynchronously, timeoutException);
}
public void Set()
{
List <AsyncWaiter> toCallList = null;
AsyncWaiter toCall = null;
if (!this.isSignaled)
{
lock (syncObject)
{
if (!this.isSignaled)
{
if (this.resetMode == EventResetMode.ManualReset)
{
this.isSignaled = true;
Monitor.PulseAll(syncObject);
toCallList = this.asyncWaiters;
this.asyncWaiters = null;
}
else
{
if (this.syncWaiterCount > 0)
{
Monitor.Pulse(syncObject);
}
else if (this.asyncWaiters != null && this.asyncWaiters.Count > 0)
{
toCall = this.asyncWaiters[0];
this.asyncWaiters.RemoveAt(0);
}
else
{
this.isSignaled = true;
}
}
}
}
}
if (toCallList != null)
{
foreach (AsyncWaiter waiter in toCallList)
{
waiter.CancelTimer();
waiter.Call();
}
}
if (toCall != null)
{
toCall.CancelTimer();
toCall.Call();
}
}
public void LoadHttpData()
{
var request = new HttpDataSource("https://www.google.com?q=a");
var waiter = new AsyncWaiter();
var filter = new FilterDebugListener("Filter HttpDataSource", "Core.HttpDataSource");
DebugLog.AddListener(filter);
request.SendRequestAsync(HttpDataSource.MethodGet, HttpDataSourceResponseType.AsString);
Assert.AreEqual(WaiterResults.Success, waiter.Wait(10, request), "Couldn't load data");
Assert.AreNotEqual(0, filter.Count, "Invalid number of captured log messages!");
}
public async Task PerformAsync(IRetryContext context, CancellationToken cancellationToken)
{
TestabilityTrace.TraceSource.WriteNoise("DelayStrategy", "{0}: Sleeping '{1}' seconds.", context.ActivityId, this.delayTime.TotalSeconds);
await AsyncWaiter.WaitAsync(this.delayTime, cancellationToken);
TimeSpan nextSleepTime = this.getNextDelayTime(this.delayTime);
if (nextSleepTime != this.delayTime)
{
TestabilityTrace.TraceSource.WriteNoise("DelayStrategy", "{0}: Increasing current delay time from '{1}' to '{2}' seconds.", context.ActivityId, this.delayTime.TotalSeconds, nextSleepTime.TotalSeconds);
this.delayTime = nextSleepTime;
}
}
public static AsyncWaiter Acquire(Action action)
{
if (stack.Count == 0)
{
return new AsyncWaiter {
action = action
}
}
;
AsyncWaiter waiter = stack.Pop();
waiter.action = action;
return(waiter);
}
public IAsyncResult BeginEnter(AsyncCallback callback, object state)
{
lock (this.syncRoot)
{
if (this.count < this.maxCount)
{
this.count++;
return(new CompletedAsyncResult <bool>(true, callback, state));
}
AsyncWaiter asyncWaiter = new AsyncWaiter(callback, state);
this.waiters.Enqueue(asyncWaiter);
return(asyncWaiter);
}
}
public void Set()
{
List <AsyncWaiter> asyncWaiters = null;
AsyncWaiter waiter = null;
if (!this.isSignaled)
{
lock (this.syncObject)
{
if (!this.isSignaled)
{
if (this.resetMode == EventResetMode.ManualReset)
{
this.isSignaled = true;
Monitor.PulseAll(this.syncObject);
asyncWaiters = this.asyncWaiters;
this.asyncWaiters = null;
}
else if (this.syncWaiterCount > 0)
{
Monitor.Pulse(this.syncObject);
}
else if ((this.asyncWaiters != null) && (this.asyncWaiters.Count > 0))
{
waiter = this.asyncWaiters[0];
this.asyncWaiters.RemoveAt(0);
}
else
{
this.isSignaled = true;
}
}
}
}
if (asyncWaiters != null)
{
foreach (AsyncWaiter waiter2 in asyncWaiters)
{
waiter2.CancelTimer();
waiter2.Call();
}
}
if (waiter != null)
{
waiter.CancelTimer();
waiter.Call();
}
}
public ReliableLog(
DispatcherQueueSetting setting,
IReliableStateManager stateManager)
: base(nameof(ReliableLog <TMessage>))
{
this.setting = setting;
this.stateManager = stateManager;
this.maxQueueLength = setting.MaxQueueLength;
this.recordDictionaryKeyName = this.setting.Name + ":RecordDictionary";
this.metaDictionaryKeyName = this.setting.Name + ":MetaDictionary";
this.lastCommittedIndexKeyName = this.setting.Name + ":LastCommit";
this.checkpointKeyName = this.setting.Name + ":Checkpoint";
this.lastIndex = this.lastCommittedIndex = this.currentCheckpointIndex = new RecordInfo(RecordInfo.InvalidIndex, this.maxQueueLength);
this.inflightAppends = new List <CommitInfo>();
this.waiter = new AsyncWaiter();
}
private static void OnWaiterSignaled(IAsyncResult result)
{
ConcurrentTransactionalDictionary <TKey, TValue> .TransactionalAsyncWaiter asyncState = (ConcurrentTransactionalDictionary <TKey, TValue> .TransactionalAsyncWaiter)result.AsyncState;
Exception timeoutException = null;
try
{
if (!AsyncWaiter.End(result))
{
timeoutException = new TimeoutException();
}
}
catch (OperationCanceledException operationCanceledException)
{
timeoutException = operationCanceledException;
}
asyncState.Complete(false, timeoutException);
}
public ValueTask LockAsync()
{
AsyncWaiter asyncWaiter;
lock (m_Sync)
{
if (m_State == State.Free)
{
m_State = State.Locked;
return(new ValueTask());
}
asyncWaiter = new AsyncWaiter();
m_WaitersQueue.Enqueue(asyncWaiter);
}
return(new ValueTask(asyncWaiter.Task));
}
public WaitPendingOperationsAsyncResult(PendingOperationTracker owner, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state)
{
this.owner = owner;
this.timeout = timeout;
AsyncWaiter asyncWaiter = null;
lock (this.owner.syncLock)
{
this.owner.rejectNewRequests = true;
if (this.owner.pendingOperationCount > (long)0)
{
asyncWaiter = new AsyncWaiter(timeout, PendingOperationTracker.WaitPendingOperationsAsyncResult.StaticOnWaiterCompleted, this);
this.owner.waiters.Add(asyncWaiter);
}
}
if (asyncWaiter == null)
{
base.Complete(true);
}
}
private static void OnTimerComplete(object state)
{
AsyncWaiter item = (AsyncWaiter)state;
AsyncWaitHandle parent = item.Parent;
bool flag = false;
lock (parent.syncObject)
{
if ((parent.asyncWaiters != null) && parent.asyncWaiters.Remove(item))
{
item.TimedOut = true;
flag = true;
}
}
item.CancelTimer();
if (flag)
{
item.Call();
}
}
public void LoadHttpDataFollowedByMultipleCancel()
{
var request = new HttpDataSource("https://www.google.pl/search?q=a");
var waiter = new AsyncWaiter();
counter = 0;
request.DataReceived += delegate { counter++; };
request.DataReceiveFailed += delegate { counter++; };
for (int i = 0; i < 10; i++)
{
request.SendRequestAsync(HttpDataSource.MethodGet, HttpDataSourceResponseType.AsString);
waiter.Sleep(130);
request.Cancel();
}
request.SendRequestAsync(HttpDataSource.MethodGet, HttpDataSourceResponseType.AsString);
Assert.AreEqual(WaiterResults.Success, waiter.Wait(10, request), "Couldn't load data");
Assert.AreEqual(1, counter, "Should receive data only once!");
}
static void OnTimerComplete(object state)
{
AsyncWaiter waiter = (AsyncWaiter)state;
AsyncWaitHandle thisPtr = waiter.Parent;
bool callWaiter = false;
lock (thisPtr.syncObject)
{
// If still in the waiting list (that means it hasn't been signaled)
if (thisPtr.asyncWaiters != null && thisPtr.asyncWaiters.Remove(waiter))
{
waiter.TimedOut = true;
callWaiter = true;
}
}
waiter.CancelTimer();
if (callWaiter)
{
waiter.Call();
}
}
public bool WaitAsync(Action <object, TimeoutException> callback, object state, TimeSpan timeout)
{
if (!_isSignaled || (_isSignaled && _resetMode == EventResetMode.AutoReset))
{
lock (_syncObject)
{
if (_isSignaled && _resetMode == EventResetMode.AutoReset)
{
_isSignaled = false;
}
else if (!_isSignaled)
{
AsyncWaiter waiter = new AsyncWaiter(this, callback, state);
if (_asyncWaiters == null)
{
_asyncWaiters = new List <AsyncWaiter>();
}
_asyncWaiters.Add(waiter);
if (timeout != TimeSpan.MaxValue)
{
if (s_timerCompleteCallback == null)
{
s_timerCompleteCallback = new Action <object>(OnTimerComplete);
}
waiter.SetTimer(s_timerCompleteCallback, waiter, timeout);
}
return(false);
}
}
}
return(true);
}
/**
* Synchronous interface implemented using the asynchronous TAP interface.
*/
/**
* Try to cancel an asynchronous request identified by its task.
*/
private bool CancelWaitByTask(Task <bool> awaiterTask)
{
AsyncWaiter awaiter = null;
lock (theLock) {
foreach (AsyncWaiter _awaiter in asyncWaiters)
{
if (_awaiter.Task == awaiterTask)
{
awaiter = _awaiter;
asyncWaiters.Remove(_awaiter);
awaiter.done = true;
break;
}
}
}
if (awaiter != null)
{
// Dispose resources and complete async wait with TaskCanceledException
awaiter.Dispose(false);
awaiter.SetCanceled();
}
return(awaiter != null);
}
public bool WaitAsync(Action<object, TimeoutException> callback, object state, TimeSpan timeout)
{
if (!this.isSignaled || (this.isSignaled && this.resetMode == EventResetMode.AutoReset))
{
lock (syncObject)
{
if (this.isSignaled && this.resetMode == EventResetMode.AutoReset)
{
this.isSignaled = false;
}
else if (!this.isSignaled)
{
AsyncWaiter waiter = new AsyncWaiter(this, callback, state);
if (this.asyncWaiters == null)
{
this.asyncWaiters = new List<AsyncWaiter>();
}
this.asyncWaiters.Add(waiter);
if (timeout != TimeSpan.MaxValue)
{
if (timerCompleteCallback == null)
{
timerCompleteCallback = new Action<object>(OnTimerComplete);
}
waiter.SetTimer(timerCompleteCallback, waiter, timeout);
}
return false;
}
}
}
return true;
}
public TransactionalAsyncWaiter(AsyncCallback callback, object state) : base(callback, state)
{
this.waiter = new AsyncWaiter(TimeSpan.MaxValue, ConcurrentTransactionalDictionary <TKey, TValue> .TransactionalAsyncWaiter.onWaiterSignaled, this, false);
}
public static void Wait <T>(this T operation, Action <T> action) where T : AsyncOperation
{
if (operation == null)
{
throw new ArgumentNullException("operation");
}
if (action == null)
{
throw new ArgumentNullException("action");
}
operations.Add(new KeyValuePair <AsyncOperation, Action <AsyncOperation> >(operation, AsyncWaiter <T> .Acquire(action).Emit));
}
public override async Task <ActionStateBase> RunAsync(CancellationToken cancellationToken, ServiceInternalFaultInfo serviceInternalFaultInfo)
{
InvokeQuorumLossState state = Convert(this.State);
Guid partitionId = state.Info.PartitionId;
List <Tuple <string, string> > unreliableTransportInfo = state.Info.UnreliableTransportInfo;
List <long> targetReplicas = state.Info.ReplicaIds;
var unreliableTransportTaskList = new List <Task>();
List <Tuple <string, string> > unreliableTransportInfoList = new List <Tuple <string, string> >();
foreach (Tuple <string, string> ut in unreliableTransportInfo)
{
string nodeName = ut.Item1;
string behaviorName = ut.Item2;
System.Fabric.Common.UnreliableTransportBehavior behavior = new System.Fabric.Common.UnreliableTransportBehavior("*", "StatefulServiceReopen");
behavior.AddFilterForPartitionId(partitionId);
TestabilityTrace.TraceSource.WriteInfo(StepBase.TraceType, "{0} - applying '{1}'", this.State.OperationId, behaviorName);
unreliableTransportTaskList.Add(FabricClientRetryHelper.ExecuteFabricActionWithRetryAsync(
() => this.FabricClient.TestManager.AddUnreliableTransportBehaviorAsync(
nodeName,
behaviorName,
behavior,
this.RequestTimeout,
cancellationToken),
this.OperationTimeout,
cancellationToken));
}
await Task.WhenAll(unreliableTransportTaskList).ConfigureAwait(false);
// Bug#2271465 - Unreliable transport through API should return only once the behavior has been successfully applied
await Task.Delay(TimeSpan.FromSeconds(5.0), cancellationToken).ConfigureAwait(false);
List <Task> tasks = new List <Task>();
foreach (long replicaId in targetReplicas)
{
ReplicaSelector replicaSelector = ReplicaSelector.ReplicaIdOf(PartitionSelector.PartitionIdOf(this.partitionSelector.ServiceName, partitionId), replicaId);
TestabilityTrace.TraceSource.WriteInfo(StepBase.TraceType, "{0} - faulting replica with id={1}", this.State.OperationId, replicaId);
Task task = FaultAnalysisServiceUtility.RestartReplicaAsync(this.FabricClient, replicaSelector, CompletionMode.DoNotVerify, this.RequestTimeout, this.OperationTimeout, cancellationToken);
tasks.Add(task);
}
await Task.WhenAll(tasks).ConfigureAwait(false);
ActionTest.PerformInternalServiceFaultIfRequested(this.State.OperationId, serviceInternalFaultInfo, this.State, cancellationToken, true);
TestabilityTrace.TraceSource.WriteInfo(StepBase.TraceType, "{0} - keeping partition in quorum loss for '{1}'", this.State.OperationId, state.Info.QuorumLossDuration);
await Task.Delay(state.Info.QuorumLossDuration, cancellationToken).ConfigureAwait(false);
TimeoutHelper timeoutHelper = new TimeoutHelper(this.OperationTimeout);
bool conditionSatisfied = false;
int quorumLossCheckRetries = FASConstants.QuorumLossCheckRetryCount;
do
{
TestabilityTrace.TraceSource.WriteInfo(StepBase.TraceType, "{0} - checking PartitionStatus", this.State.OperationId);
ServicePartitionList partitionsResult = await FabricClientRetryHelper.ExecuteFabricActionWithRetryAsync(
() => this.FabricClient.QueryManager.GetPartitionListAsync(
this.partitionSelector.ServiceName,
null,
this.RequestTimeout,
cancellationToken),
this.OperationTimeout,
cancellationToken).ConfigureAwait(false);
foreach (StatefulServicePartition partition in partitionsResult)
{
if (partition.PartitionInformation.Id == partitionId)
{
if (partition.PartitionStatus == ServicePartitionStatus.InQuorumLoss)
{
conditionSatisfied = true;
break;
}
}
}
await AsyncWaiter.WaitAsync(TimeSpan.FromSeconds(5), cancellationToken).ConfigureAwait(false);
}while (!conditionSatisfied && quorumLossCheckRetries-- > 0);
if (!conditionSatisfied)
{
string error = string.Format(CultureInfo.InvariantCulture, "{0} - Service could not induce quorum loss for service '{1}', partition '{2}'. Please retry", this.State.OperationId, this.partitionSelector.ServiceName, partitionId);
TestabilityTrace.TraceSource.WriteWarning(StepBase.TraceType, error);
throw new FabricTransientException("The operation could not be performed, please retry", FabricErrorCode.NotReady);
}
await QuorumLossStepsFactory.RemoveUTAsync(this.FabricClient, this.State, this.RequestTimeout, this.OperationTimeout, cancellationToken);
state.StateProgress.Push(StepStateNames.CompletedSuccessfully);
return(state);
}
private void TimeoutAsync(AsyncWaiter waiter)
{
if (waiter.CancelDelay.IsCancellationRequested)
return;
VerboseLog("{0:000}|{1}|async wait timed out", Thread.CurrentThread.Id,_id);
if (_asyncWaiters.Remove(waiter))
{
CleanUpWaiter(waiter);
}
waiter.Task.TrySetResult(false);
}
/// <summary>
/// Will set ObjectedDisposedException is we were disposed.
/// </summary>
private void CleanUpWaiter(AsyncWaiter waiter)
{
waiter.CancelRegistration.Dispose();
if (waiter.Delay != null)
{
waiter.CancelDelay.Cancel();
waiter.Delay.Dispose();
}
if (_wasDisposed)
{
VerboseLog("{0:000}|{1}|disposing async waiter: {2}", Thread.CurrentThread.Id, _id, waiter.Task.Task.Id);
waiter.Task.TrySetException(new ObjectDisposedException(GetType().Name));
}
}
private void CancelAsync(AsyncWaiter waiter)
{
VerboseLog("{0:000}|{1}|async wait cancelled", Thread.CurrentThread.Id, _id);
if (_asyncWaiters.Remove(waiter))
{
CleanUpWaiter(waiter);
}
waiter.Task.TrySetCanceled();
}
