public async Task <HttpResponseMessage> EnableBackupProtection([FromBody] BackupMapping backupMapping, [FromUri(Name = "api-version")] string apiVersion = "0.0", [FromUri] int timeout = 60)
{
string fabricRequestHeader = this.GetFabricRequestFromRequstHeader();
return(await
this.RunAsync(new EnableBackupMappingOperation(fabricRequestHeader, backupMapping, apiVersion, this.statefulService), timeout));
}
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);
}
public override async Task <bool> Process(Microsoft.ServiceFabric.Services.Runtime.StatefulService statefulService, TimeSpan timeout, CancellationToken cancellationToken, string processQueueTypeTrace)
{
WorkItem workItem = null;
WorkItemQueue workItemQueue = await WorkItemQueue.CreateOrGetWorkItemQueue(statefulService);
BackupMappingStore backupMappingStore =
await BackupMappingStore.CreateOrGetBackupMappingStore(statefulService);
BackupRestoreTrace.TraceSource.WriteInfo(processQueueTypeTrace, "Resolving for {0} of type {1} ", this.ApplicationOrServiceUri, this.FabricBackupResourceType);
try
{
if (this.FabricBackupResourceType == FabricBackupResourceType.ApplicationUri)
{
ServiceList serviceList =
await FabricClientHelper.GetServiceList(this.ApplicationOrServiceUri);
foreach (Query.Service service in serviceList)
{
if (service.ServiceKind == ServiceKind.Stateful && (service as StatefulService).HasPersistedState)
{
BackupMapping specificServiceBackupMapping = await backupMappingStore.GetValueAsync(
UtilityHelper.GetBackupMappingKey(service.ServiceName.OriginalString, null));
if (specificServiceBackupMapping == null || this.WorkItemInfo.WorkItemType == WorkItemPropogationType.SuspendPartition ||
this.WorkItemInfo.WorkItemType == WorkItemPropogationType.ResumePartition)
{
ServicePartitionList servicePartitionList =
await
FabricClientHelper.GetPartitionList(service.ServiceName.OriginalString);
foreach (Partition servicePartition in servicePartitionList)
{
BackupMapping specificPartitionBackupMapping =
await backupMappingStore.GetValueAsync(UtilityHelper.GetBackupMappingKey(
service.ServiceName.OriginalString,
servicePartition.PartitionInformation.Id.ToString()));
if (specificPartitionBackupMapping == null || this.WorkItemInfo.WorkItemType == WorkItemPropogationType.SuspendPartition ||
this.WorkItemInfo.WorkItemType == WorkItemPropogationType.ResumePartition)
{
//Send to Service Partition
workItem = new SendToServiceNodeWorkItem
(await UtilityHelper.GetCustomServiceUri(service.ServiceName.OriginalString, timeout, cancellationToken),
servicePartition.PartitionInformation.Id.ToString(),
this.WorkItemInfo);
await workItemQueue.AddWorkItem(workItem, timeout, cancellationToken);
}
}
}
}
}
}
else if (this.FabricBackupResourceType == FabricBackupResourceType.ServiceUri)
{
ServicePartitionList servicePartitionList =
await
FabricClientHelper.GetPartitionList(this.ApplicationOrServiceUri);
foreach (Partition servicePartition in servicePartitionList)
{
BackupMapping specificPartitionBackupMapping =
await backupMappingStore.GetValueAsync(UtilityHelper.GetBackupMappingKey(
this.ApplicationOrServiceUri, servicePartition.PartitionInformation.Id.ToString()));
if (specificPartitionBackupMapping == null || this.WorkItemInfo.WorkItemType == WorkItemPropogationType.SuspendPartition ||
this.WorkItemInfo.WorkItemType == WorkItemPropogationType.ResumePartition)
{
//Send to Service Partition
workItem = new SendToServiceNodeWorkItem
(await UtilityHelper.GetCustomServiceUri(this.ApplicationOrServiceUri, timeout, cancellationToken), servicePartition.PartitionInformation.Id.ToString(), this.WorkItemInfo);
await workItemQueue.AddWorkItem(workItem, timeout, cancellationToken);
}
}
}
BackupRestoreTrace.TraceSource.WriteInfo(processQueueTypeTrace, "Resolving successful");
}
catch (Exception exception)
{
AggregateException aggregateException = exception as AggregateException;
if (aggregateException != null)
{
BackupRestoreTrace.TraceSource.WriteWarning(processQueueTypeTrace, "Aggregate Exception Stack Trace : {0}",
exception.StackTrace);
foreach (Exception innerException in aggregateException.InnerExceptions)
{
BackupRestoreTrace.TraceSource.WriteWarning(processQueueTypeTrace,
"Inner Exception : {0} , Message : {1} , Stack Trace : {2} ",
innerException.InnerException, innerException.Message, innerException.StackTrace);
}
}
else
{
BackupRestoreTrace.TraceSource.WriteWarning(processQueueTypeTrace,
"Exception : {0} , Message : {1} , Stack Trace : {2} ",
exception.InnerException, exception.Message, exception.StackTrace);
}
return(false);
}
return(true);
}
/// <summary>
/// Gets called when a partition is disabled for a pariticular policy.
/// </summary>
internal async Task DisablePolicyAsync(BackupPolicy backupPolicy, string partitionId, BackupMapping inheritedBackupMapping, TimeSpan timeout, CancellationToken cancellationToken, ITransaction transaction)
{
/**
* Cases:
* 1. Partition has different policy inherited and storage is different, cleanup wont impact the same storage.
* ---> Check whether the timercallback is finished or not.
* 2. Partition has different inherited policy and storage and container are same.
* --> NO Cleanup
* **/
// Since, you have disabled the policy now look for the backup mapping on the partition.
var backupPolicyStore = await BackupPolicyStore.CreateOrGetBackupPolicyStore(this.StatefulService);
if (inheritedBackupMapping == null)
{
await AddPartitionToCleanUpStore(partitionId, backupPolicy, cancellationToken, transaction);
Task cleanUpTask = CleanUpTaskUtil(partitionId, backupPolicy);
}
else
{
var inheritedPolicy = await backupPolicyStore.GetValueAsync(inheritedBackupMapping.BackupPolicyName);
if (!backupPolicy.Storage.CompareStorage(inheritedPolicy.Storage))
{
BackupRestoreTrace.TraceSource.WriteWarning(TraceType, "Inherited Policy for partition:{0} is having same storage, so, cleanup is skipped.");
}
else
{
await AddPartitionToCleanUpStore(partitionId, backupPolicy, cancellationToken, transaction);
Task cleanUpTask = CleanUpTaskUtil(partitionId, backupPolicy);
}
}
}
internal EnableBackupMappingOperation(string fabricRequestHeader, BackupMapping backupMapping, string apiVersion, StatefulService statefulService) : base(apiVersion, statefulService)
{
this.fabricRequestHeader = fabricRequestHeader;
this.backupMapping = backupMapping;
}
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));
}
