internal async override Task InitializeAsync()
{
this.BackupMappingStore = await BackupMappingStore.CreateOrGetBackupMappingStore(this.StatefulService).ConfigureAwait(false);
this.BackupPolicyStore = await BackupPolicyStore.CreateOrGetBackupPolicyStore(this.StatefulService).ConfigureAwait(false);
this.WorkItemQueue = await WorkItemQueue.CreateOrGetWorkItemQueue(this.StatefulService).ConfigureAwait(false);
}
internal async Task DisablePolicyAsync(string fabricUri, BackupMapping currentBackupMapping, TimeSpan timeout, CancellationToken cancellationToken, ITransaction transaction)
{
BackupRestoreTrace.TraceSource.WriteInfo(TraceType, " In DisablePolicyAsync for fabricUri : {0}", fabricUri);
string applicationNameUri = null;
string serviceNameUri = null;
string partitionID = null;
var fabricBackupResourceType = UtilityHelper.GetApplicationAndServicePartitionUri(fabricUri, out applicationNameUri, out serviceNameUri, out partitionID);
List <string> filteredPartitionList = new List <string>();
var backupMappingStore = await BackupMappingStore.CreateOrGetBackupMappingStore(this.StatefulService);
var backupPolicyStore = await BackupPolicyStore.CreateOrGetBackupPolicyStore(this.StatefulService);
var currentBackupPolicy = await backupPolicyStore.GetValueAsync(currentBackupMapping.BackupPolicyName, transaction);
BackupMapping inheritedBackupMapping = null;
switch (fabricBackupResourceType)
{
case FabricBackupResourceType.ApplicationUri:
filteredPartitionList = await FilterPartitionListToDisableForFabricURI(await GetPartitionsForServiceOrApplication(fabricUri,
FabricBackupResourceType.ApplicationUri, timeout, cancellationToken), timeout, cancellationToken, FabricBackupResourceType.ServiceUri);
break;
case FabricBackupResourceType.ServiceUri:
filteredPartitionList = await FilterPartitionListToDisableForFabricURI(await GetPartitionsForServiceOrApplication(fabricUri,
FabricBackupResourceType.ServiceUri, timeout, cancellationToken), timeout, cancellationToken, FabricBackupResourceType.ServiceUri);
inheritedBackupMapping = await backupMappingStore.GetValueAsync(applicationNameUri, transaction);
break;
case FabricBackupResourceType.PartitionUri:
inheritedBackupMapping = await backupMappingStore.GetValueAsync(serviceNameUri, transaction);
if (inheritedBackupMapping == null)
{
inheritedBackupMapping = await backupMappingStore.GetValueAsync(applicationNameUri, transaction);
}
filteredPartitionList.Add(partitionID);
break;
}
foreach (var partitionId in filteredPartitionList)
{
// there can be only one inherited backup policy for a single URI.
BackupRestoreTrace.TraceSource.WriteInfo(TraceType, " Trying to start DisablePolicyTask for partitionId : {0}", partitionId);
await DisablePolicyAsync(currentBackupPolicy, partitionId, inheritedBackupMapping, timeout, cancellationToken, transaction);
BackupRestoreTrace.TraceSource.WriteInfo(TraceType, " Succesfully started DisablePolicyTask for partitionId : {0}", partitionId);
}
}
internal async Task <BackupMapping> GetEffectiveBackupMappingFromPartitionId(string partitionId, TimeSpan timeout, CancellationToken cancellationToken, FabricBackupResourceType fabricBackupResourceType)
{
string serviceNameUri = await FabricClientHelper.GetFabricServiceUriFromPartitionId(partitionId, timeout, tokenSource.Token);
string partitionUri = await UtilityHelper.GetFabricUriFromPartitionId(partitionId, this.timeout, this.tokenSource.Token);
var backupMappingStore = await BackupMappingStore.CreateOrGetBackupMappingStore(this.StatefulService);
BackupMapping backupMapping = null;
if (fabricBackupResourceType == FabricBackupResourceType.ApplicationUri)
{
backupMapping = (await backupMappingStore.GetValueAsync(partitionUri, timeout, this.tokenSource.Token) ??
await backupMappingStore.GetValueAsync(serviceNameUri, this.timeout, tokenSource.Token));
}
else
{
backupMapping = await backupMappingStore.GetValueAsync(partitionUri, timeout, this.tokenSource.Token);
}
return(backupMapping);
}
internal async Task <HashSet <string> > FindParititionsEnabledByPolicy(BackupPolicy backupPolicy)
{
BackupRestoreTrace.TraceSource.WriteInfo(TraceType, " Finding all the partitions enabled for the backupPolicy : {0}", backupPolicy.Name);
HashSet <string> partitionsEnabledByPolicy = new HashSet <string>();
var backupPolicyStore = await BackupPolicyStore.CreateOrGetBackupPolicyStore(this.StatefulService);
var backupMappingStore = await BackupMappingStore.CreateOrGetBackupMappingStore(this.StatefulService);
var backupEnabledSet = backupPolicy.BackupEnabledSet.ToList();
foreach (var backupedUri in backupEnabledSet)
{
string applicationName = null;
string serviceName = null;
string partitionId = null;
FabricBackupResourceType fabricBackupResourceType =
UtilityHelper.GetApplicationAndServicePartitionUri(backupedUri, out applicationName, out serviceName,
out partitionId);
switch (fabricBackupResourceType)
{
case FabricBackupResourceType.PartitionUri:
partitionsEnabledByPolicy.Add(partitionId);
break;
default:
var partitionIDList = await GetPartitionsForServiceOrApplication(backupedUri, fabricBackupResourceType, this.timeout, this.tokenSource.Token);
foreach (var partitionID in partitionIDList)
{
partitionsEnabledByPolicy.Add(partitionID);
this.tokenSource.Token.ThrowIfCancellationRequested();
}
break;
}
}
List <string> partitionListToRemove = new List <string>();
foreach (var partitionId in partitionsEnabledByPolicy)
{
this.tokenSource.Token.ThrowIfCancellationRequested();
string serviceNameUri = await FabricClientHelper.GetFabricServiceUriFromPartitionId(partitionId, timeout, tokenSource.Token);
string applicationNameUri = await FabricClientHelper.GetFabricApplicationUriFromServiceUri(serviceNameUri, timeout, tokenSource.Token);
string partitionUri = await UtilityHelper.GetFabricUriFromPartitionId(partitionId, this.timeout, this.tokenSource.Token);
var backupMapping = (await backupMappingStore.GetValueAsync(partitionUri, timeout, this.tokenSource.Token) ??
await backupMappingStore.GetValueAsync(serviceNameUri, this.timeout, tokenSource.Token)) ??
await backupMappingStore.GetValueAsync(applicationNameUri, this.timeout, tokenSource.Token);
if (backupMapping.BackupPolicyName != backupPolicy.Name)
{
partitionListToRemove.Add(partitionId);
}
}
foreach (var partitionId in partitionListToRemove)
{
partitionsEnabledByPolicy.Remove(partitionId);
}
return(partitionsEnabledByPolicy);
}
internal override async Task <HttpResponseMessage> RunAsync(TimeSpan timeout, CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(this.backupPolicyName))
{
throw new ArgumentException(StringResources.InvalidArguments);
}
var backupPolicy = await this.BackupPolicyStore.GetValueAsync(this.backupPolicyName);
BackupMappingStore backupMappingStore = await
BackupMappingStore.CreateOrGetBackupMappingStore(this.StatefulService);
SuspendStore suspendStore = await SuspendStore.CreateOrGetSuspendStatusStore(this.StatefulService);
List <string> allSuspensions = await suspendStore.GetAllSuspensions(timeout, cancellationToken);
if (backupPolicy != null && backupPolicy.BackupEnabledSet.Count > 0)
{
HashSet <string> backupEnables = new HashSet <string>(backupPolicy.BackupEnabledSet);
foreach (var backupEnable in backupEnables)
{
if (!await this.IsFabricEntityExisting(backupEnable, timeout, cancellationToken))
{
using (ITransaction transaction = this.StatefulService.StateManager.CreateTransaction())
{
var currentBackupPolicy =
await
this.BackupPolicyStore.GetValueWithUpdateLockModeAsync(this.backupPolicyName, timeout,
cancellationToken,
transaction);
var updatedBackupPolicy = currentBackupPolicy.ToBuilder()
.RemoveFromBackupEnabledSet(backupEnable)
.Build();
await
this.BackupPolicyStore.RemoveProtectionEntity(updatedBackupPolicy, backupEnable,
timeout,
cancellationToken, transaction);
await backupMappingStore.DeleteValueAsync(backupEnable, timeout, cancellationToken);
await transaction.CommitAsync();
}
}
}
}
RetentionManager retentionManager = await RetentionManager.CreateOrGetRetentionManager(this.StatefulService);
using (var transaction = this.StatefulService.StateManager.CreateTransaction())
{
foreach (string suspension in allSuspensions)
{
string applicationNameUri = null;
string serviceNameUri = null;
string partitionId = null;
FabricBackupResourceType fabricBackupResourceType =
UtilityHelper.GetApplicationAndServicePartitionUri(suspension, out applicationNameUri, out serviceNameUri, out partitionId);
BackupMapping backupMapping = null;
switch (fabricBackupResourceType)
{
case FabricBackupResourceType.PartitionUri:
backupMapping =
await backupMappingStore.GetValueAsync(UtilityHelper.GetBackupMappingKey(serviceNameUri, partitionId),
timeout, cancellationToken, transaction) ??
await backupMappingStore.GetValueAsync(serviceNameUri, timeout, cancellationToken, transaction) ??
await backupMappingStore.GetValueAsync(applicationNameUri, timeout, cancellationToken, transaction);
break;
case FabricBackupResourceType.ServiceUri:
backupMapping =
await backupMappingStore.GetValueAsync(serviceNameUri, timeout, cancellationToken, transaction) ??
await backupMappingStore.GetValueAsync(applicationNameUri, timeout, cancellationToken, transaction);
break;
case FabricBackupResourceType.ApplicationUri:
backupMapping =
await backupMappingStore.GetValueAsync(applicationNameUri, timeout, cancellationToken, transaction);
break;
}
if (backupMapping != null && this.backupPolicyName.Equals(backupMapping.BackupPolicyName))
{
await suspendStore.DeleteValueAsync(suspension, timeout, cancellationToken, transaction);
}
}
await this.BackupPolicyStore.DeleteValueAsync(this.backupPolicyName, timeout, cancellationToken, transaction);
await retentionManager.DeletePolicyAsync(this.backupPolicyName, timeout, cancellationToken, transaction);
await transaction.CommitAsync();
}
return(new HttpResponseMessage(HttpStatusCode.OK));
}
public async Task <BackupPolicy> GetBackupSchedulingPolicyAsync(BackupPartitionInfo backupPartitionInfo,
TimeSpan timeout,
CancellationToken cancellationToken)
{
BackupPolicy backupPolicy;
BackupRestoreTrace.TraceSource.WriteInfo(TraceType, "{0} GetBackupPolicy invoked", backupPartitionInfo.PartitionId);
var backupMappingStore = await BackupMappingStore.CreateOrGetBackupMappingStore(this.statefulService);
var backupPolicyStore = await BackupPolicyStore.CreateOrGetBackupPolicyStore(this.statefulService);
var suspendStore = await SuspendStore.CreateOrGetSuspendStatusStore(this.statefulService);
var serviceNameUri = await UtilityHelper.GetCustomServiceUri(backupPartitionInfo.ServiceName, timeout, cancellationToken);
var backupMappingKey = UtilityHelper.GetBackupMappingKey(serviceNameUri, backupPartitionInfo.PartitionId.ToString());
var backupMappingModel = (await backupMappingStore.GetValueAsync(backupMappingKey) ??
await backupMappingStore.GetValueAsync(serviceNameUri)) ??
await backupMappingStore.GetValueAsync(UtilityHelper.GetApplicationNameFromService(serviceNameUri));
bool isPartitionSuspended = await suspendStore.GetValueAsync(backupMappingKey) != null;
if (backupMappingModel == null || isPartitionSuspended)
{
BackupRestoreTrace.TraceSource.WriteInfo(TraceType, "{0} Backup protection not enabled", backupPartitionInfo.PartitionId);
throw new FabricPeriodicBackupNotEnabledException();
}
var backupPolicyName = backupMappingModel.BackupPolicyName;
var backupPolicyModel = await backupPolicyStore.GetValueAsync(backupPolicyName);
switch (backupPolicyModel.BackupSchedule.BackupScheduleType)
{
case BackupScheduleType.FrequencyBased:
backupPolicy = new FrequencyBasedBackupPolicy();
var frequencyBasedSchedulePolicy = (System.Fabric.BackupRestore.Common.Model.FrequencyBasedBackupSchedule)backupPolicyModel.BackupSchedule;
backupPolicy.PolicyType = BackupPolicyType.FrequencyBased;
var freqBackupPolicy = (FrequencyBasedBackupPolicy)backupPolicy;
freqBackupPolicy.RunFrequency = (ushort)frequencyBasedSchedulePolicy.Interval;
if (frequencyBasedSchedulePolicy.IntervalType == BackupScheduleInterval.Hours)
{
freqBackupPolicy.RunFrequencyType = BackupPolicyRunFrequency.Hours;
}
if (frequencyBasedSchedulePolicy.IntervalType == BackupScheduleInterval.Minutes)
{
freqBackupPolicy.RunFrequencyType = BackupPolicyRunFrequency.Minutes;
}
break;
case BackupScheduleType.TimeBased:
backupPolicy = new ScheduleBasedBackupPolicy();
var scheduleBasedSchedulePolicy = (System.Fabric.BackupRestore.Common.Model.TimeBasedBackupSchedule)backupPolicyModel.BackupSchedule;
backupPolicy.PolicyType = BackupPolicyType.ScheduleBased;
var schdBackupPolicy = (ScheduleBasedBackupPolicy)backupPolicy;
if (scheduleBasedSchedulePolicy.ScheduleFrequencyType == BackupScheduleFrequency.Daily)
{
schdBackupPolicy.RunSchedule = BackupPolicyRunSchedule.Daily;
}
if (scheduleBasedSchedulePolicy.ScheduleFrequencyType == BackupScheduleFrequency.Weekly)
{
schdBackupPolicy.RunSchedule = BackupPolicyRunSchedule.Weekly;
}
schdBackupPolicy.RunDays = new List <DayOfWeek>(scheduleBasedSchedulePolicy.RunDays);
schdBackupPolicy.RunTimes = new List <TimeSpan>(scheduleBasedSchedulePolicy.RunTimes);
break;
default:
throw new FabricPeriodicBackupNotEnabledException();
}
backupPolicy.MaxIncrementalBackups = Convert.ToByte(backupPolicyModel.MaxIncrementalBackup);
backupPolicy.Name = backupPolicyModel.Name;
backupPolicy.PolicyId = backupPolicyModel.UniqueId;
switch (backupPolicyModel.Storage.BackupStorageType)
{
case BackupStorageType.FileShare:
var fileShareStorage = (System.Fabric.BackupRestore.Common.Model.FileShareBackupStorageInfo)backupPolicyModel.Storage;
backupPolicy.StoreInformation = new FileShareBackupStore
{
AccessType = String.IsNullOrEmpty(fileShareStorage.PrimaryUserName) ? FileShareAccessType.None : FileShareAccessType.DomainUser,
FileSharePath = Path.Combine(fileShareStorage.Path, UtilityHelper.GetBaseDirectoryPathForPartition(serviceNameUri, backupPartitionInfo.PartitionId.ToString())),
PrimaryUserName = fileShareStorage.PrimaryUserName,
PrimaryPassword = fileShareStorage.PrimaryPassword,
SecondaryUserName = fileShareStorage.SecondaryUserName,
SecondaryPassword = fileShareStorage.SecondaryPassword,
IsPasswordEncrypted = fileShareStorage.IsPasswordEncrypted,
};
break;
case BackupStorageType.AzureBlobStore:
var azureStorage = (System.Fabric.BackupRestore.Common.Model.AzureBlobBackupStorageInfo)backupPolicyModel.Storage;
backupPolicy.StoreInformation = new AzureBlobBackupStore
{
ConnectionString = azureStorage.ConnectionString,
ContainerName = azureStorage.ContainerName,
FolderPath = UtilityHelper.GetBaseDirectoryPathForPartition(serviceNameUri, backupPartitionInfo.PartitionId.ToString()),
IsAccountKeyEncrypted = azureStorage.IsConnectionStringEncrypted,
};
break;
case BackupStorageType.DsmsAzureBlobStore:
var dsmsAzureStorage = (System.Fabric.BackupRestore.Common.Model.DsmsAzureBlobBackupStorageInfo)backupPolicyModel.Storage;
backupPolicy.StoreInformation = new DsmsAzureBlobBackupStore
{
StorageCredentialsSourceLocation = dsmsAzureStorage.StorageCredentialsSourceLocation,
ContainerName = dsmsAzureStorage.ContainerName,
FolderPath = UtilityHelper.GetBaseDirectoryPathForPartition(serviceNameUri, backupPartitionInfo.PartitionId.ToString()),
};
break;
}
return(backupPolicy);
}
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);
}
