// 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 UpdateBackupStatusAsTimeout(StatefulService statefulService, string fabricUri, TimeSpan timeout, CancellationToken cancellationToken,
string processQueueTypeTrace)
{
BackupRestoreTrace.TraceSource.WriteInfo(processQueueTypeTrace, "Updating the Backup status as timeout for request Service Uri : {0} , PartitionId {1}", this.ServiceUri, this.PartitionId);
BackupPartitionStore backupPartitionStore = await BackupPartitionStore.CreateOrGetBackupPartitionStore(statefulService);
using (ITransaction transaction = statefulService.StateManager.CreateTransaction())
{
var currentBackupPartitionStatus = await backupPartitionStore.GetValueWithUpdateLockModeAsync(fabricUri, timeout, cancellationToken, transaction);
BackupRestoreTrace.TraceSource.WriteInfo(processQueueTypeTrace, "BackupPartitionStatus {0} as timeout for request Service Uri : {1} , PartitionId {2}", currentBackupPartitionStatus, this.ServiceUri, this.PartitionId);
if ((currentBackupPartitionStatus?.BackupPartitionStatusState == BackupState.Accepted ||
currentBackupPartitionStatus?.BackupPartitionStatusState == BackupState.BackupInProgress) &&
this.BackupRequestGuid.Equals(currentBackupPartitionStatus.OperationId))
{
var backupPartitionStatus = currentBackupPartitionStatus.ToBuilder()
.WithState(BackupState.Timeout)
.WithErrorCode(unchecked ((int)NativeTypes.FABRIC_ERROR_CODE.FABRIC_E_TIMEOUT))
.WithMessage(StringResources.BackupTimeout)
.Build();
await backupPartitionStore.UpdateValueAsync(fabricUri, backupPartitionStatus, timeout, cancellationToken, transaction);
await transaction.CommitAsync();
BackupRestoreTrace.TraceSource.WriteInfo(processQueueTypeTrace, "Updated the Backup status as timeout failed for request Service Uri : {0} , PartitionId {1}", this.ServiceUri, this.PartitionId);
}
else
{
transaction.Abort();
BackupRestoreTrace.TraceSource.WriteInfo(processQueueTypeTrace, "Updating the Backup status as timeout failed for request Service Uri : {0} , PartitionId {1}", this.ServiceUri, this.PartitionId);
}
}
}
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 BackupOperationResultAsync(BackupOperationResult operationResult, TimeSpan timeout,
CancellationToken cancellationToken)
{
BackupRestoreTrace.TraceSource.WriteInfo(TraceType,
"BackupOperationResultAsync invoked for partition {0}, OperationId {1} ErrorCode {2}, message {3}",
operationResult.PartitionId, operationResult.OperationId, operationResult.ErrorCode, operationResult.Message);
var backupPartitionStore =
await BackupPartitionStore.CreateOrGetBackupPartitionStore(this.statefulService);
var fabricUri = UtilityHelper.GetBackupMappingKey(await UtilityHelper.GetCustomServiceUri(operationResult.ServiceName, timeout, cancellationToken),
operationResult.PartitionId.ToString());
await UtilityHelper.InvokeWithRetry(async() =>
{
BackupRestoreTrace.TraceSource.WriteInfo(TraceType,
"Trying to update the Backup Request for Partition Id {0} ", operationResult.PartitionId);
using (ITransaction transaction = this.statefulService.StateManager.CreateTransaction())
{
var backupPartitionStatus = await backupPartitionStore.GetValueWithUpdateLockModeAsync(fabricUri, timeout, cancellationToken, transaction);
if ((backupPartitionStatus != null) &&
(backupPartitionStatus.BackupPartitionStatusState == BackupState.BackupInProgress ||
backupPartitionStatus.BackupPartitionStatusState == BackupState.Accepted) &&
backupPartitionStatus.OperationId.Equals(operationResult.OperationId)) // TODO : Also check for Guid for the request
{
var backupPartitionStatusBuilder = backupPartitionStatus.ToBuilder()
.WithState(operationResult.ErrorCode != 0 ? BackupState.Failure : BackupState.Success)
.WithErrorCode(operationResult.ErrorCode)
.WithMessage(operationResult.Message)
.WithTimeStampUtc(operationResult.TimeStampUtc);
if (operationResult.ErrorCode == 0)
{
var updatedEpoch = new BackupEpoch
{
ConfigurationNumber = operationResult.EpochOfLastBackupRecord.ConfigurationNumber,
DataLossNumber = operationResult.EpochOfLastBackupRecord.DataLossNumber
};
backupPartitionStatusBuilder
.WithEpochOfLastBackupRecord(updatedEpoch)
.WithLsnOfLastBackupRecord(operationResult.LsnOfLastBackupRecord)
.WithBackupId(operationResult.BackupId)
.WithBackupLocation(operationResult.BackupLocation);
}
await backupPartitionStore.UpdateValueAsync(fabricUri, backupPartitionStatusBuilder.Build(), transaction);
await transaction.CommitAsync();
BackupRestoreTrace.TraceSource.WriteInfo(TraceType,
"Updated the Backup Request for Partition Id {0} ", operationResult.PartitionId);
}
else
{
transaction.Abort();
}
}
});
}
public void AbortTransaction()
{
if (transaction != null)
{
transaction.Abort();
transaction = null;
transactionLevel = 0;
objectStore.AbortTransaction();
}
}
public async Task <IActionResult> GetAsync()
{
List <object> devices = new List <object>();
IReliableDictionary <string, DeviceEventSeries> storeLatestMessage = await this.stateManager.GetOrAddAsync <IReliableDictionary <string, DeviceEventSeries> >(TargetSolution.Names.EventLatestDictionaryName);
using (ITransaction tx = this.stateManager.CreateTransaction())
{
try
{
IAsyncEnumerable <KeyValuePair <string, DeviceEventSeries> > enumerable = await storeLatestMessage.CreateEnumerableAsync(tx, EnumerationMode.Ordered);
IAsyncEnumerator <KeyValuePair <string, DeviceEventSeries> > enumerator = enumerable.GetAsyncEnumerator();
while (await enumerator.MoveNextAsync(appLifetime.ApplicationStopping))
{
devices.Add(
new
{
DeviceId = enumerator.Current.Key,
enumerator.Current.Value.Events
});
}
await tx.CommitAsync();
}
catch (TimeoutException te)
{
// transient error. Could Retry if one desires .
ServiceEventSource.Current.ServiceMessage(this.context, $"DataService - GetAsync - TimeoutException : Message=[{te.ToString()}]");
tx.Abort();
}
catch (Exception ex)
{
ServiceEventSource.Current.ServiceMessage(this.context, $"DataService - GetAsync - General Exception - Message=[{0}]", ex);
tx.Abort();
}
}
return(this.Ok(devices));
}
public async Task RestoreOperationResultAsync(RestoreOperationResult operationResult, TimeSpan timeout,
CancellationToken cancellationToken)
{
BackupRestoreTrace.TraceSource.WriteInfo(TraceType, "RestoreOperationResultAsync invoked for partition {0}, ErrorCode {1}, message {2}",
operationResult.PartitionId, operationResult.ErrorCode, operationResult.Message);
var restoreStore = await RestoreStore.CreateOrGetRestoreStatusStore(this.statefulService);
var workItemQueue = await WorkItemQueue.CreateOrGetWorkItemQueue(this.statefulService);
string brsServiceUri = await UtilityHelper.GetCustomServiceUri(operationResult.ServiceName, timeout, cancellationToken);
var fabricUri = UtilityHelper.GetBackupMappingKey(brsServiceUri, operationResult.PartitionId.ToString());
WorkItem pushPolicyAfterRestore = new SendToServiceNodeWorkItem(brsServiceUri, operationResult.PartitionId.ToString(), new WorkItemInfo()
{
WorkItemType = WorkItemPropogationType.UpdatePolicyAfterRestore,
});
await UtilityHelper.InvokeWithRetry(async() =>
{
BackupRestoreTrace.TraceSource.WriteInfo(TraceType, "Trying to Update the Restore request for partition {0}", operationResult.PartitionId);
using (ITransaction transaction = this.statefulService.StateManager.CreateTransaction())
{
var restoreStatus = await restoreStore.GetValueWithUpdateLockModeAsync(fabricUri, timeout, cancellationToken, transaction);
if ((restoreStatus != null) &&
(restoreStatus.RestoreStatusState == RestoreState.RestoreInProgress ||
restoreStatus.RestoreStatusState == RestoreState.Accepted) &&
(restoreStatus.RestoreRequestGuid.Equals(operationResult.OperationId)))
//TODO: Add check for each request by Guid
{
var updatedRestoreStatus = restoreStatus.ToBuilder()
.WithState(operationResult.ErrorCode != 0 ? RestoreState.Failure : RestoreState.Success)
.WithErrorCode(operationResult.ErrorCode)
.WithMessage(operationResult.Message)
.WithTimeStampUtc(operationResult.TimeStampUtc)
.Build();
await restoreStore.UpdateValueAsync(fabricUri, updatedRestoreStatus, timeout, cancellationToken, transaction);
await workItemQueue.AddWorkItem(pushPolicyAfterRestore, timeout, cancellationToken, transaction);
await transaction.CommitAsync();
BackupRestoreTrace.TraceSource.WriteInfo(TraceType, "Updated the Restore request for partition {0}", operationResult.PartitionId);
}
else
{
transaction.Abort();
}
}
});
}
public ServiceData CollectNext(int jobId, int timeout, int totalTask)
{
//Console.WriteLine("From GridService.CollectNext called for jobId=" + jobId);
ServiceData serviceData = new ServiceData();
Result reponseTemplate = new Result();
reponseTemplate.JobID = jobId;
int previousResultCount = 0;
int newResultCount = 0;
Result[] finalResult = new Result[totalTask];
while (newResultCount < totalTask)
{
using (ITransaction txn = Master.TxnManager.Create(30000))
{
try
{
Result[] resultA = Master.SpaceProxy.TakeMultiple(reponseTemplate);
if (resultA.Length > 0)
{
newResultCount += resultA.Length;
for (int i = previousResultCount; i < newResultCount; i++)
{
finalResult[i] = resultA[i - previousResultCount];
}
Console.WriteLine("From GridService.CollectNext for jobId=" + jobId + " numberOfResultsFound =" + serviceData.Data.Length + ", newResultCount=" + newResultCount);
previousResultCount = newResultCount;
}
txn.Commit();
Thread.Sleep(timeout);
}
catch (Exception e)
{
e.ToString();
// rollback the transaction
txn.Abort();
}
}
}
Master.SpaceProxy.Take(job);
jobResult.JobStatus = "Completed";
Master.SpaceProxy.Write(jobResult);
Console.WriteLine(DateTime.Now +
" - Done executing Job and job object removed from space " + job.JobID);
return(serviceData);
}
private async Task <bool> TryDispatchTaskAsync(DispatcherTask <T> dispatcherTask, ITransaction transaction, T item)
{
var success = true;
try
{
await dispatcherTask(transaction, item, _tokenSource.Token).ConfigureAwait(false);
await transaction.CommitAsync().ConfigureAwait(false);
}
catch
{
transaction.Abort();
success = false;
}
return(success);
}
/// <summary>
/// Send an abort which will not throw on failure.
/// </summary>
///
/// <param name="transaction">The transaction to abort.</param>
///
/// <exception cref="AmazonServiceException">If there is an error communicating with QLDB.</exception>
private void NoThrowAbort(ITransaction transaction)
{
try
{
if (transaction != null)
{
transaction.Abort();
}
else
{
this.session.AbortTransaction();
}
}
catch (AmazonServiceException ase)
{
this.logger.LogWarning("Ignored error aborting transaction during execution: {}", ase);
}
}
private async Task UpdateRestoreStatusAsTimeout(StatefulService statefulService, string fabricUri, TimeSpan timeout, CancellationToken cancellationToken,
string processQueueTypeTrace)
{
BackupRestoreTrace.TraceSource.WriteInfo(processQueueTypeTrace, "Updating the Restore status as timeout for request Service Uri : {0} , PartitionId {1}", this.ServiceUri, this.PartitionId);
RestoreStore restoreStore = await RestoreStore.CreateOrGetRestoreStatusStore(statefulService);
WorkItemQueue workItemQueue = await WorkItemQueue.CreateOrGetWorkItemQueue(statefulService);
WorkItem workItem = new SendToServiceNodeWorkItem(this.ServiceUri, this.PartitionId, new WorkItemInfo()
{
WorkItemType = WorkItemPropogationType.UpdatePolicyAfterRestore
});
using (ITransaction transaction = statefulService.StateManager.CreateTransaction())
{
var currentRestoreStatus = await restoreStore.GetValueWithUpdateLockModeAsync(fabricUri, timeout, cancellationToken, transaction);
BackupRestoreTrace.TraceSource.WriteInfo(processQueueTypeTrace, "RestoreStatus {0} as timeout for request Service Uri : {1} , PartitionId {2}", currentRestoreStatus, this.ServiceUri, this.PartitionId);
if (currentRestoreStatus != null &&
currentRestoreStatus.RestoreRequestGuid.Equals(this.RestoreRequestGuid) &&
(currentRestoreStatus.RestoreStatusState == RestoreState.Accepted ||
currentRestoreStatus.RestoreStatusState == RestoreState.RestoreInProgress))
{
var restoreStatus = currentRestoreStatus.ToBuilder()
.WithState(RestoreState.Timeout)
.WithErrorCode(unchecked ((int)NativeTypes.FABRIC_ERROR_CODE.FABRIC_E_TIMEOUT))
.WithMessage(StringResources.RestoreTimeout)
.Build();
await restoreStore.UpdateValueAsync(fabricUri, restoreStatus, timeout, cancellationToken, transaction);
await workItemQueue.AddWorkItem(workItem, timeout, cancellationToken, transaction);
await transaction.CommitAsync();
BackupRestoreTrace.TraceSource.WriteInfo(processQueueTypeTrace, "Updated Restore Status as Timeout for request Service Uri : {0} , PartitionId {1}", this.ServiceUri, this.PartitionId);
}
else
{
transaction.Abort();
BackupRestoreTrace.TraceSource.WriteInfo(processQueueTypeTrace, "Updated Restore Status as Timeout Failed for request Service Uri : {0} , PartitionId {1}", this.ServiceUri, this.PartitionId);
}
}
}
public void readWithTransaction()
{
ITransactionManager mgr = GigaSpacesFactory.CreateDistributedTransactionManager();
// Create a transaction using the transaction manager:
using (ITransaction txn = mgr.Create()) {
try {
// ...
SqlQuery <User> query = new SqlQuery <User> ("Contacts.HOME = '770-123-5555'");
User user = proxy.Read <User> (query, txn, long.MaxValue, ReadModifiers.ExclusiveReadLock);
// ....
txn.Commit();
} catch (Exception ex) {
System.Console.WriteLine(ex.ToString());
// rollback the transaction
txn.Abort();
}
}
}
internal virtual async Task DeleteValueAsync(TKey key, TimeSpan timeout, CancellationToken cancellationToken, ITransaction transaction = null)
{
BackupRestoreTrace.TraceSource.WriteInfo(TraceType, "DeleteValueAsync Key: {0}", key);
try
{
if (transaction == null)
{
using (transaction = this.StatefulService.StateManager.CreateTransaction())
{
ConditionalValue <TValue> conditionalValue =
await this.StoreReliableDictionary.TryRemoveAsync(transaction, key, timeout, cancellationToken);
if (conditionalValue.HasValue)
{
await transaction.CommitAsync();
}
else
{
transaction.Abort();
throw new FabricBackupKeyNotExisingException();
}
}
}
else
{
ConditionalValue <TValue> conditionalValue =
await this.StoreReliableDictionary.TryRemoveAsync(transaction, key, timeout, cancellationToken);
if (!conditionalValue.HasValue)
{
throw new FabricBackupKeyNotExisingException();
}
}
}
catch (Exception exception)
{
BackupRestoreTrace.TraceSource.WriteInfo(TraceType, "DeleteValueAsync Key : {0} Failed ", key);
UtilityHelper.LogException(TraceType, exception);
this.HandleException(exception);
}
}
/// <summary>
/// Try to abort the transaction.
/// </summary>
///
/// <param name="transaction">The transaction to abort.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
///
/// <returns>Whether the abort call has succeeded.</returns>
/// <exception cref="AmazonServiceException">If there is an error communicating with QLDB.</exception>
private async Task <bool> TryAbort(ITransaction transaction, CancellationToken cancellationToken = default)
{
try
{
if (transaction != null)
{
await transaction.Abort(cancellationToken);
}
else
{
await this.session.AbortTransaction(cancellationToken);
}
}
catch (AmazonServiceException ase)
{
this.logger.LogWarning("This session is invalid on ABORT: {}", ase);
this.isAlive = false;
return(false);
}
return(true);
}
/// <summary>
/// Try to abort the transaction.
/// </summary>
///
/// <param name="transaction">The transaction to abort.</param>
/// <returns>Whether the abort call has succeeded.</returns>
/// <exception cref="AmazonServiceException">If there is an error communicating with QLDB.</exception>
private bool TryAbort(ITransaction transaction)
{
try
{
if (transaction != null)
{
transaction.Abort();
}
else
{
this.session.AbortTransaction();
}
}
catch (AmazonServiceException ase)
{
this.logger.LogWarning("This session is invalid on ABORT: {}", ase);
this.isAlive = false;
return(false);
}
return(true);
}
public async Task <IActionResult> ReadEntityByIdentity(string name, string key)
{
UserProfile userProfile = new UserProfile();
IReliableDictionary <string, string> identitiesDictionary = await this.stateManager.GetOrAddAsync <IReliableDictionary <string, string> >(Names.IdentitiesDictionaryName);
IReliableDictionary <string, User> entitiesDictionary = await this.stateManager.GetOrAddAsync <IReliableDictionary <string, User> >(Names.EntitiesDictionaryName);
using (ITransaction tx = this.stateManager.CreateTransaction())
{
try
{
var result = await identitiesDictionary.TryGetValueAsync(tx, key);
if (result.HasValue)
{
var userResult = await entitiesDictionary.TryGetValueAsync(tx, result.Value.ToString());
userProfile.FirstName = userResult.Value.FirstName;
userProfile.LastName = userResult.Value.LastName;
userProfile.UserName = userResult.Value.Username;
userProfile.Password = userResult.Value.Password;
}
await tx.CommitAsync();
}
catch (TimeoutException te)
{
// transient error. Could Retry if one desires .
ServiceEventSource.Current.ServiceMessage(this.context, $"DataService - ReadEntityByIdentity - TimeoutException : Message=[{te.ToString()}]");
}
catch (Exception ex)
{
ServiceEventSource.Current.ServiceMessage(this.context, $"DataService - ReadEntityByIdentity - General Exception - Message=[{0}]", ex);
tx.Abort();
}
}
return(this.Ok(userProfile));
}
public async Task <string> GetAllRequests()
{
try
{
var queue = await this.StateManager.GetOrAddAsync <IReliableConcurrentQueue <UserRequest> >(UserRequestsQueueName);
List <UserRequest> items = new List <UserRequest>();
using (ITransaction tx = this.StateManager.CreateTransaction())
{
ConditionalValue <UserRequest> ret;
do
{
ret = await queue.TryDequeueAsync(tx);
if (ret.HasValue)
{
items.Add(ret.Value);
}
} while (ret.HasValue);
tx.Abort();
}
return(JsonConvert.SerializeObject(items));
}
catch (InvalidOperationException ex)
{
ServiceEventSource.Current.Message(string.Format("GetAllRequests: Getting requests rejected: {0}", ex));
throw;
}
catch (Exception ex)
{
ServiceEventSource.Current.Message(string.Format("GetAllRequests: Exception {0}", ex));
throw;
}
}
// Transactions
public void createPayment()
{
ITransactionManager mgr = GigaSpacesFactory.CreateDistributedTransactionManager();
// Create a transaction using the transaction manager:
ITransaction trn = mgr.Create();
try{
Payment payment = new Payment();
payment.CreatedDate = DateTime.Today;
payment.Status = ETransactionStatus.PROCESSED;
proxy.Write(payment);
// Commit the transaction
trn.Commit();
}
catch (Exception ex) {
System.Console.WriteLine(ex.ToString());
// rollback the transaction
trn.Abort();
}
}
public static async Task <List <KeyValuePair <TKeyType, TValueType> > > GetAllObjectsFromStateManagerFor(StatefulServiceContext context, ITransaction tx, IReliableStateManager stateManager, string dictionaryName, IApplicationLifetime appLifetime)
{
List <KeyValuePair <TKeyType, TValueType> > listRet = new List <KeyValuePair <TKeyType, TValueType> >();
IReliableDictionary <TKeyType, TValueType> dictionary = await stateManager.GetOrAddAsync <IReliableDictionary <TKeyType, TValueType> >(dictionaryName);
using (tx)
{
try
{
IAsyncEnumerable <KeyValuePair <TKeyType, TValueType> > enumerable = await dictionary.CreateEnumerableAsync(tx);
IAsyncEnumerator <KeyValuePair <TKeyType, TValueType> > enumerator = enumerable.GetAsyncEnumerator();
while (await enumerator.MoveNextAsync(appLifetime.ApplicationStopping))
{
if (enumerator.Current.Value.GetType() == typeof(TValueType))
{
listRet.Add(new KeyValuePair <TKeyType, TValueType>(enumerator.Current.Key, (TValueType)enumerator.Current.Value));
}
}
}
catch (TimeoutException te)
{
// transient error. Could Retry if one desires .
ServiceEventSource.Current.ServiceMessage(context, $"DataService - GetAllObjectsFromStateManagerFor - TimeoutException : Message=[{te.ToString()}]");
}
catch (Exception ex)
{
ServiceEventSource.Current.ServiceMessage(context, $"DataService - GetAllObjectsFromStateManagerFor - General Exception - Message=[{0}]", ex);
tx.Abort();
}
return(listRet);
}
}
public Task Abort()
{
wrappedTransaction.Abort();
return(Task.CompletedTask);
}
private async Task ProcessBackup(StatefulService statefulService, TimeSpan timeout, CancellationToken cancellationToken, string processQueueTypeTrace)
{
BackupRestoreTrace.TraceSource.WriteInfo(processQueueTypeTrace, "Processing the Backup for request Uri : {0} , PartitionId {1}", this.ServiceUri, this.PartitionId);
var timeOutPersecCycle = 30000;
var backupPartitionStore = await BackupPartitionStore.CreateOrGetBackupPartitionStore(statefulService);
var fabricUri = UtilityHelper.GetBackupMappingKey(this.ServiceUri, this.PartitionId);
BackupPartitionStatus backupPartitionStatus;
do
{
var backupNowConfiguration =
new BackupNowConfiguration()
{
StoreInformation = this.GetBackupStoreInformationFromBackupStorage(this.BackupStorage),
OperationTimeoutMilliseconds = (int)this.BackupTimeout.TotalMilliseconds
};
await UtilityHelper.InvokeWithRetry(async() =>
{
await
Program.ServiceAgent.BackupPartitionAsync(new Uri(UtilityHelper.GetUriFromCustomUri(this.ServiceUri)),
Guid.Parse(this.PartitionId),
this.BackupRequestGuid, backupNowConfiguration, timeout, cancellationToken);
});
BackupRestoreTrace.TraceSource.WriteInfo(processQueueTypeTrace, "Requested the BackupPartitionAsync Successfully for Service Uri : {0} , PartitionId {1}", this.ServiceUri, this.PartitionId);
await UtilityHelper.InvokeWithRetry(async() =>
{
using (ITransaction transaction = statefulService.StateManager.CreateTransaction())
{
var currentBackupPartitionStatus = await backupPartitionStore.GetValueWithUpdateLockModeAsync(fabricUri, timeout, cancellationToken, transaction);
if (currentBackupPartitionStatus.BackupPartitionStatusState == BackupState.Accepted)
{
var toUpdateBackupPartitionStatus = currentBackupPartitionStatus.ToBuilder().WithState(BackupState.BackupInProgress).Build();
await backupPartitionStore.UpdateValueAsync(fabricUri, toUpdateBackupPartitionStatus,
timeout,
cancellationToken,
transaction);
await transaction.CommitAsync();
BackupRestoreTrace.TraceSource.WriteInfo(processQueueTypeTrace, "Updated the Backup partition request to BackupInProcss for request Service Uri : {0} , PartitionId {1}", this.ServiceUri, this.PartitionId);
}
else
{
transaction.Abort();
BackupRestoreTrace.TraceSource.WriteInfo(processQueueTypeTrace,
"Could not Update the BackupPartition request to BackupInProcess for request Service Uri : {0} , PartitionId {1} because currentBackupPartitionStatus value is {2}",
this.ServiceUri, this.PartitionId, currentBackupPartitionStatus);
}
}
}
);
await Task.Delay(timeOutPersecCycle, cancellationToken);
backupPartitionStatus = await backupPartitionStore.GetValueAsync(fabricUri);
BackupRestoreTrace.TraceSource.WriteInfo(processQueueTypeTrace, "BackupPartitionstatusState {0},isCancellationRequested {1} for Service Uri : {2} , PartitionId {3}",
backupPartitionStatus.BackupPartitionStatusState, cancellationToken.IsCancellationRequested, this.ServiceUri, this.PartitionId);
} while ((backupPartitionStatus.BackupPartitionStatusState == BackupState.Accepted ||
backupPartitionStatus.BackupPartitionStatusState == BackupState.BackupInProgress) &&
this.BackupRequestGuid.Equals(backupPartitionStatus.OperationId) &&
!cancellationToken.IsCancellationRequested);
cancellationToken.ThrowIfCancellationRequested();
}
public async Task <IActionResult> CreateEntity(string name, string key, [FromBody] UserProfile userProfile)
{
bool bRet = false;
if (String.IsNullOrEmpty(name) || String.IsNullOrEmpty(key))
{
return(this.BadRequest());
}
if (userProfile != null)
{
Debug.WriteLine("On CreateEntity postContent=[" + userProfile.ToString() + "]");
}
else
{
Debug.WriteLine("On CreateEntity postContent=[ userProfile is null ]");
}
if (userProfile == null)
{
return(this.BadRequest());
}
string id = FnvHash.GetUniqueId();
User user = new User();
user.Id = id;
user.Username = userProfile.UserName;
user.FirstName = userProfile.FirstName;
user.LastName = userProfile.LastName;
user.Password = userProfile.Password;
user.PasswordCreated = true;
IReliableDictionary <string, string> identitiesDictionary = await this.stateManager.GetOrAddAsync <IReliableDictionary <string, string> >(Names.IdentitiesDictionaryName);
IReliableDictionary <string, User> entitiesDictionary = await this.stateManager.GetOrAddAsync <IReliableDictionary <string, User> >(Names.EntitiesDictionaryName);
using (ITransaction tx = this.stateManager.CreateTransaction())
{
int retryCount = 1;
while (retryCount > 0)
{
try
{
await identitiesDictionary.AddAsync(tx, userProfile.UserName, id);
await entitiesDictionary.AddAsync(tx, id, user);
// Commit
await tx.CommitAsync();
retryCount = 0;
}
catch (TimeoutException te)
{
// transient error. Could Retry if one desires .
ServiceEventSource.Current.ServiceMessage(this.context, $"DataService - CreateEntity(Save) - TimeoutException : Retry Count#{retryCount}: Message=[{te.ToString()}]");
if (global::Iot.Common.Names.TransactionsRetryCount > retryCount)
{
retryCount = 0;
}
else
{
retryCount++;
await Task.Delay(global::Iot.Common.Names.TransactionRetryWaitIntervalInMills *(int)Math.Pow(2, retryCount));
}
}
catch (Exception ex)
{
ServiceEventSource.Current.ServiceMessage(this.context, $"DataService - CreateEntity(Save) - General Exception - Message=[{0}]", ex);
retryCount = 0;
tx.Abort();
}
}
}
// now let's check if the commits have finished
using (ITransaction tx = this.stateManager.CreateTransaction())
{
try
{
bool keepReading = true;
while (keepReading)
{
var result = await identitiesDictionary.TryGetValueAsync(tx, userProfile.UserName);
if (result.Value.Equals(id))
{
await tx.CommitAsync();
bRet = true;
break;
}
Thread.Sleep(1000);
}
}
catch (TimeoutException te)
{
// transient error. Could Retry if one desires .
ServiceEventSource.Current.ServiceMessage(this.context, $"DataService - CreateEntity(Wait Save) - TimeoutException : Message=[{te.ToString()}]");
}
catch (Exception ex)
{
ServiceEventSource.Current.ServiceMessage(this.context, $"DataService - CreateEntity(Wait Save) - General Exception - Message=[{0}]", ex);
tx.Abort();
}
}
return(this.Ok(bRet));
}
public async Task <RestorePointDetails> GetRestorePointDetailsAsync(BackupPartitionInfo backupPartitionInfo, TimeSpan timeout,
CancellationToken cancellationToken)
{
BackupRestoreTrace.TraceSource.WriteInfo(TraceType, "GetRestorePointDetailsAsync invoked for partition {0}", backupPartitionInfo.PartitionId);
var restoreStore = await RestoreStore.CreateOrGetRestoreStatusStore(this.statefulService);
var backupMappingStore = await BackupMappingStore.CreateOrGetBackupMappingStore(this.statefulService);
var backupPolicyStore = await BackupPolicyStore.CreateOrGetBackupPolicyStore(this.statefulService);
bool userInitiatedOperation;
BackupStorage backupStorage;
BackupStoreInformation backupStoreInformation = null;
List <string> backupLocations;
string brsServiceUri = await UtilityHelper.GetCustomServiceUri(backupPartitionInfo.ServiceName, timeout, cancellationToken);
var fabricUri = UtilityHelper.GetBackupMappingKey(brsServiceUri, backupPartitionInfo.PartitionId.ToString());
var restoreStatus = await restoreStore.GetValueAsync(fabricUri);
if (restoreStatus != null && (
restoreStatus.RestoreStatusState != RestoreState.Failure ||
restoreStatus.RestoreStatusState != RestoreState.Invalid ||
restoreStatus.RestoreStatusState != RestoreState.Success ||
restoreStatus.RestoreStatusState != RestoreState.Timeout))
{
backupStorage = restoreStatus.BackupStorage;
userInitiatedOperation = true;
backupLocations = restoreStatus.BackupLocations.ToList();
}
else
{
var backupMappingKey = UtilityHelper.GetBackupMappingKey(brsServiceUri,
backupPartitionInfo.PartitionId.ToString());
var backupMappingModel = (await backupMappingStore.GetValueAsync(backupMappingKey) ??
await backupMappingStore.GetValueAsync(brsServiceUri)) ??
await backupMappingStore.GetValueAsync(UtilityHelper.GetApplicationNameFromService(brsServiceUri));
if (backupMappingModel == null)
{
throw new FabricPeriodicBackupNotEnabledException();
}
var backupPolicy = await backupPolicyStore.GetValueAsync(backupMappingModel.BackupPolicyName);
if (backupPolicy != null && backupPolicy.AutoRestore)
{
backupStorage = backupPolicy.Storage;
userInitiatedOperation = false;
string applicationName, serviceName;
UtilityHelper.GetApplicationAndServiceNameFromServiceUri(brsServiceUri,
out applicationName, out serviceName);
// Get the latest backup now
var backups = await backupStorage.GetBackupEnumerationsTask(
applicationName,
serviceName,
backupPartitionInfo.PartitionId.ToString(),
DateTime.MinValue,
DateTime.MaxValue,
true,
cancellationToken);
if (backups == null || backups.Count == 0)
{
throw new ArgumentException(); // TODO: Change this with appropriate exception
}
var backupDetail = backups.First();
var recoveryPointManager = RecoveryPointManagerFactory.GetRecoveryPointManager(backupStorage);
backupLocations = await recoveryPointManager.GetBackupLocationsInBackupChainAsync(backupDetail.BackupLocation, cancellationToken);
}
else
{
throw new ArgumentException(); // TODO: Change with the OTher exception
}
}
switch (backupStorage.BackupStorageType)
{
case BackupStorageType.FileShare:
var fileShareStorage = (FileShareStorage)backupStorage;
backupStoreInformation = new FileShareBackupStore
{
AccessType = String.IsNullOrEmpty(fileShareStorage.PrimaryUserName) ? FileShareAccessType.None : FileShareAccessType.DomainUser,
FileSharePath = fileShareStorage.Path,
PrimaryUserName = fileShareStorage.PrimaryUserName,
PrimaryPassword = fileShareStorage.PrimaryPassword,
SecondaryUserName = fileShareStorage.SecondaryUserName,
SecondaryPassword = fileShareStorage.SecondaryPassword,
IsPasswordEncrypted = fileShareStorage.IsPasswordEncrypted,
};
break;
case BackupStorageType.AzureBlobStore:
var azureStorage = (AzureStorage)backupStorage;
backupStoreInformation = new AzureBlobBackupStore
{
ConnectionString = azureStorage.ConnectionString,
ContainerName = azureStorage.ContainerName,
FolderPath = String.Empty, // TODO: This should be constructed
IsAccountKeyEncrypted = azureStorage.IsConnectionStringEncrypted,
};
break;
case BackupStorageType.DsmsAzureBlobStore:
var dsmsAzureStorage = (DsmsAzureStorage)backupStorage;
backupStoreInformation = new DsmsAzureBlobBackupStore
{
StorageCredentialsSourceLocation = dsmsAzureStorage.StorageCredentialsSourceLocation,
ContainerName = dsmsAzureStorage.ContainerName,
FolderPath = String.Empty, // TODO: This should be constructed
};
break;
}
Guid restoreOperationId = Guid.NewGuid();
if (userInitiatedOperation)
{
await UtilityHelper.InvokeWithRetry(async() =>
{
using (ITransaction transaction = this.statefulService.StateManager.CreateTransaction())
{
var currentRestoreStatus = await restoreStore.GetValueWithUpdateLockModeAsync(fabricUri, timeout, cancellationToken, transaction);
restoreOperationId = currentRestoreStatus.RestoreRequestGuid;
if (currentRestoreStatus.RestoreStatusState == RestoreState.Accepted) //TODO Check for Guid
{
var toUpdateRestoreStatus = currentRestoreStatus.ToBuilder().WithState(RestoreState.RestoreInProgress).Build();
await
restoreStore.UpdateValueAsync(fabricUri, toUpdateRestoreStatus, timeout,
cancellationToken, transaction);
await transaction.CommitAsync();
}
else
{
transaction.Abort();
}
}
});
}
var restorePartitionDetails = new RestorePointDetails()
{
BackupLocations = backupLocations,
UserInitiatedOperation = userInitiatedOperation,
StoreInformation = backupStoreInformation,
OperationId = restoreOperationId
};
BackupRestoreTrace.TraceSource.WriteInfo(TraceType, "GetRestorePointDetailsAsync invoked for partition {0} with Return Values {1}", backupPartitionInfo.PartitionId, restorePartitionDetails);
return(restorePartitionDetails);
}
