public async Task <long> GetCountAsync(ITransaction tx)
{
if (reliableDictionary == null)
{
await InitializeReliableDictionary();
}
return(await reliableDictionary.GetCountAsync(tx));
}
public async Task <IHttpActionResult> Get(int countyId)
{
IReliableDictionary <Guid, CountyDoctorStats> countyHealth =
await this.stateManager.GetOrAddAsync <IReliableDictionary <Guid, CountyDoctorStats> >(string.Format(Service.CountyHealthDictionaryName, countyId));
using (ITransaction tx = this.stateManager.CreateTransaction())
{
if (await countyHealth.GetCountAsync(tx) > 0)
{
IList <KeyValuePair <Guid, CountyDoctorStats> > doctorStats = new List <KeyValuePair <Guid, CountyDoctorStats> >();
IAsyncEnumerator <KeyValuePair <Guid, CountyDoctorStats> > enumerator = (await countyHealth.CreateEnumerableAsync(tx)).GetAsyncEnumerator();
while (await enumerator.MoveNextAsync(CancellationToken.None))
{
doctorStats.Add(enumerator.Current);
}
return(this.Ok(this.indexCalculator.ComputeAverageIndex(doctorStats.Select(x => x.Value.AverageHealthIndex))));
}
else
{
return(this.Ok(-1));
}
}
}
/// <summary>
/// The platform calls this method when an instance of your service is placed and ready to execute.
/// </summary>
/// <param name="cancellationToken">
/// The system uses a cancellation token to signal your service when it's time to stop running.
/// </param>
/// <returns></returns>
protected override async Task RunAsync(CancellationToken cancellationToken)
{
IReliableDictionary <int, CustomObject> dictionary = await this.StateManager.GetOrAddAsync <IReliableDictionary <int, CustomObject> >("dictionary1");
int i = 1;
while (!cancellationToken.IsCancellationRequested)
{
using (ITransaction tx = this.StateManager.CreateTransaction())
{
await dictionary.AddOrUpdateAsync(tx, i, new CustomObject()
{
Data = i
}, (k, v) => new CustomObject()
{
Data = v.Data + 1
});
await tx.CommitAsync();
}
ServiceEventSource.Current.ServiceMessage(
this,
"Total Custom Objects: {0}. Data Average: {1}",
await dictionary.GetCountAsync(),
dictionary.Average(item => item.Value.Data));
i = i % 10 == 0 ? 1 : i + 1;
await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken);
}
}
// Maps the paritions of the applications from primary cluster and secondary cluster
public async Task MapPartitionsOfApplication(Uri applicationName, ClusterDetails primaryCluster, ClusterDetails secondaryCluster, String reliableDictionary)
{
FabricClient primaryFabricClient = new FabricClient(primaryCluster.address + ':' + primaryCluster.clientConnectionEndpoint);
FabricClient secondaryFabricClient = new FabricClient(secondaryCluster.address + ':' + secondaryCluster.clientConnectionEndpoint);
IReliableDictionary <Guid, PartitionWrapper> myDictionary = await this.StateManager.GetOrAddAsync <IReliableDictionary <Guid, PartitionWrapper> >(reliableDictionary);
ServiceList services = await primaryFabricClient.QueryManager.GetServiceListAsync(applicationName);
foreach (Service service in services)
{
ServicePartitionList primaryPartitions = await primaryFabricClient.QueryManager.GetPartitionListAsync(service.ServiceName);
ServicePartitionList secondaryPartitions = await secondaryFabricClient.QueryManager.GetPartitionListAsync(service.ServiceName);
await MapPartitions(applicationName, service.ServiceName, primaryCluster, primaryPartitions, secondaryCluster, secondaryPartitions, reliableDictionary);
using (var tx = this.StateManager.CreateTransaction())
{
var result = await myDictionary.GetCountAsync(tx);
ServiceEventSource.Current.ServiceMessage(this.Context, "The number of items in dictionary are : {0}", result);
await tx.CommitAsync();
}
}
}
// PRIVATE Methods
public async Task <long> GetQueueLengthAsyncInternal()
{
long count = -1;
IReliableDictionary <DateTimeOffset, DeviceEventSeries> storeCompletedMessages = await this.stateManager.GetOrAddAsync <IReliableDictionary <DateTimeOffset, DeviceEventSeries> >(TargetSolution.Names.EventHistoryDictionaryName);
using (ITransaction tx = this.stateManager.CreateTransaction())
{
try
{
count = await storeCompletedMessages.GetCountAsync(tx);
await tx.CommitAsync();
}
catch (TimeoutException te)
{
// transient error. Could Retry if one desires .
ServiceEventSource.Current.ServiceMessage(this.context, $"DataService - GetQueueLengthAsync - TimeoutException : Message=[{te.ToString()}]");
tx.Abort();
}
catch (Exception ex)
{
ServiceEventSource.Current.ServiceMessage(this.context, $"DataService - GetQueueLengthAsync - General Exception - Message=[{0}]", ex);
tx.Abort();
}
}
return(count);
}
private async Task <long> ExecuteCountAsync(IReliableDictionary <string, Order> orders)
{
long count = 0;
using (ITransaction tx = this.stateManager.CreateTransaction())
{
count = await orders.GetCountAsync(tx);
await tx.CommitAsync();
}
return(count);
}
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 <IActionResult> GetPlayerStats()
{
try
{
if (!PlayerManager.IsActive)
{
return new ContentResult {
StatusCode = 500, Content = "Service is still starting up. Please retry."
}
}
;
IReliableDictionary <string, PlayerPackage> playdict =
await this.stateManager.GetOrAddAsync <IReliableDictionary <string, PlayerPackage> >(PlayersDictionaryName);
PlayerStats stats = new PlayerStats(0, 0, 0, 0);
//Go through the player dictionary gathering data and averaging or summing as you go.
using (ITransaction tx = this.stateManager.CreateTransaction())
{
stats.NumAccounts = await playdict.GetCountAsync(tx);
IAsyncEnumerable <KeyValuePair <string, PlayerPackage> > enumerable = await playdict.CreateEnumerableAsync(tx);
IAsyncEnumerator <KeyValuePair <string, PlayerPackage> > enumerator = enumerable.GetAsyncEnumerator();
while (await enumerator.MoveNextAsync(CancellationToken.None))
{
//Averaging
if (enumerator.Current.Value.State == LogState.LoggedIn)
{
stats.NumLoggedIn++;
}
stats.AvgNumLogins += (float)enumerator.Current.Value.NumLogins / stats.NumAccounts;
stats.AvgAccountAge += (double)DateTime.Now.ToUniversalTime().Subtract(enumerator.Current.Value.FirstLogin).Seconds /
stats.NumAccounts;
}
await tx.CommitAsync();
}
return(this.Json(stats));
}
catch (Exception e)
{
return(exceptionHandler(e));
}
}
// Maps the paritions of the applications from primary cluster and secondary cluster
public async Task MapPartitionsOfApplication(Uri applicationName, ClusterDetails primaryCluster, ClusterDetails secondaryCluster, String reliableDictionary)
{
FabricClient primaryFabricClient = GetSecureFabricClient(primaryCluster.address + ':' + primaryCluster.clientConnectionEndpoint, primaryCluster.certificateThumbprint);
FabricClient secondaryFabricClient = GetSecureFabricClient(secondaryCluster.address + ':' + secondaryCluster.clientConnectionEndpoint, secondaryCluster.certificateThumbprint);
IReliableDictionary <Guid, PartitionWrapper> myDictionary = await this.StateManager.GetOrAddAsync <IReliableDictionary <Guid, PartitionWrapper> >(reliableDictionary);
ServiceList services = await primaryFabricClient.QueryManager.GetServiceListAsync(applicationName);
foreach (Service service in services)
{
ServicePartitionList primaryPartitions;
ServicePartitionList secondaryPartitions;
if (service.ServiceKind == ServiceKind.Stateless)
{
continue;
}
try
{
primaryPartitions = await primaryFabricClient.QueryManager.GetPartitionListAsync(service.ServiceName);
}
catch (Exception ex)
{
ServiceEventSource.Current.Message("Restore Service: Exception getting primary partitions {0}", ex);
throw;
}
try
{
secondaryPartitions = await secondaryFabricClient.QueryManager.GetPartitionListAsync(service.ServiceName);
}
catch (Exception ex)
{
ServiceEventSource.Current.Message("Restore Service: Exception getting secondary partitions {0}", ex);
throw;
}
await MapPartitions(applicationName, service.ServiceName, primaryCluster, primaryPartitions, secondaryCluster, secondaryPartitions, reliableDictionary);
using (var tx = this.StateManager.CreateTransaction())
{
var result = await myDictionary.GetCountAsync(tx);
ServiceEventSource.Current.ServiceMessage(this.Context, "The number of items in dictionary are : {0}", result);
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);
}
}
public async Task <long> GetKeyCountAsync(CancellationToken cancellationToken)
{
IReliableDictionary <SessionKeyItemId, SessionKeyItem> sessionKeyItems =
await StateManager
.GetOrAddAsync <IReliableDictionary <SessionKeyItemId, SessionKeyItem> >(SessionKeyDictionaryName);
ServiceEventSource.Current.Message($"Method started {nameof(SessionKeys)}->GetKeyCountAsync() at: {DateTime.UtcNow}");
long sessionKeyCount = 0;
if (sessionKeyItems != null)
{
using (var tx = StateManager.CreateTransaction()) {
sessionKeyCount = await sessionKeyItems.GetCountAsync(tx);
}
}
ServiceEventSource.Current.Message($"Method ended {nameof(SessionKeys)}->GetKeyCountAsync() at: {DateTime.UtcNow}");
return(sessionKeyCount);
}
private async Task PeriodicInventoryCheck(CancellationToken cancellationToken)
{
IReliableDictionary <InventoryItemId, InventoryItem> inventoryItems =
await this.stateManager.GetOrAddAsync <IReliableDictionary <InventoryItemId, InventoryItem> >(InventoryItemDictionaryName);
if (this.storageType == StorageTypes.Azure)
{
await this.InitializeAsync(cancellationToken);
}
while (!cancellationToken.IsCancellationRequested)
{
ServiceEventSource.Current.ServiceMessage(this, "Checking inventory stock for {0} items.", await inventoryItems.GetCountAsync());
foreach (InventoryItem item in inventoryItems.Select(x => x.Value))
{
cancellationToken.ThrowIfCancellationRequested();
try
{
//Check if stock is below restockThreshold and if the item is not already on reorder
if ((item.AvailableStock <= item.RestockThreshold) && !item.OnReorder)
{
ServiceUriBuilder builder = new ServiceUriBuilder(RestockRequestManagerServiceName);
IRestockRequestManager restockRequestManagerClient = ServiceProxy.Create <IRestockRequestManager>(0, builder.ToUri());
// we reduce the quantity passed in to RestockRequest to ensure we don't overorder
RestockRequest newRequest = new RestockRequest(item.Id, (item.MaxStockThreshold - item.AvailableStock));
InventoryItem updatedItem = new InventoryItem(
item.Description,
item.Price,
item.AvailableStock,
item.RestockThreshold,
item.MaxStockThreshold,
item.Id,
true);
// TODO: this call needs to be idempotent in case we fail to update the InventoryItem after this completes.
await restockRequestManagerClient.AddRestockRequestAsync(newRequest);
// Write operations take an exclusive lock on an item, which means we can't do anything else with that item while the transaction is open.
// If something blocks before the transaction is committed, the open transaction on the item will prevent all operations on it, including reads.
// Once the transaction commits, the lock is released and other operations on the item can proceed.
// Operations on the transaction all have timeouts to prevent deadlocking an item,
// but we should do as little work inside the transaction as possible that is not related to the transaction itself.
using (ITransaction tx = this.stateManager.CreateTransaction())
{
await inventoryItems.TryUpdateAsync(tx, item.Id, updatedItem, item);
await tx.CommitAsync();
}
ServiceEventSource.Current.ServiceMessage(
this,
"Restock order placed. Item ID: {0}. Quantity: {1}",
newRequest.ItemId,
newRequest.Quantity);
}
}
catch (Exception e)
{
ServiceEventSource.Current.ServiceMessage(this, "Failed to place restock order for item {0}. {1}", item.Id, e.ToString());
}
if (this.storageType == StorageTypes.Local)
{
await this.StateManager.BackupAsync(this.BackupCallbackAsync);
}
else
{
await this.StateManager.BackupAsync(this.BackupCallbackAzureAsync);
}
}
await Task.Delay(TimeSpan.FromSeconds(30), cancellationToken);
}
}
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);
}
}
}
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);
}
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);
}
}
}
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 <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);
}