public async Task <ConditionalValue <TValue> > TryRemoveAsync(ITransaction tx, TKey key)
{
if (reliableDictionary == null)
{
await InitializeReliableDictionary();
}
return(await reliableDictionary.TryRemoveAsync(tx, key));
}
/// <summary>
/// Unregisters an entity as observable for a given topic.
/// </summary>
/// <param name="topic">The topic.</param>
/// <param name="entityId">The entity id.</param>
/// <returns>The asynchronous result of the operation.</returns>
public async Task UnregisterObservableAsync(string topic, EntityId entityId)
{
if (string.IsNullOrWhiteSpace(topic))
{
throw new ArgumentException($"The {nameof(topic)} parameter cannot be null.", nameof(topic));
}
if (entityId == null)
{
throw new ArgumentException($"The {nameof(entityId)} parameter cannot be null.", nameof(entityId));
}
try
{
IReliableDictionary <string, EntityId> observablesDictionary = await this.StateManager.GetOrAddAsync <IReliableDictionary <string, EntityId> >(topic);
string entityUri = entityId.EntityUri.ToString();
using (ITransaction transaction = this.StateManager.CreateTransaction())
{
ConditionalValue <EntityId> result = await observablesDictionary.TryGetValueAsync(transaction, entityUri);
if (result.HasValue)
{
await observablesDictionary.TryRemoveAsync(transaction, entityUri);
ServiceEventSource.Current.Message($"Observable successfully unregistered.\r\n[Observable]: {entityId}\r\n[Publication]: Topic=[{topic}]");
}
await transaction.CommitAsync();
}
}
catch (Exception ex)
{
ServiceEventSource.Current.Error(ex);
throw;
}
}
public async Task Clear(string key, CancellationToken cancellationToken = default(CancellationToken))
{
if (await Contains(key, cancellationToken).ConfigureAwait(false))
{
await state.TryRemoveAsync(transactionProvider.Current, key, TimeSpan.FromSeconds(5), cancellationToken).ConfigureAwait(false);
}
}
private async Task PeriodicOldMessageTrimming(CancellationToken cancellationToken)
{
IReliableDictionary <CustomerOrderActorMessageId, DateTime> recentRequests =
await this.stateManager.GetOrAddAsync <IReliableDictionary <CustomerOrderActorMessageId, DateTime> >(ActorMessageDictionaryName);
IReliableDictionary <CustomerOrderActorMessageId, Tuple <InventoryItemId, int> > requestHistory =
await
this.stateManager.GetOrAddAsync <IReliableDictionary <CustomerOrderActorMessageId, Tuple <InventoryItemId, int> > >(RequestHistoryDictionaryName);
while (!cancellationToken.IsCancellationRequested)
{
using (ITransaction tx = this.stateManager.CreateTransaction())
{
foreach (KeyValuePair <CustomerOrderActorMessageId, DateTime> request in recentRequests)
{
//if we have a record of a message that is older than 2 hours from current time, then remove that record
//from both of the stale message tracking dictionaries.
if (request.Value < (DateTime.UtcNow.AddHours(-2)))
{
await recentRequests.TryRemoveAsync(tx, request.Key);
await requestHistory.TryRemoveAsync(tx, request.Key);
}
}
await tx.CommitAsync();
}
//sleep for 5 minutes then scan again
await Task.Delay(TimeSpan.FromMinutes(5), cancellationToken);
}
}
public async Task <IActionResult> Delete(string name)
{
IReliableDictionary <string, string> dictionary =
await this.stateManager.GetOrAddAsync <IReliableDictionary <string, string> >(ValuesDictionaryName);
try
{
using (ITransaction tx = this.stateManager.CreateTransaction())
{
ConditionalValue <string> result = await dictionary.TryRemoveAsync(tx, name);
await tx.CommitAsync();
if (result.HasValue)
{
return(this.Ok());
}
return(new ContentResult {
StatusCode = 400, Content = $"A value with name {name} doesn't exist."
});
}
}
catch (FabricNotPrimaryException)
{
return(new ContentResult {
StatusCode = 503, Content = "The primary replica has moved. Please re-resolve the service."
});
}
}
internal async Task <bool> TryDequeueAndProcessAsync(CancellationToken cancellationToken)
{
IReliableQueue <Guid> queue =
await this.StateManager.GetOrAddAsync <IReliableQueue <Guid> >(QueueName);
IReliableDictionary <Guid, ApplicationDeployment> dictionary =
await this.StateManager.GetOrAddAsync <IReliableDictionary <Guid, ApplicationDeployment> >(DictionaryName);
using (ITransaction tx = this.StateManager.CreateTransaction())
{
ConditionalValue <Guid> workItem = await queue.TryDequeueAsync(tx, this.transactionTimeout, cancellationToken);
if (!workItem.HasValue)
{
ServiceEventSource.Current.ServiceMessage(this, "No new application deployment requests.");
return(false);
}
Guid workItemId = workItem.Value;
ConditionalValue <ApplicationDeployment> appDeployment =
await dictionary.TryGetValueAsync(tx, workItemId, LockMode.Update, this.transactionTimeout, cancellationToken);
if (!appDeployment.HasValue)
{
ServiceEventSource.Current.ServiceMessage(
this,
"Found queued application deployment request with no associated deployment information. Discarding.");
return(true);
}
ApplicationDeployment processedDeployment = await this.ProcessApplicationDeployment(appDeployment.Value, cancellationToken);
if (processedDeployment.Status == ApplicationDeployStatus.Complete ||
processedDeployment.Status == ApplicationDeployStatus.Failed)
{
// Remove deployments that completed or failed
await dictionary.TryRemoveAsync(tx, workItemId, this.transactionTimeout, cancellationToken);
}
else
{
// The deployment hasn't completed or failed, so queue up the next stage of deployment
await queue.EnqueueAsync(tx, workItemId, this.transactionTimeout, cancellationToken);
// And update the deployment record with the new status
await dictionary.SetAsync(tx, workItemId, processedDeployment, this.transactionTimeout, cancellationToken);
ServiceEventSource.Current.ServiceMessage(
this,
"Application deployment request successfully processed. Cluster: {0}. Status: {1}",
processedDeployment.Cluster,
processedDeployment.Status);
}
await tx.CommitAsync();
}
return(true);
}
public async Task <IActionResult> Delete(string name)
{
ServiceEventSource.Current.Message($"VotingData.Delete start. name='{name}'");
ConditionalValue <int> result = new ConditionalValue <int>(false, -1);
IReliableDictionary <string, int> votesDictionary = await this.stateManager.GetOrAddAsync <IReliableDictionary <string, int> >("votes");
IReliableDictionary <string, long> ballotDictionary = await this.stateManager.GetOrAddAsync <IReliableDictionary <string, long> >("ballots");
using (ITransaction tx = this.stateManager.CreateTransaction())
{
if (await votesDictionary.ContainsKeyAsync(tx, name))
{
ConditionalValue <int> deleteVotes = await votesDictionary.TryGetValueAsync(tx, name);
result = await votesDictionary.TryRemoveAsync(tx, name);
long ballots = await GetTotalBallotsCast();
await AuditBallot(-1 *(ballots >= deleteVotes.Value ? deleteVotes.Value : ballots));
await tx.CommitAsync();
ServiceEventSource.Current.Message($"VotingData.Delete end. '{name}' deleted.");
return(new OkResult());
}
else
{
ServiceEventSource.Current.Message($"VotingData.Delete end. '{name}' not found.");
return(new NotFoundResult());
}
}
}
private async Task PersistChanges(Order order, OrderSnapshot initial, IReliableDictionary <Guid, OrderSnapshot> dictionary, ITransaction transaction)
{
var updated = await dictionary.TryUpdateAsync(transaction, order.Id, order.GetSnapshot(), initial);
if (updated && order.IsClosed())
{
await dictionary.TryRemoveAsync(transaction, order.Id);
}
}
/// <inheritdocs/>
public async Task DeleteEntry(Guid replicaId)
{
await EnsureChunkTables();
using (var tx = ServiceFabricUtils.CreateTransaction())
{
await ServiceFabricUtils.DoWithTimeoutRetry(
async() => await m_chunktable.TryRemoveAsync(tx, replicaId));
}
}
private static async Task <bool> ExecuteRemoveAsync(ITransaction tx, Order order, IReliableDictionary <string, Order> orders)
{
var result = await orders.TryRemoveAsync(tx, order.Id);
if (result.HasValue)
{
return(true);
}
return(false);
}
/// <summary>
/// This method saves the description (eventString) and timestamp of the recentmost induced fault as
/// a ChaosEntry in a Reliable Dictionary
/// </summary>
/// <param name="eventString"></param>
/// <returns>A task to await on</returns>
private async Task StoreEventAsync(string eventString)
{
ServiceEventSource.Current.ServiceMessage(this, "ChaosTest: {0}", eventString);
IReliableDictionary <string, long> eventCount =
await this.StateManager.GetOrAddAsync <IReliableDictionary <string, long> >(StringResource.EventCountKey);
IReliableDictionary <string, DateTime> startTime =
await this.StateManager.GetOrAddAsync <IReliableDictionary <string, DateTime> >(StringResource.StartTimeKey);
IReliableDictionary <long, ChaosEntry> savedEvents =
await this.StateManager.GetOrAddAsync <IReliableDictionary <long, ChaosEntry> >(StringResource.SavedEventsKey);
using (ITransaction tx = this.StateManager.CreateTransaction())
{
if (!await startTime.ContainsKeyAsync(tx, StringResource.StartTimeKey))
{
await startTime.AddAsync(tx, StringResource.StartTimeKey, DateTime.UtcNow);
}
if (!await eventCount.ContainsKeyAsync(tx, StringResource.EventCountKey))
{
await eventCount.AddAsync(tx, StringResource.EventCountKey, 0);
}
ConditionalValue <long> result =
await eventCount.TryGetValueAsync(tx, StringResource.EventCountKey, LockMode.Update);
if (result.HasValue)
{
long currentCount = result.Value;
// If we have HistoryLength number of events, we make room for new events by removing oldest ones,
// always keeping HistoryLength number of recentmost events on the show on the webpage.
if (currentCount > Constants.HistoryLength - 1)
{
await savedEvents.TryRemoveAsync(tx, currentCount - Constants.HistoryLength + 1);
}
ChaosEntry chaosEntry = new ChaosEntry
{
Record = eventString,
TimeStamp = DateTime.UtcNow.ToString(CultureInfo.InvariantCulture)
};
await savedEvents.AddAsync(tx, ++currentCount, chaosEntry);
await eventCount.SetAsync(tx, StringResource.EventCountKey, currentCount);
await tx.CommitAsync();
}
}
}
/// <summary>
/// NOTE: This should not be used in published MVP code.
/// This function allows us to remove inventory items from inventory.
/// </summary>
/// <param name="itemId"></param>
/// <returns></returns>
public async Task DeleteInventoryItemAsync(InventoryItemId itemId)
{
IReliableDictionary <InventoryItemId, InventoryItem> inventoryItems =
await this.stateManager.GetOrAddAsync <IReliableDictionary <InventoryItemId, InventoryItem> >(InventoryItemDictionaryName);
using (ITransaction tx = this.stateManager.CreateTransaction())
{
await inventoryItems.TryRemoveAsync(tx, itemId);
await tx.CommitAsync();
}
}
public async Task <IActionResult> Delete(string staff)
{
IReliableDictionary <string, int> StaffDictionary = await this.stateManager.GetOrAddAsync <IReliableDictionary <string, int> >("counts");
using (ITransaction tx = this.stateManager.CreateTransaction())
{
await StaffDictionary.TryRemoveAsync(tx, staff);
await tx.CommitAsync();
}
return(new OkResult());
}
public async Task DeleteStoryPointEntry(Guid entryId)
{
IReliableDictionary <Guid, perStoryData> storypointdata =
await _stateManager.GetOrAddAsync <IReliableDictionary <Guid, perStoryData> >("storypointdata");
using (ITransaction tx = _stateManager.CreateTransaction())
{
await storypointdata.TryRemoveAsync(tx, entryId);
await tx.CommitAsync();
}
}
protected override async Task RunAsync(CancellationToken cancellationToken)
{
TimeSpan timeSpan = new TimeSpan(0, 0, 30);
ServiceEventSource.Current.ServiceMessage(
this,
"Partition {0} started processing messages.",
this.Context.PartitionId);
IReliableDictionary <DateTime, Message> messagesDictionary =
await this.StateManager.GetOrAddAsync <IReliableDictionary <DateTime, Message> >("messages");
//Use this method to periodically clean up messages in the messagesDictionary
while (!cancellationToken.IsCancellationRequested)
{
try
{
IEnumerable <KeyValuePair <DateTime, Message> > messagesEnumerable = await GetMessagesAsync();
// Remove all the messages that are older than 30 seconds keeping the last 50 messages
IEnumerable <KeyValuePair <DateTime, Message> > oldMessages = from t in messagesEnumerable
where t.Key < (DateTime.Now - timeSpan)
orderby t.Key ascending
select t;
using (ITransaction tx = this.StateManager.CreateTransaction())
{
int messagesCount = (int)await messagesDictionary.GetCountAsync(tx);
foreach (KeyValuePair <DateTime, Message> item in oldMessages.Take(messagesCount - MessagesToKeep))
{
await messagesDictionary.TryRemoveAsync(tx, item.Key);
}
await tx.CommitAsync();
}
}
catch (Exception e)
{
if (!this.HandleException(e))
{
ServiceEventSource.Current.ServiceMessage(
this,
"Partition {0} stopped processing because of error {1}",
this.Context.PartitionId,
e);
break;
}
}
await Task.Delay(TimeSpan.FromSeconds(2), cancellationToken);
}
}
public async Task DeleteKeyAsync(string key)
{
if (_dict == null)
{
throw new NullReferenceException(nameof(_dict));
}
using (var tx = this.StateManager.CreateTransaction())
{
await _dict.TryRemoveAsync(tx, key);
await tx.CommitAsync();
}
}
public async Task <IActionResult> Delete(string id)
{
IReliableDictionary <string, ConnectedUserData> usersDict = await this.stateManager.GetOrAddAsync <IReliableDictionary <string, ConnectedUserData> >(CONNECTED_USERS);
using (ITransaction tx = this.stateManager.CreateTransaction())
{
await usersDict.TryRemoveAsync(tx, id);
await tx.CommitAsync();
}
return(new OkResult());
}
public async Task CheckpointAsync(CheckpointInfo checkpointInfo)
{
if (checkpointInfo.RecordCount <= 0)
{
return;
}
var index = checkpointInfo.FirstRecordInfo;
var counting = 0;
using (var tx = this.stateManager.CreateTransaction())
{
// Two break conditions:
// 1. counting == checkpointInfo.RecordCount
// 2. index == checkpointInfo.LastRecordInfo
// After breaking, double check if both condition is true.
// Otherwise there's a mismatch within checkpointInfo
while (counting < checkpointInfo.RecordCount)
{
var removed = await recordDictionary.TryRemoveAsync(tx, index.Index);
if (removed.HasValue && removed.Value != null)
{
counting++;
}
if (index.Equals(checkpointInfo.LastRecordInfo))
{
break;
}
index = index.Next();
}
if (!index.Equals(checkpointInfo.LastRecordInfo) || counting != checkpointInfo.RecordCount)
{
MessageDispatcherEventSource.Current.Warning(MessageDispatcherEventSource.EmptyTrackingId, this, nameof(this.CheckpointAsync), OperationStates.NoMatch, $"Mismatch in checkpoint info. LastRecordInfo={checkpointInfo.LastRecordInfo.Index}, Index={index.Index}, RecordCount={checkpointInfo.RecordCount}, Counting={counting}");
}
await this.metaDictonary.AddOrUpdateAsync(tx, this.checkpointKeyName, checkpointInfo.LastRecordInfo, (k, v) => checkpointInfo.LastRecordInfo);
await tx.CommitAsync();
}
lock (this.Lock)
{
this.currentCheckpointIndex = checkpointInfo.LastRecordInfo;
}
MessageDispatcherEventSource.Current.Info(MessageDispatcherEventSource.EmptyTrackingId, this, nameof(this.CheckpointAsync), OperationStates.Succeeded, $"Checkpoint CurrentCheckpoint={checkpointInfo.LastRecordInfo}. NumberOfRecords={checkpointInfo.RecordCount}, Actual NumberOfRecords={counting}");
}
public async Task <bool> DeleteAsync(string key)
{
using (var tx = _stateManager.CreateTransaction())
{
var result = await _dictionary.TryRemoveAsync(tx, key);
if (result.HasValue)
{
await tx.CommitAsync();
}
return(result.HasValue);
}
}
private static async Task RemoveKeyFromReliableDictionaryPrivateAsync(
this IReliableStateManager stateManager,
string dictionaryName,
string keyToRemove,
CancellationToken ctok)
{
IReliableDictionary <string, byte[]> dictionary = await stateManager.GetOrAddAsync <IReliableDictionary <string, byte[]> >(dictionaryName).ConfigureAwait(false);
using (var tx = stateManager.CreateTransaction())
{
await dictionary.TryRemoveAsync(tx, keyToRemove).ConfigureAwait(false);
await tx.CommitAsync().ConfigureAwait(false);
}
}
private async Task <bool> ExecuteRemoveAsync(Order order, IReliableDictionary <string, Order> orders)
{
using (var tx = this.stateManager.CreateTransaction())
{
var result = await orders.TryRemoveAsync(tx, order.Id);
await tx.CommitAsync();
if (result.HasValue)
{
return(true);
}
}
return(false);
}
/// <summary>
/// Read messages stored for an observer.
/// </summary>
/// <param name="uri">Observer uri.</param>
/// <returns>An enumerable containing messages for the observer.</returns>
public async Task <IEnumerable <Message> > ReadMessagesAsync(Uri uri)
{
if (uri == null)
{
throw new ArgumentException($"The {nameof(uri)} parameter cannot be null.", nameof(uri));
}
for (int k = 1; k <= ConfigurationHelper.MaxQueryRetryCount; k++)
{
try
{
List <Message> messageList = new List <Message>();
IReliableDictionary <string, List <Message> > topicsDictionary =
await this.StateManager.GetOrAddAsync <IReliableDictionary <string, List <Message> > >(Constants.ObserverDictionary);
using (ITransaction transaction = this.StateManager.CreateTransaction())
{
ConditionalValue <List <Message> > result = await topicsDictionary.TryGetValueAsync(transaction, uri.AbsoluteUri);
if (result.HasValue)
{
messageList = result.Value;
await topicsDictionary.TryRemoveAsync(transaction, uri.AbsoluteUri);
}
await transaction.CommitAsync();
}
return(messageList);
}
catch (FabricTransientException ex)
{
ServiceEventSource.Current.Error(ex);
}
catch (AggregateException ex)
{
foreach (Exception e in ex.InnerExceptions)
{
ServiceEventSource.Current.Error(e);
}
throw;
}
catch (Exception ex)
{
ServiceEventSource.Current.Error(ex);
throw;
}
await Task.Delay(ConfigurationHelper.BackoffQueryDelay);
}
throw new TimeoutException(Constants.RetryTimeoutExhausted);
}
public async Task DeleteAsync(IEnumerable <string> fullPaths, CancellationToken cancellationToken)
{
GenericValidation.CheckBlobFullPaths(fullPaths);
using (ServiceFabricTransaction tx = GetTransaction())
{
IReliableDictionary <string, byte[]> coll = await OpenCollectionAsync().ConfigureAwait(false);
foreach (string fullPath in fullPaths)
{
await coll.TryRemoveAsync(tx.Tx, ToFullPath(fullPath)).ConfigureAwait(false);
}
await tx.CommitAsync().ConfigureAwait(false);
}
}
public async Task DeleteAsync(IEnumerable <string> ids, CancellationToken cancellationToken)
{
GenericValidation.CheckBlobId(ids);
using (ServiceFabricTransaction tx = GetTransaction())
{
IReliableDictionary <string, byte[]> coll = await OpenCollectionAsync();
foreach (string id in ids)
{
await coll.TryRemoveAsync(tx.Tx, ToId(id));
}
await tx.CommitAsync();
}
}
protected override async Task RunAsync(CancellationToken cancellationToken)
{
int hourlyLimit = (int)Math.Round(3600D / HourlyInterval.TotalSeconds);
IReliableDictionary <DateTimeOffset, Dictionary <string, long> > dictionary = await
this.StateManager.GetOrAddAsync <IReliableDictionary <DateTimeOffset, Dictionary <string, long> > >($"history:/hourly");
while (true)
{
cancellationToken.ThrowIfCancellationRequested();
try
{
ClusterLoadInformation capacities = await this.query.GetClusterLoadAsync();
DateTimeOffset utcnow = DateTimeOffset.UtcNow;
DateTimeOffset timestamp = new DateTimeOffset(utcnow.Year, utcnow.Month, utcnow.Day, utcnow.Hour, utcnow.Minute, utcnow.Second, utcnow.Offset);
Dictionary <string, long> values = new Dictionary <string, long>();
foreach (var capacity in capacities.LoadMetricInformationList)
{
values[capacity.Name] = capacity.ClusterLoad;
}
using (ITransaction tx = this.StateManager.CreateTransaction())
{
long count = await dictionary.GetCountAsync(tx);
if (count >= hourlyLimit)
{
var min = await(await dictionary.CreateLinqAsyncEnumerable(tx)).Min(x => x.Key);
await dictionary.TryRemoveAsync(tx, min);
}
await dictionary.SetAsync(tx, timestamp, values);
await tx.CommitAsync();
}
}
catch (FabricTransientException)
{
// retry
}
await Task.Delay(HourlyInterval, cancellationToken);
}
}
/// <summary>
/// Delete the given key from the category dictionary.
/// </summary>
/// <param name="stateName">State name</param>
/// <param name="key">Key</param>
/// <returns>Task</returns>
internal async Task <bool> DeleteFromState(string stateName, string key)
{
IReliableDictionary <string, string> votesDictionary = await this.stateManager.GetOrAddAsync <IReliableDictionary <string, string> >(stateName);
using (ITransaction tx = this.stateManager.CreateTransaction())
{
if (await votesDictionary.ContainsKeyAsync(tx, key))
{
await votesDictionary.TryRemoveAsync(tx, key);
await tx.CommitAsync();
return(true);
}
return(false);
}
}
private async Task FinishRemovalOfSubscriptions(IReliableDictionary <string, string> subscriptions)
{
using (ITransaction tx = this.StateManager.CreateTransaction())
{
var unregisteredServices = new List <string>();
IAsyncEnumerable <KeyValuePair <string, string> > asyncEnumerable = await subscriptions.CreateEnumerableAsync(tx).ConfigureAwait(false);
using (IAsyncEnumerator <KeyValuePair <string, string> > asyncEnumerator = asyncEnumerable.GetAsyncEnumerator())
{
while (await asyncEnumerator.MoveNextAsync(CancellationToken.None).ConfigureAwait(false))
{
string subscriber = asyncEnumerator.Current.Key;
string topic = asyncEnumerator.Current.Value;
try
{
// https://social.msdn.microsoft.com/Forums/en-US/ce8aff1d-6246-4b53-9075-13b738a24b13/best-way-to-determine-if-a-service-already-exists?forum=AzureServiceFabric
// treat as "Desired state management"
// "Instead treat this more like desired state management - create the service until you are told it already exists."
Uri serviceUri = this.Context.CreateSubscriptionUri(topic, subscriber);
var description = new DeleteServiceDescription(serviceUri);
using (var fabric = new FabricClient())
{
await fabric.ServiceManager.DeleteServiceAsync(description);
}
}
catch (FabricElementNotFoundException)
{
await UnregisterSubscriberFromTopic(subscriber, topic);
unregisteredServices.Add(subscriber);
}
}
}
// do after enumerator is complete.
foreach (var sub in unregisteredServices)
{
await subscriptions.TryRemoveAsync(tx, sub);
}
await tx.CommitAsync();
}
}
public async Task DeleteBookAsync(Book book)
{
IReliableDictionary <Guid, Book> books =
await this.StateManager.GetOrAddAsync <IReliableDictionary <Guid, Book> >(BooksDictionaryName);
ServiceEventSource.Current.ServiceMessage(this, message: "Received delete book request. ID: {0}. Name: {1}.", args: new object[] { book.ID, book.BookName });
using (ITransaction tx = this.StateManager.CreateTransaction())
{
await books.TryRemoveAsync(tx, book.ID);
await tx.CommitAsync();
ServiceEventSource.Current.ServiceMessage(
this, message: "Succesfully deleted book. ID: {0}. Name: {1}.", args: new object[] { book.ID, book.BookName });
}
}
public async Task <string> DisconfigureService(string serviceName, string primaryCluster, string secondaryCluster)
{
List <String> keysToRemove = new List <String>();
IReliableDictionary <String, PartitionWrapper> myDictionary = await this.StateManager.GetOrAddAsync <IReliableDictionary <String, PartitionWrapper> >("partitionDictionary");
using (ITransaction tx = this.StateManager.CreateTransaction())
{
IAsyncEnumerable <KeyValuePair <String, PartitionWrapper> > enumerable = await myDictionary.CreateEnumerableAsync(tx);
IAsyncEnumerator <KeyValuePair <String, PartitionWrapper> > asyncEnumerator = enumerable.GetAsyncEnumerator();
while (await asyncEnumerator.MoveNextAsync(CancellationToken.None))
{
PartitionWrapper secondaryPartition = asyncEnumerator.Current.Value;
String partitionAccessKey = asyncEnumerator.Current.Key;
if (Utility.isPartitionFromPrimarySecondaryCombination(partitionAccessKey, primaryCluster, secondaryCluster))
{
if (secondaryPartition.serviceName.ToString().Equals(serviceName))
{
keysToRemove.Add(asyncEnumerator.Current.Key);
}
}
}
await tx.CommitAsync();
}
bool allPartitionsRemoved = true;
using (ITransaction tx = this.StateManager.CreateTransaction())
{
foreach (String key in keysToRemove)
{
ConditionalValue <PartitionWrapper> value = myDictionary.TryRemoveAsync(tx, key).Result;
if (!value.HasValue)
{
allPartitionsRemoved = false;
}
}
await tx.CommitAsync();
}
if (allPartitionsRemoved)
{
return(serviceName);
}
return(null);
}
private static async Task RemoveKeysWithPrefix(
ITransaction tx,
IReliableDictionary <string, byte[]> relDict,
string keyPrefix,
CancellationToken cancellationToken)
{
var enumerable = await relDict.CreateEnumerableAsync(tx);
var enumerator = enumerable.GetAsyncEnumerator();
while (await enumerator.MoveNextAsync(cancellationToken))
{
if (enumerator.Current.Key.StartsWith(keyPrefix, StringComparison.OrdinalIgnoreCase))
{
await relDict.TryRemoveAsync(tx, enumerator.Current.Key);
}
}
}