private async Task <long> SearchDevicesHistoryCountInternal(string startTimestamp, string endTimestamp = null, string deviceId = null)
{
long lRet = await GetQueueLengthAsyncInternal();
IReliableDictionary <DateTimeOffset, DeviceEventSeries> storeCompletedMessages = storeCompletedMessages = await this.stateManager.GetOrAddAsync <IReliableDictionary <DateTimeOffset, DeviceEventSeries> >(TargetSolution.Names.EventHistoryDictionaryName);
if (storeCompletedMessages != null)
{
DateTimeOffset intervalToSearchStart = DateTimeOffset.Parse(startTimestamp).ToUniversalTime();
DateTimeOffset intervalToSearchEnd = DateTimeOffset.UtcNow;
using (ITransaction tx = this.stateManager.CreateTransaction())
{
IAsyncEnumerable <KeyValuePair <DateTimeOffset, DeviceEventSeries> > enumerable = await storeCompletedMessages.CreateEnumerableAsync(tx, EnumerationMode.Ordered);
IAsyncEnumerator <KeyValuePair <DateTimeOffset, DeviceEventSeries> > enumerator = enumerable.GetAsyncEnumerator();
await enumerator.MoveNextAsync(appLifetime.ApplicationStopping);
if (lRet > 0 && enumerator.Current.Key.CompareTo(intervalToSearchStart) < 0)
{
lRet = 0;
if (endTimestamp == null)
{
enumerable = await storeCompletedMessages.CreateEnumerableAsync(
tx, key => (key.CompareTo(intervalToSearchStart) >= 0), EnumerationMode.Ordered);
}
else
{
intervalToSearchEnd = DateTimeOffset.Parse(endTimestamp);
enumerable = await storeCompletedMessages.CreateEnumerableAsync(
tx, key => (key.CompareTo(intervalToSearchStart) >= 0) && (key.CompareTo(intervalToSearchEnd) <= 0), EnumerationMode.Ordered);
}
enumerator = enumerable.GetAsyncEnumerator();
while (await enumerator.MoveNextAsync(appLifetime.ApplicationStopping))
{
lRet++;
}
}
await tx.CommitAsync();
}
}
ServiceEventSource.Current.ServiceMessage(this.context, $"DataService - SearchDevicesHistoryCount - Count of[{lRet}] for data range from [{startTimestamp}] to [{endTimestamp ?? "empty"}] - device [{deviceId ?? "All"}]");
return(lRet);
}
public async Task <List <VehicleModel> > GetVehicles(CancellationToken cancellationToken)
{
try
{
cancellationToken.ThrowIfCancellationRequested();
IReliableDictionary <Guid, VehicleModel> vehicleDictionary = await GetVehicleModelsFromReliableStateAsync();
List <VehicleModel> vehicleModels = new List <VehicleModel>();
using (ITransaction tx = _stateManager.CreateTransaction())
{
Microsoft.ServiceFabric.Data.IAsyncEnumerable <KeyValuePair <Guid, VehicleModel> > allVehicles =
await vehicleDictionary.CreateEnumerableAsync(tx, EnumerationMode.Unordered);
using (Microsoft.ServiceFabric.Data.IAsyncEnumerator <KeyValuePair <Guid, VehicleModel> > enumertor =
allVehicles.GetAsyncEnumerator())
{
while (await enumertor.MoveNextAsync(CancellationToken.None))
{
KeyValuePair <Guid, VehicleModel> current = enumertor.Current;
vehicleModels.Add(current.Value);
}
}
}
return(vehicleModels);
}
catch (Exception)
{
throw;
}
}
public async Task <IEnumerable <Domain.CustomerInformation> > GetCustomerInformationAsync(CancellationToken ct)
{
IList <Domain.CustomerInformation> results = new List <Domain.CustomerInformation>();
IReliableDictionary <string, Domain.CustomerInformation> customers =
await this.StateManager.GetOrAddAsync <IReliableDictionary <string, Domain.CustomerInformation> >(CustomerInformationDictionary);
ServiceEventSource.Current.Message("Called CustomerInformationDictionary to return CustomerInformation");
using (ITransaction tx = this.StateManager.CreateTransaction())
{
ServiceEventSource.Current.Message("Generating item views for {0} items", await customers.GetCountAsync(tx));
IAsyncEnumerator <KeyValuePair <string, Domain.CustomerInformation> > enumerator =
(await customers.CreateEnumerableAsync(tx)).GetAsyncEnumerator();
while (await enumerator.MoveNextAsync(ct))
{
results.Add(enumerator.Current.Value);
}
}
return(results);
}
public async Task <IEnumerable <perStoryData> > GetAllStoryPointData()
{
IReliableDictionary <Guid, perStoryData> storypointdata =
await _stateManager.GetOrAddAsync <IReliableDictionary <Guid, perStoryData> >("storypointdata");
var result = new List <perStoryData>();
using (ITransaction tx = _stateManager.CreateTransaction())
{
Microsoft.ServiceFabric.Data.IAsyncEnumerable <KeyValuePair <Guid, perStoryData> > allstorypointdata =
await storypointdata.CreateEnumerableAsync(tx, EnumerationMode.Unordered);
using (Microsoft.ServiceFabric.Data.IAsyncEnumerator <KeyValuePair <Guid, perStoryData> > enumerator =
allstorypointdata.GetAsyncEnumerator())
{
while (await enumerator.MoveNextAsync(CancellationToken.None))
{
KeyValuePair <Guid, perStoryData> current = enumerator.Current;
result.Add(current.Value);
}
}
}
return(result);
}
public async Task <List <KeyValuePair <string, int> > > GetAllVoteCounts()
{
ServiceEventSource.Current.Message("VotingData.GetAllVoteCounts start.");
List <KeyValuePair <string, int> > kvps = new List <KeyValuePair <string, int> >();
IReliableDictionary <string, int> votesDictionary = await this.stateManager.GetOrAddAsync <IReliableDictionary <string, int> >("votes");
using (ITransaction tx = this.stateManager.CreateTransaction())
{
if (votesDictionary != null)
{
IAsyncEnumerable <KeyValuePair <string, int> > e = await votesDictionary.CreateEnumerableAsync(tx);
IAsyncEnumerator <KeyValuePair <string, int> > items = e.GetAsyncEnumerator();
while (await items.MoveNextAsync(new CancellationToken()))
{
kvps.Add(new KeyValuePair <string, int>(items.Current.Key, items.Current.Value));
}
//kvps.Sort((x, y) => x.Value.CompareTo(y.Value) * -1); // intentionally commented out!
}
await tx.CommitAsync();
}
ServiceEventSource.Current.Message($"VotingData.GetAllVoteCounts end. Number of keys: {kvps.Count.ToString()}");
return(kvps);
}
public static Task ForeachAsync <TKey, TValue>(
this IReliableDictionary <TKey, TValue> instance, ITransaction tx, CancellationToken token, EnumerationMode enumMode, Func <TKey, bool> filter,
Action <KeyValuePair <TKey, TValue> > doSomething)
where TKey : IEquatable <TKey>, IComparable <TKey>
{
return(ForeachAsync <TKey, TValue>(instance.CreateEnumerableAsync(tx, filter, enumMode), token, doSomething));
}
public async Task <IActionResult> Get()
{
try
{
CancellationToken ct = new CancellationToken();
IReliableDictionary <string, string> votesDictionary = await this.stateManager.GetOrAddAsync <IReliableDictionary <string, string> >(Enums.StateName.VoterIdVoteForPair.ToString());
using (ITransaction tx = this.stateManager.CreateTransaction())
{
IAsyncEnumerable <KeyValuePair <string, string> > list = await votesDictionary.CreateEnumerableAsync(tx);
IAsyncEnumerator <KeyValuePair <string, string> > enumerator = list.GetAsyncEnumerator();
Dictionary <string, int> dictionary = new Dictionary <string, int>();
while (await enumerator.MoveNextAsync(ct))
{
if (dictionary.ContainsKey(enumerator.Current.Value))
{
dictionary[enumerator.Current.Value] = dictionary[enumerator.Current.Value] + 1;
}
else
{
dictionary[enumerator.Current.Value] = 1;
}
}
var result = dictionary.OrderByDescending(d => d.Value);
return(Json(result));
}
}
catch (Exception)
{
return(Json(new List <KeyValuePair <string, string> >()));
}
}
public async Task <CheckoutSummary[]> GetOrderHistoryAsync(string userId)
{
List <CheckoutSummary> result = new List <CheckoutSummary>();
IReliableDictionary <DateTime, CheckoutSummary> history =
await StateManager.GetOrAddAsync <IReliableDictionary <DateTime, CheckoutSummary> >(HISTORY_COLLECTION);
using (ITransaction tx = StateManager.CreateTransaction())
{
IAsyncEnumerable <KeyValuePair <DateTime, CheckoutSummary> > allCheckoutSummaries =
await history.CreateEnumerableAsync(tx, EnumerationMode.Unordered);
using (IAsyncEnumerator <KeyValuePair <DateTime, CheckoutSummary> > enumerator = allCheckoutSummaries.GetAsyncEnumerator())
{
while (await enumerator.MoveNextAsync(CancellationToken.None))
{
KeyValuePair <DateTime, CheckoutSummary> current = enumerator.Current;
result.Add(current.Value);
}
}
}
return(result.ToArray());
}
public static async Task <IList <KeyValuePair <Guid, T> > > QueryReliableDictionary <T>
(IReliableStateManager stateManager, string collectionName, Func <T, bool> filter)
{
var result = new List <KeyValuePair <Guid, T> >();
IReliableDictionary <Guid, T> reliableDictionary =
await stateManager.GetOrAddAsync <IReliableDictionary <Guid, T> >(collectionName);
using (ITransaction tx = stateManager.CreateTransaction())
{
IAsyncEnumerable <KeyValuePair <Guid, T> > asyncEnumerable = await reliableDictionary.CreateEnumerableAsync(tx);
using (IAsyncEnumerator <KeyValuePair <Guid, T> > asyncEnumerator = asyncEnumerable.GetAsyncEnumerator())
{
while (await asyncEnumerator.MoveNextAsync(CancellationToken.None))
{
if (filter(asyncEnumerator.Current.Value))
{
result.Add(asyncEnumerator.Current);
}
}
}
}
return(result);
}
public async Task <IActionResult> Get()
{
CancellationToken ct = new CancellationToken();
// (1)Use StateManager to get or add a reliable dictionary called counts.
IReliableDictionary <string, int> votesDictionary = await this.stateManager.GetOrAddAsync <IReliableDictionary <string, int> >("counts");
//(2) All interactions with values in a reliable dictionary require a transaction, this using statement (2) creates that transaction.
using (ITransaction tx = this.stateManager.CreateTransaction())
{
IAsyncEnumerable <KeyValuePair <string, int> > list = await votesDictionary.CreateEnumerableAsync(tx);
IAsyncEnumerator <KeyValuePair <string, int> > enumerator = list.GetAsyncEnumerator();
List <KeyValuePair <string, int> > result = new List <KeyValuePair <string, int> >();
//(3) In the transaction, we then update the value of the relevant key for the voting option and commits the operation.
//Once the commit method returns, the data is updated in the dictionary and replicated to other nodes in the cluster.
//The data is now safely stored in the cluster, and the back-end service can fail over to other nodes, still having the data available.
while (await enumerator.MoveNextAsync(ct))
{
result.Add(enumerator.Current);
}
return(this.Json(result));
}
}
public async Task <IEnumerable <BlobId> > ListAsync(ListOptions options, CancellationToken cancellationToken)
{
if (options == null)
{
options = new ListOptions();
}
var result = new List <BlobId>();
using (ServiceFabricTransaction tx = GetTransaction())
{
IReliableDictionary <string, byte[]> coll = await OpenCollectionAsync();
IAsyncEnumerable <KeyValuePair <string, byte[]> > enumerable =
await coll.CreateEnumerableAsync(tx.Tx);
using (IAsyncEnumerator <KeyValuePair <string, byte[]> > enumerator = enumerable.GetAsyncEnumerator())
{
while (await enumerator.MoveNextAsync(cancellationToken))
{
KeyValuePair <string, byte[]> current = enumerator.Current;
if (options.Prefix == null || current.Key.StartsWith(options.Prefix))
{
result.Add(new BlobId(current.Key, BlobItemKind.File));
}
}
}
}
return(result);
}
public async Task <List <RoomData> > GetAllRoomsAsync(CancellationToken cancellationToken)
{
List <RoomData> roomsResult = new List <RoomData>();
using (var tx = this.StateManager.CreateTransaction())
{
var rooms = await roomsDictionary.CreateEnumerableAsync(tx);
var roomsEnumerator = rooms.GetAsyncEnumerator();
while (await roomsEnumerator.MoveNextAsync(cancellationToken))
{
roomsResult.Add(roomsEnumerator.Current.Value);
}
await tx.CommitAsync();
}
foreach (RoomData r in roomsResult)
{
try
{
var roomActor = ActorProxy.Create <IRoomActor>(new ActorId(r.Number), new Uri("fabric:/AffittaCamere/RoomActorService"));
var info = await roomActor.GetRoomInfoAsync(cancellationToken);
r.IsAvailable = info == null ? true : !info.Reserved;
r.User = info == null ? string.Empty : info.User;
}
catch (Exception)
{
}
}
return(roomsResult);
}
public async Task <IActionResult> Get()
{
CancellationToken ct = new CancellationToken();
IReliableDictionary <string, int> votesDictionary = await this.stateManager.GetOrAddAsync <IReliableDictionary <string, int> >("counts");
using (ITransaction tx = this.stateManager.CreateTransaction())
{
IAsyncEnumerable <KeyValuePair <string, int> > list = await votesDictionary.CreateEnumerableAsync(tx);
IAsyncEnumerator <KeyValuePair <string, int> > enumerator = list.GetAsyncEnumerator();
List <KeyValuePair <string, int> > result = new List <KeyValuePair <string, int> >();
while (await enumerator.MoveNextAsync(ct))
{
result.Add(enumerator.Current);
}
if (!result.Any())
{
result.Add(new KeyValuePair <string, int>("Pizza", 1));
result.Add(new KeyValuePair <string, int>("Sushi", 9));
}
return(this.Json(result));
}
}
/// <summary>
/// Enumerates scheduled health checks.
/// </summary>
internal async Task EnumerateHealthChecksAsync()
{
// Check if the partition is readable/writable.
if (PartitionAccessStatus.Granted != this._service.ReadStatus || PartitionAccessStatus.Granted != this._service.WriteStatus)
{
return;
}
// Get the health check schedule items.
IReliableDictionary <long, WatchdogScheduledItem> scheduleDict = await this.GetHealthCheckScheduleDictionaryAsync();
// Create a transaction for the enumeration.
using (ITransaction eTx = this._service.StateManager.CreateTransaction())
{
// Create the AsyncEnumerator.
IAsyncEnumerator <KeyValuePair <long, WatchdogScheduledItem> > ae =
(await scheduleDict.CreateEnumerableAsync(eTx, EnumerationMode.Ordered)).GetAsyncEnumerator();
while (await ae.MoveNextAsync(this._token))
{
// Compare the times, if this item is due for execution
if (ae.Current.Value.ExecutionTicks < DateTimeOffset.UtcNow.UtcTicks)
{
await this.PerformItemHealthCheckAsync(ae.Current.Value);
}
}
await eTx.CommitAsync();
}
this._healthState = HealthState.Ok;
}
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())
{
IAsyncEnumerator <KeyValuePair <CustomerOrderActorMessageId, DateTime> > enumerator =
(await recentRequests.CreateEnumerableAsync(tx)).GetAsyncEnumerator();
while (await enumerator.MoveNextAsync(cancellationToken))
{
//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 (enumerator.Current.Value < (DateTime.UtcNow.AddHours(-2)))
{
await recentRequests.TryRemoveAsync(tx, enumerator.Current.Key);
await requestHistory.TryRemoveAsync(tx, enumerator.Current.Key);
}
}
await tx.CommitAsync();
}
//sleep for 5 minutes then scan again
await Task.Delay(TimeSpan.FromMinutes(5), cancellationToken);
}
}
public async Task <HealthIndex> Get(int countyId)
{
IReliableDictionary <Guid, CountyDoctorStats> countyHealth =
await this.stateManager.GetOrAddAsync <IReliableDictionary <Guid, CountyDoctorStats> >(
string.Format(CountyService.CountyHealthDictionaryName, countyId));
IList <KeyValuePair <Guid, CountyDoctorStats> > doctorStats = new List <KeyValuePair <Guid, CountyDoctorStats> >();
using (ITransaction tx = this.stateManager.CreateTransaction())
{
var enumerator = (await countyHealth.CreateEnumerableAsync(tx)).GetAsyncEnumerator();
while (await enumerator.MoveNextAsync(CancellationToken.None))
{
doctorStats.Add(enumerator.Current);
}
}
if (doctorStats.Count > 0)
{
return(this.indexCalculator.ComputeAverageIndex(doctorStats.Select(x => x.Value.AverageHealthIndex)));
}
return(this.indexCalculator.ComputeIndex(-1));
}
/// <summary>
/// Add CheckoutSummary to the history
/// </summary>
/// <param name="userId"></param>
/// <returns></returns>
public async Task <CheckoutSummary[]> GetOrderHitoryAsync(string userId)
{
//get reference to history transaction
var result = new List <CheckoutSummary>();
IReliableDictionary <DateTime, CheckoutSummary> history =
await StateManager.GetOrAddAsync <IReliableDictionary <DateTime, CheckoutSummary> >("history");
//go through all items in history collection - return as list of history summary
using (ITransaction tx = StateManager.CreateTransaction())
{
Microsoft.ServiceFabric.Data.IAsyncEnumerable <KeyValuePair <DateTime, CheckoutSummary> > allProducts =
await history.CreateEnumerableAsync(tx, EnumerationMode.Unordered);
using (Microsoft.ServiceFabric.Data.IAsyncEnumerator <KeyValuePair <DateTime, CheckoutSummary> > enumerator = allProducts.GetAsyncEnumerator())
{
while (await enumerator.MoveNextAsync(CancellationToken.None))
{
KeyValuePair <DateTime, CheckoutSummary> current = enumerator.Current;
result.Add(current.Value);
}
}
}
return(result.ToArray());
}
private async Task <IEnumerable <Chunk> > GetChunks_impl(Guid?replicaId)
{
using (var tx = ServiceFabricUtils.CreateTransaction())
{
retry:
try
{
if (replicaId.HasValue)
{
var res = await m_chunktable.TryGetValueAsync(tx, replicaId.Value);
if (res.HasValue)
{
return(Utils.Deserialize <Chunk[]>(res.Value));
}
}
else
{
var res = await m_chunktable.CreateEnumerableAsync(tx, EnumerationMode.Unordered);
var enumerator = res.GetAsyncEnumerator();
List <Chunk> chunks = new List <Chunk>();
while (await enumerator.MoveNextAsync(m_cancel))
{
chunks.AddRange(Utils.Deserialize <Chunk[]>(enumerator.Current.Value));
}
return(chunks);
}
}
catch (TimeoutException) { await Task.Delay(1000); goto retry; }
catch (Exception ex) { Log.WriteLine(LogLevel.Error, "{0}", $"ServiceFabricChunkTable: {ex.ToString()}"); }
finally { await tx.CommitAsync(); }
}
return(null);
}
public async Task <IActionResult> Get(string eventId, string topicId)
{
try
{
List <Feedback> result = new List <Feedback>();
var tryGetResult = await this.stateManager.TryGetAsync <IReliableDictionary <string, Feedback> >(ValuesDictionaryName);
if (tryGetResult.HasValue)
{
IReliableDictionary <string, Feedback> dictionary = tryGetResult.Value;
using (ITransaction tx = this.stateManager.CreateTransaction())
{
var enumerable = await dictionary.CreateEnumerableAsync(tx);
var enumerator = enumerable.GetAsyncEnumerator();
while (await enumerator.MoveNextAsync(CancellationToken.None))
{
result.Add(enumerator.Current.Value);
}
}
}
return(this.Json(result));
}
catch (FabricException)
{
return(new ContentResult {
StatusCode = 503, Content = "The service was unable to process the request. Please try again."
});
}
}
public async Task <IActionResult> Get()
{
ServiceEventSource.Current.Message($"VotingData.Get start. ");
CancellationToken ct = new CancellationToken();
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())
{
IAsyncEnumerable <KeyValuePair <string, int> > list = await votesDictionary.CreateEnumerableAsync(tx);
IAsyncEnumerator <KeyValuePair <string, int> > enumerator = list.GetAsyncEnumerator();
List <KeyValuePair <string, int> > result = new List <KeyValuePair <string, int> >();
while (await enumerator.MoveNextAsync(ct))
{
result.Add(enumerator.Current);
}
ServiceEventSource.Current.Message($"VotingData.Get end.");
return(this.Json(result));
}
}
public async Task Clear()
{
DateTimeOffset now = DateTimeOffset.Now;
var toKeep = new List <KeyValuePair <Guid, DateTimeOffset> >();
using (ITransaction tx = this.sm.CreateTransaction())
{
var asyncEnumerable = await dictionary.CreateEnumerableAsync(tx);
using (var asyncEnumerator = asyncEnumerable.GetAsyncEnumerator())
{
while (await asyncEnumerator.MoveNextAsync(CancellationToken.None))
{
if ((now - asyncEnumerator.Current.Value).TotalSeconds < maxDelaySeconds)
{
toKeep.Add(asyncEnumerator.Current);
}
}
}
await dictionary.ClearAsync();
foreach (var pair in toKeep)
{
await dictionary.TryAddAsync(tx, pair.Key, pair.Value);
}
await tx.CommitAsync();
lastClear = DateTimeOffset.Now;
}
}
public async Task <IList <Book> > GetBooksAsync(CancellationToken ct)
{
IReliableDictionary <Guid, Book> books =
await this.StateManager.GetOrAddAsync <IReliableDictionary <Guid, Book> >(BooksDictionaryName);
ServiceEventSource.Current.Message(message: "Called GetBooksAsync to return books");
IList <Book> results = new List <Book>();
using (ITransaction tx = this.StateManager.CreateTransaction())
{
ServiceEventSource.Current.Message(message: "Generating item views for {0} items", args: new object[] { await books.GetCountAsync(tx) });
IAsyncEnumerator <KeyValuePair <Guid, Book> > enumerator =
(await books.CreateEnumerableAsync(tx)).GetAsyncEnumerator();
while (await enumerator.MoveNextAsync(ct))
{
results.Add(enumerator.Current.Value);
}
}
return(results);
}
public async Task <IReadOnlyCollection <NetCore.Blobs.Blob> > ListAsync(ListOptions options, CancellationToken cancellationToken)
{
if (options == null)
{
options = new ListOptions();
}
var result = new List <NetCore.Blobs.Blob>();
using (ServiceFabricTransaction tx = GetTransaction())
{
IReliableDictionary <string, byte[]> coll = await OpenCollectionAsync().ConfigureAwait(false);
global::Microsoft.ServiceFabric.Data.IAsyncEnumerable <KeyValuePair <string, byte[]> > enumerable =
await coll.CreateEnumerableAsync(tx.Tx).ConfigureAwait(false);
using (global::Microsoft.ServiceFabric.Data.IAsyncEnumerator <KeyValuePair <string, byte[]> > enumerator = enumerable.GetAsyncEnumerator())
{
while (await enumerator.MoveNextAsync(cancellationToken).ConfigureAwait(false))
{
KeyValuePair <string, byte[]> current = enumerator.Current;
if (options.FilePrefix == null || current.Key.StartsWith(options.FilePrefix))
{
result.Add(new NetCore.Blobs.Blob(current.Key, BlobItemKind.File));
}
}
}
}
return(result);
}
public async Task <IEnumerable <InventoryItemView> > GetCustomerInventoryAsync(CancellationToken ct)
{
IReliableDictionary <InventoryItemId, InventoryItem> inventoryItems =
await this.StateManager.GetOrAddAsync <IReliableDictionary <InventoryItemId, InventoryItem> >(InventoryItemDictionaryName);
ServiceEventSource.Current.Message("Called GetCustomerInventory to return InventoryItemView");
await this.PrintInventoryItemsAsync(inventoryItems, ct);
IList <InventoryItemView> results = new List <InventoryItemView>();
using (ITransaction tx = this.StateManager.CreateTransaction())
{
ServiceEventSource.Current.Message("Generating item views for {0} items", await inventoryItems.GetCountAsync(tx));
IAsyncEnumerator <KeyValuePair <InventoryItemId, InventoryItem> > enumerator =
(await inventoryItems.CreateEnumerableAsync(tx)).GetAsyncEnumerator();
while (await enumerator.MoveNextAsync(ct))
{
if (enumerator.Current.Value.AvailableStock > 0)
{
results.Add(enumerator.Current.Value);
}
}
}
return(results);
}
public async Task <IEnumerable <Product> > GetAllProducts()
{
IReliableDictionary <Guid, Product> products =
await _stateManager.GetOrAddAsync <IReliableDictionary <Guid, Product> >("products");
var result = new List <Product>();
using (ITransaction tx = _stateManager.CreateTransaction())
{
Microsoft.ServiceFabric.Data.IAsyncEnumerable <KeyValuePair <Guid, Product> > allProducts =
await products.CreateEnumerableAsync(tx, EnumerationMode.Unordered);
using (Microsoft.ServiceFabric.Data.IAsyncEnumerator <KeyValuePair <Guid, Product> > enumerator =
allProducts.GetAsyncEnumerator())
{
while (await enumerator.MoveNextAsync(CancellationToken.None))
{
KeyValuePair <Guid, Product> current = enumerator.Current;
result.Add(current.Value);
}
}
}
return(result);
}
public async Task <IActionResult> Get()
{
try
{
var result = new List <KeyValuePair <string, BookingAggregates> >();
var tryGetResult = await _stateManager.TryGetAsync <IReliableDictionary <string, BookingAggregates> >(ValuesDictionaryName);
if (tryGetResult.HasValue)
{
IReliableDictionary <string, BookingAggregates> dictionary = tryGetResult.Value;
using (ITransaction tx = _stateManager.CreateTransaction())
{
var list = await dictionary.CreateEnumerableAsync(tx);
var enumerator = list.GetAsyncEnumerator();
while (await enumerator.MoveNextAsync(CancellationToken.None))
{
result.Add(enumerator.Current);
}
}
}
return(Json(result));
}
catch (FabricException)
{
return(new ContentResult {
StatusCode = 503, Content = "The service was unable to process the request. Please try again."
});
}
}
public async Task <List <User> > GetUsersAsync(CancellationToken cancellationToken)
{
IReliableDictionary <string, User> users =
await this.StateManager.GetOrAddAsync <IReliableDictionary <string, User> >(StateManagerKey);
var returnList = new List <User>();
using (var tx = this.StateManager.CreateTransaction())
{
var asyncEnumerable = await users.CreateEnumerableAsync(tx);
var asyncEnumerator = asyncEnumerable.GetAsyncEnumerator();
try
{
while (await asyncEnumerator.MoveNextAsync(cancellationToken))
{
returnList.Add(asyncEnumerator.Current.Value);
}
}
catch (OperationCanceledException)
{
// Ignore
}
await tx.CommitAsync();
}
return(returnList);
}
public async Task <IEnumerable <Product> > GetAllProducts()
{
IReliableDictionary <Guid, Product> products = await _stateManager
.GetOrAddAsync <IReliableDictionary <Guid, Product> >("products");
var results = new List <Product>();
// Everything is done via transactions
using (ITransaction tx = _stateManager.CreateTransaction())
{
// Get all products from Service Fabric async. (Incurs a call cost)
// Returns enumerable instead of list because there can be millions of products.
Microsoft.ServiceFabric.Data.IAsyncEnumerable <KeyValuePair <Guid, Product> > allProducts =
await products.CreateEnumerableAsync(tx, EnumerationMode.Unordered);
// Get product enumerator from Service Fabric async. (Incurs a call cost)
using (Microsoft.ServiceFabric.Data.IAsyncEnumerator <KeyValuePair <Guid, Product> > enumerator =
allProducts.GetAsyncEnumerator())
{
while (await enumerator.MoveNextAsync(CancellationToken.None))
{
KeyValuePair <Guid, Product> current = enumerator.Current;
results.Add(current.Value);
}
}
}
return(results);
}
private async Task EnumerateRemindersAsync(
IReliableDictionary <string, byte[]> reminderDictionary,
Dictionary <string, ReminderCompletedData> reminderCompletedDataDict,
ActorReminderCollection reminderCollection,
CancellationToken cancellationToken)
{
using (var tx = this.stateManager.CreateTransaction())
{
var enumerable = await reminderDictionary.CreateEnumerableAsync(tx);
var enumerator = enumerable.GetAsyncEnumerator();
while (await enumerator.MoveNextAsync(cancellationToken))
{
var data = enumerator.Current.Value;
if (data == null)
{
continue;
}
var reminderData = ActorReminderDataSerializer.Deserialize(data);
var key = CreateStorageKey(reminderData.ActorId, reminderData.Name);
ReminderCompletedData reminderCompletedData;
reminderCompletedDataDict.TryGetValue(key, out reminderCompletedData);
reminderCollection.Add(
reminderData.ActorId,
new ActorReminderState(reminderData, this.logicalTimeManager.CurrentLogicalTime, reminderCompletedData));
}
}
}
public static async Task <IAsyncEnumerable <KeyValuePair <TKey, TValue> > > CreateLinqAsyncEnumerable <TKey, TValue>(
this IReliableDictionary <TKey, TValue> dictionary, Microsoft.ServiceFabric.Data.ITransaction txn, Func <TKey, bool> filter, EnumerationMode enumerationMode)
where TKey : IComparable <TKey>, IEquatable <TKey>
{
var enumerable = await dictionary.CreateEnumerableAsync(txn, filter, enumerationMode).ConfigureAwait(false);
return(enumerable.AsAsyncEnumerable());
}
/// <summary>
/// Gets a list of active clusters. Clusters that are new, being created, or ready and not expired are considered active.
/// </summary>
/// <param name="clusterDictionary"></param>
/// <returns></returns>
private async Task<IEnumerable<KeyValuePair<int, Cluster>>> GetActiveClusters(
IReliableDictionary<int, Cluster> clusterDictionary, CancellationToken cancellationToken)
{
List<KeyValuePair<int, Cluster>> activeClusterList = new List<KeyValuePair<int, Cluster>>();
using (ITransaction tx = this.StateManager.CreateTransaction())
{
IAsyncEnumerable<KeyValuePair<int, Cluster>> clusterAsyncEnumerable = await clusterDictionary.CreateEnumerableAsync(tx);
await clusterAsyncEnumerable.ForeachAsync(
cancellationToken,
x =>
{
if (x.Value.Status == ClusterStatus.New ||
x.Value.Status == ClusterStatus.Creating ||
x.Value.Status == ClusterStatus.Ready)
{
activeClusterList.Add(x);
}
});
}
return activeClusterList;
}
async protected override Task RunAsync(CancellationToken cancelServicePartitionReplica)
{
_roomsState = await StateManager.GetOrAddAsync<IReliableDictionary<string, RoomData>>("Rooms");
using (var tx = StateManager.CreateTransaction())
{
var roomEnumerable = await _roomsState.CreateEnumerableAsync(tx, EnumerationMode.Unordered);
using (var roomEnumerator = roomEnumerable.GetAsyncEnumerator())
{
while (await roomEnumerator.MoveNextAsync(cancelServicePartitionReplica).ConfigureAwait(false))
{
roomEnumerator.Current.Value.Members = new List<RoomMember>();
Rooms.Add(roomEnumerator.Current.Key, roomEnumerator.Current.Value);
}
}
}
ServiceEventSource.Current.ServiceMessage(this, "RunAsync called");
while (!cancelServicePartitionReplica.IsCancellationRequested)
{
await Task.Delay(10000, cancelServicePartitionReplica);
}
}
private async Task PrintInventoryItemsAsync(IReliableDictionary<InventoryItemId, InventoryItem> inventoryItems, CancellationToken cancellationToken)
{
using (ITransaction tx = this.StateManager.CreateTransaction())
{
ServiceEventSource.Current.Message("Printing Inventory for {0} items:", await inventoryItems.GetCountAsync(tx));
IAsyncEnumerator<KeyValuePair<InventoryItemId, InventoryItem>> enumerator =
(await inventoryItems.CreateEnumerableAsync(tx)).GetAsyncEnumerator();
while (await enumerator.MoveNextAsync(cancellationToken))
{
ServiceEventSource.Current.Message("ID:{0}|Item:{1}", enumerator.Current.Key, enumerator.Current.Value);
}
}
}