public async Task ConfigureApplication(string application, List <PolicyStorageEntity> policyDetails, ClusterDetails primaryCluster, ClusterDetails secondaryCluster)
{
IPolicyStorageService policyStorageClient = ServiceProxy.Create <IPolicyStorageService>(new Uri("fabric:/SFAppDRTool/PolicyStorageService"));
bool overwritePolicyDetails = false;
bool stored = policyStorageClient.PostStorageDetails(policyDetails, primaryCluster.httpEndpoint, primaryCluster.certificateThumbprint, overwritePolicyDetails).GetAwaiter().GetResult();
await MapPartitionsOfApplication(new Uri(application), primaryCluster, secondaryCluster, "partitionDictionary");
IReliableDictionary <String, List <String> > configuredApplicationsDictionary = await this.StateManager.GetOrAddAsync <IReliableDictionary <String, List <String> > >("configuredApplicationsDictionary");
using (var tx = this.StateManager.CreateTransaction())
{
String primarySecondaryJoin = Utility.getPrimarySecondaryClusterJoin(primaryCluster.address, secondaryCluster.address);
ConditionalValue <List <String> > applicationsList = await configuredApplicationsDictionary.TryGetValueAsync(tx, primarySecondaryJoin);
if (applicationsList.HasValue)
{
List <String> configuredApplicationsList = applicationsList.Value;
configuredApplicationsList.Add(application);
var result = await configuredApplicationsDictionary.TryAddAsync(tx, primarySecondaryJoin, configuredApplicationsList);
}
else
{
List <String> configuredApplicationsList = new List <String>();
configuredApplicationsList.Add(application);
var result = await configuredApplicationsDictionary.TryAddAsync(tx, primarySecondaryJoin, configuredApplicationsList);
}
await tx.CommitAsync();
}
}
public async Task <T> NewMessage <T>(IdempotentMessage <T> message)
{
DateTimeOffset now = DateTimeOffset.Now;
if ((now - lastClear).TotalSeconds > 1.5 * maxDelaySeconds)
{
await Clear();
}
if ((now - message.Time).TotalSeconds > maxDelaySeconds)
{
return(default(T));
}
using (ITransaction tx = this.sm.CreateTransaction())
{
var result = await dictionary.TryGetValueAsync(tx, message.Id);
if (result.HasValue)
{
tx.Abort();
return(default(T));
}
else
{
await dictionary.TryAddAsync(tx, message.Id, message.Time);
await tx.CommitAsync();
return(message.Value);
}
}
}
public async Task <bool> TryAddAsync(ITransaction tx, TKey key, TValue value)
{
if (reliableDictionary == null)
{
await InitializeReliableDictionary();
}
return(await reliableDictionary.TryAddAsync(tx, key, value));
}
// Maps named partitions based on their name
public async Task MapNamedPartitions(Uri applicationName, Uri serviceName, ClusterDetails primaryCluster, ServicePartitionList primaryPartitions, ClusterDetails secondaryCluster, ServicePartitionList secondaryPartitions, string reliableDictionary)
{
IReliableDictionary <Guid, PartitionWrapper> myDictionary = await this.StateManager.GetOrAddAsync <IReliableDictionary <Guid, PartitionWrapper> >(reliableDictionary);
foreach (var primaryPartition in primaryPartitions)
{
var partitionNamePrimary = (primaryPartition.PartitionInformation as NamedPartitionInformation).Name;
foreach (var secondaryPartition in secondaryPartitions)
{
string partitionNameSecondary = (secondaryPartition.PartitionInformation as NamedPartitionInformation).Name;
if (partitionNamePrimary == partitionNameSecondary)
{
using (var tx = this.StateManager.CreateTransaction())
{
var result = await myDictionary.TryAddAsync(tx, primaryPartition.PartitionInformation.Id, new PartitionWrapper(secondaryPartition, primaryPartition.PartitionInformation.Id, applicationName, serviceName, primaryCluster, secondaryCluster));
ServiceEventSource.Current.ServiceMessage(this.Context, result ? "Successfully Mapped Partition-{0} to Partition-{1}" : "Already Exists", primaryPartition.PartitionInformation.Id, secondaryPartition.PartitionInformation.Id);
// If an exception is thrown before calling CommitAsync, the transaction aborts, all changes are
// discarded, and nothing is saved to the secondary replicas.
await tx.CommitAsync();
}
}
}
}
}
/// <summary>
/// Register
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <UserRegisterRequestModel> Register(UserRegisterRequestModel request)
{
IReliableDictionary <string, UserState> myDictionary = await this.StateManager.GetOrAddAsync <IReliableDictionary <string, UserState> >("Users");
using (ITransaction tx = this.StateManager.CreateTransaction())
{
ConditionalValue <UserState> result = await myDictionary.TryGetValueAsync(tx, request.CellPhone);
if (!result.HasValue)
{
UserState state = new UserState
{
CellPhone = request.CellPhone,
PassWord = request.PassWord,
RealName = request.RealName,
UserIdentifier = Guid.NewGuid()
};
bool isSuc = await myDictionary.TryAddAsync(tx, state.CellPhone, state);
await tx.CommitAsync();
if (!isSuc)
{
return(null);
}
request.UserIdentifier = state.UserIdentifier;
return(request);
}
request.UserIdentifier = result.Value.UserIdentifier;
return(request);
}
}
/// <summary>
/// Saves a HealthCheckScheduleItem to the dictionary.
/// </summary>
/// <param name="tx">ITransaction instance.</param>
/// <param name="item">HealthCheckScheuleItem instance.</param>
/// <returns>True if successful, otherwise false.</returns>
/// <remarks>Separate method to address possible key collisions.</remarks>
internal async Task <bool> SaveAsync(ITransaction tx, WatchdogScheduledItem item)
{
int retryCount = 5;
// Get the schedule dictionary.
IReliableDictionary <long, WatchdogScheduledItem> schedDict = await this.GetHealthCheckScheduleDictionaryAsync().ConfigureAwait(false);
// Get a copy of the desired execution time.
long key = item.ExecutionTicks;
while (retryCount-- >= 0)
{
// Attempt to add the item. There may be a collision because the key already exists.
// If it doesn't succeed try again with a new key.
if (await schedDict.TryAddAsync(tx, key, item, this._timeout, this._token).ConfigureAwait(false))
{
return(true);
}
// Increment the key value.
key++;
}
// Exhausted the number of allowed retries.
return(false);
}
// Maps Int64 partitions based on their low key
public async Task MapInt64Partitions(Uri applicationName, Uri serviceName, ClusterDetails primaryCluster, ServicePartitionList primaryPartitions, ClusterDetails secondaryCluster, ServicePartitionList secondaryPartitions, string reliableDictionary)
{
IReliableDictionary <Guid, PartitionWrapper> myDictionary = await this.StateManager.GetOrAddAsync <IReliableDictionary <Guid, PartitionWrapper> >(reliableDictionary);
foreach (var primaryPartition in primaryPartitions)
{
long hashCode = HashUtil.getLongHashCode(primaryPartition.PartitionInformation.Id.ToString());
if (await BelongsToPartition(hashCode))
{
var int64PartitionInfo = primaryPartition.PartitionInformation as Int64RangePartitionInformation;
long?lowKeyPrimary = int64PartitionInfo?.LowKey;
foreach (var secondaryPartition in secondaryPartitions)
{
long?lowKeySecondary = (secondaryPartition.PartitionInformation as Int64RangePartitionInformation)?.LowKey;
if (lowKeyPrimary == lowKeySecondary)
{
using (var tx = this.StateManager.CreateTransaction())
{
var result = await myDictionary.TryAddAsync(tx, primaryPartition.PartitionInformation.Id, new PartitionWrapper(secondaryPartition, primaryPartition.PartitionInformation.Id, applicationName, serviceName, primaryCluster, secondaryCluster));
ServiceEventSource.Current.ServiceMessage(this.Context, result ? "Successfully Mapped Partition-{0} to Partition-{1}" : "Already Exists", primaryPartition.PartitionInformation.Id, secondaryPartition.PartitionInformation.Id);
await tx.CommitAsync();
}
}
}
}
}
}
/// <summary>
/// This is called by Restore Service to and it stores the storage details along with the policy details in the reliable dictionary
/// </summary>
/// <param name="policies"></param>
/// <param name="primaryClusterConnectionString"></param>
/// <returns></returns>
public async Task <bool> PostStorageDetails(List <PolicyStorageEntity> policies, string primaryClusterConnectionString)
{
IReliableDictionary <string, BackupStorage> myDictionary = await this.StateManager.GetOrAddAsync <IReliableDictionary <string, BackupStorage> >("storageDictionary");
foreach (var entity in policies)
{
BackupStorage backupStorage = await GetStorageInfo(entity.policy, primaryClusterConnectionString);
if (backupStorage != null && entity.backupStorage != null)
{
backupStorage.connectionString = entity.backupStorage.connectionString;
backupStorage.primaryUsername = entity.backupStorage.primaryUsername;
backupStorage.primaryPassword = entity.backupStorage.primaryPassword;
backupStorage.secondaryUsername = entity.backupStorage.secondaryUsername;
backupStorage.secondaryPassword = entity.backupStorage.secondaryPassword;
backupStorage.friendlyname = entity.backupStorage.friendlyname;
}
else
{
return(false);
}
using (var tx = this.StateManager.CreateTransaction())
{
var result = await myDictionary.TryAddAsync(tx, entity.policy, backupStorage);
ServiceEventSource.Current.ServiceMessage(this.Context, result ? "Successfully added policy {0} storgae details" : "Already Exists", entity.policy);
// If an exception is thrown before calling CommitAsync, the transaction aborts, all changes are
// discarded, and nothing is saved to the secondary replicas.
await tx.CommitAsync();
}
}
return(true);
}
public async Task <T> Add(T entity)
{
var storableEntity = _mapper.MapToStorable(entity);
var succeed = await _aggreateStorage.TryAddAsync(_transaction, entity.Id, storableEntity);
if (!succeed)
{
throw new Exception("Something went wrong when trying to add the turn");
}
return(entity);
}
/// <summary>
/// This is called by Restore Service to and it stores the storage details along with the policy details in the reliable dictionary
/// </summary>
/// <param name="policies"></param>
/// <param name="primaryClusterConnectionString"></param>
/// <returns></returns>
public async Task <bool> PostStorageDetails(List <PolicyStorageEntity> policies, string primaryClusterConnectionString, string clusterThumbprint, bool overwritePolicyDetails)
{
IReliableDictionary <string, BackupStorage> myDictionary = await this.StateManager.GetOrAddAsync <IReliableDictionary <string, BackupStorage> >("storageDictionary");
foreach (var entity in policies)
{
BackupStorage backupStorage;
try
{
backupStorage = await GetStorageInfo(entity.policy, primaryClusterConnectionString, clusterThumbprint);
}
catch (Exception ex) {
ServiceEventSource.Current.Message("Policy Storage Service: Exception getting storage info {0}", ex);
throw;
}
if (backupStorage != null && entity.backupStorage != null)
{
backupStorage.connectionString = entity.backupStorage.connectionString;
backupStorage.primaryUsername = entity.backupStorage.primaryUsername;
backupStorage.primaryPassword = entity.backupStorage.primaryPassword;
backupStorage.secondaryUsername = entity.backupStorage.secondaryUsername;
backupStorage.secondaryPassword = entity.backupStorage.secondaryPassword;
backupStorage.friendlyname = entity.backupStorage.friendlyname;
backupStorage.Encrypt();
}
else
{
return(false);
}
using (var tx = this.StateManager.CreateTransaction())
{
ConditionalValue <BackupStorage> cndbackupStorage = await myDictionary.TryGetValueAsync(tx, entity.policy);
if (!cndbackupStorage.HasValue || cndbackupStorage.HasValue && overwritePolicyDetails)
{
var result = await myDictionary.TryAddAsync(tx, entity.policy, backupStorage);
ServiceEventSource.Current.ServiceMessage(this.Context, result ? "Successfully added policy {0} storage details" : "Could not add policy", entity.policy);
}
else
{
ServiceEventSource.Current.ServiceMessage(this.Context, "Policy {0} already exists", entity.policy);
}
// If an exception is thrown before calling CommitAsync, the transaction aborts, all changes are
// discarded, and nothing is saved to the secondary replicas.
await tx.CommitAsync();
}
}
return(true);
}
// Maps singleton partitions
public async Task MapSingletonPartition(Uri applicationName, Uri serviceName, ClusterDetails primaryCluster, ServicePartitionList primaryPartitions, ClusterDetails secondaryCluster, ServicePartitionList secondaryPartitions, string partitionDictionaryName)
{
IReliableDictionary <String, PartitionWrapper> partitionDictionary = await this.StateManager.GetOrAddAsync <IReliableDictionary <String, PartitionWrapper> >(partitionDictionaryName);
using (var tx = this.StateManager.CreateTransaction())
{
var result = await partitionDictionary.TryAddAsync(tx, Utility.getPartitionAccessKey(primaryPartitions[0].PartitionInformation.Id, primaryCluster.address, secondaryCluster.address), new PartitionWrapper(secondaryPartitions[0], primaryPartitions[0].PartitionInformation.Id, applicationName, serviceName, primaryCluster, secondaryCluster));
ServiceEventSource.Current.ServiceMessage(this.Context, result ? "Successfully Mapped Partition-{0} to Partition-{1}" : "Already Exists", primaryPartitions[0].PartitionInformation.Id, secondaryPartitions[0].PartitionInformation.Id);
// If an exception is thrown before calling CommitAsync, the transaction aborts, all changes are
// discarded, and nothing is saved to the secondary replicas.
await tx.CommitAsync();
}
}
public async Task PostStorageDetails(string backupPolicy, BackupStorage backupStorage)
{
IReliableDictionary <string, BackupStorage> myDictionary = await this.StateManager.GetOrAddAsync <IReliableDictionary <string, BackupStorage> >("storageDictionary");
using (var tx = this.StateManager.CreateTransaction())
{
var result = await myDictionary.TryAddAsync(tx, backupPolicy, backupStorage);
ServiceEventSource.Current.ServiceMessage(this.Context, result ? "Successfully added policy {0} storgae details" : "Already Exists", backupPolicy);
// If an exception is thrown before calling CommitAsync, the transaction aborts, all changes are
// discarded, and nothing is saved to the secondary replicas.
await tx.CommitAsync();
}
}
/// <summary>
/// Registers the configuration.
/// </summary>
/// <param name="request">The request.</param>
/// <returns></returns>
public async Task <bool> RegisterConfiguration(ConsumerConfigureRequestModel request)
{
IReliableDictionary <string, ConsumerConfiguresState> dictionary = await this.StateManager.GetOrAddAsync <IReliableDictionary <string, ConsumerConfiguresState> >(DictionaryKey);
using (ITransaction tx = this.StateManager.CreateTransaction())
{
ConditionalValue <ConsumerConfiguresState> result = await dictionary.TryGetValueAsync(tx, ConfigureKey);
bool isSuc;
if (result.HasValue)
{
int count = result.Value.Configures.Count(x => x.Action.Equals(request.Action) && x.ServiceName.Equals(request.ServiceName) && x.DictionaryKey.Equals(request.DictionaryKey));
if (count > 0)
{
return(false);
}
ConsumerConfiguresState configure = result.Value;
configure.Configures.Add(new ConsumerConfigureInfo
{
Action = request.Action,
Address = request.Address,
ServiceName = request.ServiceName,
DictionaryKey = request.DictionaryKey
});
isSuc = await dictionary.TryUpdateAsync(tx, ConfigureKey, configure, result.Value);
return(isSuc);
}
ConsumerConfiguresState state = new ConsumerConfiguresState
{
Configures = new List <ConsumerConfigureInfo>
{
new ConsumerConfigureInfo
{
Action = request.Action,
Address = request.Address,
ServiceName = request.ServiceName,
DictionaryKey = request.DictionaryKey
}
}
};
isSuc = await dictionary.TryAddAsync(tx, ConfigureKey, state);
await tx.CommitAsync();
return(isSuc);
}
}
private async Task <string> AddUserAsync(string user)
{
IReliableDictionary <String, String> dictionary = await this.StateManager.GetOrAddAsync <IReliableDictionary <String, String> >("dictionary");
using (ITransaction tx = this.StateManager.CreateTransaction())
{
bool addResult = await dictionary.TryAddAsync(tx, user.ToUpperInvariant(), user);
await tx.CommitAsync();
return(String.Format(
"User {0} {1}",
user,
addResult ? "sucessfully added" : "already exists"));
}
}
private async Task <string> AddItemToCacheAsync(string collection, string key, string data)
{
IReliableDictionary <String, String> dictionary = await this.StateManager.GetOrAddAsync <IReliableDictionary <String, String> >(collection);
using (ITransaction tx = this.StateManager.CreateTransaction())
{
bool addResult = await dictionary.TryAddAsync(tx, key.ToUpperInvariant(), data);
await tx.CommitAsync();
return(String.Format(
"Type '{0}', Item '{1}' {2}",
collection,
key,
addResult ? "sucessfully added" : "already exists"));
}
}
private async Task <RCAddResult> AddInstallerPackageAsync(InstallerPkg pkg)
{
IReliableDictionary <string, InstallerPkg> packagesDictionary = await this._statemanager.GetOrAddAsync <IReliableDictionary <string, InstallerPkg> >("packages");
using (ITransaction tx = _statemanager.CreateTransaction())
{
var result = await packagesDictionary.TryGetValueAsync(tx, pkg.Name);
if (result.HasValue)
{
return(RCAddResult.KeyAlreadyExists);
}
if (!await packagesDictionary.TryAddAsync(tx, pkg.Name, pkg))
{
return(RCAddResult.Failure);
}
await tx.CommitAsync();
}
return(RCAddResult.Success);
}
/// <summary>
/// Performs a HealthCheck for a scheduled item.
/// </summary>
/// <param name="item">WatchdogScheduledItem instance.</param>
internal async Task PerformItemHealthCheckAsync(WatchdogScheduledItem item)
{
// Get the health check dictionaries.
IReliableDictionary <string, HealthCheck> dict = await this.GetHealthCheckDictionaryAsync();
IReliableDictionary <long, WatchdogScheduledItem> scheduleDict = await this.GetHealthCheckScheduleDictionaryAsync();
// Create a transaction.
using (ITransaction tx = this._service.StateManager.CreateTransaction())
{
// Attempt to get the HealthCheck instance for the key. If not return.
ConditionalValue <HealthCheck> cv = await dict.TryGetValueAsync(tx, item.Key, LockMode.Update);
if (cv.HasValue)
{
HealthCheck hc = cv.Value;
try
{
// Find the partition information that matches the partition identifier.
// If the partition isn't found, remove the health check item.
Partition partition = await this.FindMatchingPartitionAsync(hc.Partition);
if (null == partition)
{
await dict.TryRemoveAsync(tx, hc.Key, this._timeout, this._token);
}
else
{
// Execute the check and evaluate the results returned in the new HealthCheck instance.
hc = await this.ExecuteHealthCheckAsync(hc, partition);
// Update the value of the HealthCheck to store the results of the test.
await dict.TryUpdateAsync(tx, item.Key, hc, cv.Value);
// Remove the current scheduled item.
await scheduleDict.TryRemoveAsync(tx, item.ExecutionTicks);
// Add the new scheduled item.
WatchdogScheduledItem newItem = new WatchdogScheduledItem(hc.LastAttempt.Add(hc.Frequency), hc.Key);
await(scheduleDict.TryAddAsync(tx, newItem.ExecutionTicks, newItem));
}
// Commit the transaction.
await tx.CommitAsync();
}
catch (TimeoutException ex)
{
ServiceEventSource.Current.ServiceMessage(this._service.Context, ex.Message);
}
catch (FabricNotPrimaryException ex)
{
ServiceEventSource.Current.ServiceMessage(this._service.Context, ex.Message);
return;
}
catch (Exception ex)
{
ServiceEventSource.Current.ServiceMessage(this._service.Context, ex.Message);
throw;
}
}
}
}
// An interface method which is for disconfiguring the appliations thereby deleting their entries in reliable dictionary.
public async Task <string> DisconfigureApplication(string applicationName, 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.applicationName.ToString().Equals(applicationName))
{
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();
}
IReliableDictionary <String, List <String> > configuredApplicationsDictionary = await this.StateManager.GetOrAddAsync <IReliableDictionary <String, List <String> > >("configuredApplicationsDictionary");
using (var tx = this.StateManager.CreateTransaction())
{
String primarySecondaryJoin = Utility.getPrimarySecondaryClusterJoin(primaryCluster, secondaryCluster);
ConditionalValue <List <String> > applicationsList = await configuredApplicationsDictionary.TryGetValueAsync(tx, primarySecondaryJoin);
if (applicationsList.HasValue)
{
List <String> configuredApplicationsList = applicationsList.Value;
configuredApplicationsList.Remove(applicationName);
var result = await configuredApplicationsDictionary.TryAddAsync(tx, primarySecondaryJoin, configuredApplicationsList);
}
await tx.CommitAsync();
}
if (allPartitionsRemoved)
{
return(applicationName);
}
return(null);
}
private async Task <bool> MatchmakeOneGame(CancellationToken cancellationToken, IReliableConcurrentQueue <UserRequest> queue, IReliableDictionary <ActorInfo, PlayersInMatch> usedActors, IReliableDictionary <UserRequest, ActorInfo> matchmakedUsers)
{
try
{
ConditionalValue <UserRequest> ret;
PlayersInMatch players = new PlayersInMatch();
ActorInfo actorId;
using (var tx = this.StateManager.CreateTransaction())
{
do
{
ret = await queue.TryDequeueAsync(tx, cancellationToken);
if (ret.HasValue)
{
players = players.AddPlayer(new UserRequest(ret.Value));
}
}while (!cancellationToken.IsCancellationRequested && ret.HasValue && players.Count < MatchSize);
if (cancellationToken.IsCancellationRequested || players.Count != MatchSize)
{
ServiceEventSource.Current.ServiceMessage(this.Context, cancellationToken.IsCancellationRequested ? $"Cancellation requested!" : $"Not enough players in the queue to matchmake!");
tx.Abort();
return(false);
}
// found enough players - assign them actor
//bool usedActor = false;
//do
//{
// actorId = ActorId.CreateRandom();
// usedActor = await usedActors.ContainsKeyAsync(tx, actorId);
//}
//while (!cancellationToken.IsCancellationRequested && usedActor);
actorId = await GetSimulationActorId(tx, cancellationToken);
if (cancellationToken.IsCancellationRequested)
{
ServiceEventSource.Current.ServiceMessage(this.Context, $"Cancellation requested!");
tx.Abort();
return(false);
}
bool added = await usedActors.TryAddAsync(tx, actorId, players);
if (!added)
{
ServiceEventSource.Current.ServiceMessage(this.Context, $"Tried to add already used actor {actorId}");
tx.Abort();
return(false);
}
var playersToAdd = players.GetList();
List <UserRequest> addedPlayers = new List <UserRequest>();
foreach (var player in playersToAdd)
{
added = await matchmakedUsers.TryAddAsync(tx, player, actorId);
if (added)
{
addedPlayers.Add(player);
}
}
if (addedPlayers.Count != playersToAdd.Count)
{
foreach (var player in addedPlayers)
{
await matchmakedUsers.TryRemoveAsync(tx, player);
await queue.EnqueueAsync(tx, player);
}
ServiceEventSource.Current.ServiceMessage(this.Context, $"Some duplicated requests encountered");
}
await tx.CommitAsync();
}
List <UserRequest> playersList = players.GetList();
// Create actor simulation
int index = actorId.ActorIndex;
string suffix = GetSimulationActorNameSuffix(index);
string actorServiceUri = $"{this.context.CodePackageActivationContext.ApplicationName}/SimulationActorService{suffix}";
ISimulationActor simulationActor = ActorProxy.Create <ISimulationActor>(actorId.ActorId, new Uri(actorServiceUri));
bool simulated = await simulationActor.SimulateMatch(playersList, actorId);
if (!simulated)
{
ServiceEventSource.Current.Message($"Something went wrong with simulation");
return(false);
}
await simulationActor.SubscribeAsync <ISimulationEvents>(this, ResubsriptionInterval);
// Notify clients
IWebService webService = ServiceProxy.Create <IWebService>(new Uri($"{this.context.CodePackageActivationContext.ApplicationName}/WebService"));
await webService.StartGame(actorId, playersList);
StringBuilder builder = new StringBuilder();
builder.Append($"Created new match\n ActorID: {actorId}\n");
for (int i = 0; i < players.Count; i++)
{
builder.Append($"UserID_{i}: {playersList[i]}\n");
}
ServiceEventSource.Current.ServiceMessage(this.Context, builder.ToString());
return(true);
}
catch (Exception ex)
{
ServiceEventSource.Current.Message(string.Format("Exception {0}", ex));
return(false);
}
}
public Task <bool> TryAdd(Core.ITransaction tx, TKey key, TValue value)
{
return(wrappedReliableDictionary.TryAddAsync(((ServiceFabTransaction)tx).WrappedTransaction, key, value));
}
public Task <bool> TryAddAsync(ITransaction tx, TKey key, TimeSpan timeout = default(TimeSpan), CancellationToken cancellationToken = default(CancellationToken)) => m_dictionary.TryAddAsync(tx, key, null, timeout.DefaultToInfinite(), cancellationToken);