private NativeCommon.IFabricAsyncOperationContext PartitionBackupOperationBeginWrapper(
Uri serviceName,
Guid partitionId,
Guid operationId,
BackupNowConfiguration configuration,
TimeSpan timeout,
NativeCommon.IFabricAsyncOperationCallback callback)
{
var timeoutMilliseconds = Utility.ToMilliseconds(timeout, "timeout");
var partitionInfo = new BackupPartitionInfo
{
PartitionId = partitionId,
ServiceName = serviceName.ToString(),
};
using (var pin = new PinCollection())
{
return(this._nativeAgent.BeginPartitionBackupOperation(
partitionInfo.ToNative(pin),
operationId,
configuration.ToNative(pin),
timeoutMilliseconds,
callback));
}
}
NativeCommon.IFabricAsyncOperationContext NativeBackupRestoreRuntime.IFabricBackupRestoreHandler.BeginPartitionBackupOperation(Guid operationId, IntPtr backupConfiguration,
uint timeoutMilliseconds, NativeCommon.IFabricAsyncOperationCallback callback)
{
var managedTimout = TimeSpan.FromMilliseconds(timeoutMilliseconds);
BackupNowConfiguration managedConfiguration = null;
if (backupConfiguration != IntPtr.Zero)
{
managedConfiguration = BackupNowConfiguration.FromNative(backupConfiguration);
}
return(Utility.WrapNativeAsyncMethodImplementation(
cancellationToken =>
this.Handler.BackupPartitionAsync(
operationId,
managedConfiguration,
managedTimout,
cancellationToken),
callback,
"BackupRestoreBroker.BeginPartitionBackupOperation",
ThreadErrorMessageSetter));
}
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 Task BackupPartitionAsync(Uri serviceName, Guid partitionId, Guid operationId, BackupNowConfiguration configuration, TimeSpan timeout, CancellationToken cancellationToken)
{
Requires.Argument <Uri>("serviceName", serviceName).NotNull();
Requires.Argument <Guid>("partitionId", partitionId).NotNullOrEmpty();
Requires.Argument <Guid>("operationId", operationId).NotNullOrEmpty();
Requires.Argument <BackupNowConfiguration>("configuration", configuration).NotNull();
BackupRestoreTrace.TraceSource.WriteInfo(TraceType, "Backup Now partition {0}", partitionId);
return(Utility.WrapNativeAsyncInvokeInMTA(
(callback) => this.PartitionBackupOperationBeginWrapper(serviceName, partitionId, operationId, configuration, timeout, callback),
this.PartitionBackupOperationEndWrapper,
cancellationToken,
"FabricBackupRestoreServiceAgent.BackupPartitionAsync"));
}
