private async Task <bool> IsApplicationOrServiceExisting(FabricBackupResourceType fabricBackupResourceType,
string applicationOrServiceUri, string partitionId, TimeSpan timeout, CancellationToken cancellationToken)
{
bool isApplicationOrServiceExisting;
try
{
if (fabricBackupResourceType == FabricBackupResourceType.ApplicationUri)
{
isApplicationOrServiceExisting = await FabricClientHelper.ValidateApplicationUri(applicationOrServiceUri, timeout, cancellationToken);
}
else if (fabricBackupResourceType == FabricBackupResourceType.ServiceUri)
{
isApplicationOrServiceExisting = await FabricClientHelper.ValidateServiceUri(applicationOrServiceUri, timeout, cancellationToken);
}
else if (fabricBackupResourceType == FabricBackupResourceType.PartitionUri)
{
isApplicationOrServiceExisting = await FabricClientHelper.ValidatePartition(applicationOrServiceUri, partitionId, timeout, cancellationToken);
}
else
{
throw new ArgumentException(StringResources.InvalidArguments);
}
}
catch (FabricException)
{
//Since the Application Or Service is not existing we will return false
isApplicationOrServiceExisting = false;
}
return(isApplicationOrServiceExisting);
}
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);
}
protected internal async Task ValidateTheRequestFabricUri(string fabricUri, TimeSpan timeout, CancellationToken cancellationToken)
{
string applicationNameUri = null;
string serviceNameUri = null;
string partitionId = null;
FabricBackupResourceType fabricResourceType =
UtilityHelper.GetApplicationAndServicePartitionUri(fabricUri, out applicationNameUri, out serviceNameUri, out partitionId);
bool isInputValid = false;
switch (fabricResourceType)
{
case FabricBackupResourceType.ApplicationUri:
isInputValid = await FabricClientHelper.ValidateApplicationUri(applicationNameUri, timeout, cancellationToken);
break;
case FabricBackupResourceType.ServiceUri:
isInputValid = await FabricClientHelper.ValidateServiceUri(serviceNameUri, timeout, cancellationToken);
break;
case FabricBackupResourceType.PartitionUri:
isInputValid = await FabricClientHelper.ValidateServiceUri(serviceNameUri, timeout, cancellationToken);
if (isInputValid)
{
isInputValid = await FabricClientHelper.ValidatePartition(serviceNameUri, partitionId, timeout, cancellationToken);
}
break;
case FabricBackupResourceType.Error:
throw new ArgumentException("Invalid argument");
}
if (!isInputValid)
{
throw new ArgumentException("Invalid Arguments for Application / Service / Partitions Details.");
}
}
internal async Task <List <string> > GetPartitionsForServiceOrApplication(string fabricUri, FabricBackupResourceType fabricBackupResourceType, TimeSpan timeout, CancellationToken cancellationToken)
{
List <string> serviceUriList = new List <string>();
if (fabricBackupResourceType == FabricBackupResourceType.ApplicationUri)
{
Query.ServiceList serviceList =
await FabricClientHelper.GetServiceList(fabricUri);
foreach (Query.Service service in serviceList)
{
serviceUriList.Add(service.ServiceName.OriginalString);
}
}
else
{
serviceUriList.Add(fabricUri);
}
this.tokenSource.Token.ThrowIfCancellationRequested();
List <string> partitionIdList = new List <string>();
foreach (var serviceUri in serviceUriList)
{
Query.ServicePartitionList servicePartitionList = await
FabricClientHelper.GetPartitionList(serviceUri);
foreach (Query.Partition servicePartition in servicePartitionList)
{
partitionIdList.Add(servicePartition.PartitionInformation.Id.ToString());
}
this.tokenSource.Token.ThrowIfCancellationRequested();
}
return(partitionIdList);
}
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)
{
WorkItem workItem = null;
string applicationNameUri = null;
string serviceNameUri = null;
string partitionId = null;
this.ThrowInvalidArgumentIfNull(this.backupMapping);
var appOrServiceUri = await UtilityHelper.GetFabricUriFromRequstHeader(this.fabricRequestHeader, timeout, cancellationToken);
BackupMappingModel backupMappingModel = BackupMappingModel.FromBackupMappingView(this.backupMapping, appOrServiceUri);
FabricBackupResourceType fabricResourceType =
UtilityHelper.GetApplicationAndServicePartitionUri(backupMappingModel.ApplicationOrServiceUri, out applicationNameUri, out serviceNameUri, out partitionId);
bool isInputValid = false;
string key = backupMappingModel.ApplicationOrServiceUri;
BackupMappingModel existingBackupMapping = await this.BackupMappingStore.GetValueAsync(key, timeout, cancellationToken);
BackupPolicyModel backupPolicy = await this.BackupPolicyStore.GetValueAsync(backupMappingModel.BackupPolicyName, timeout, cancellationToken);
if (backupPolicy == null)
{
throw new FabricException(StringResources.BackupPolicyDoesNotExist, FabricErrorCode.BackupPolicyDoesNotExist);
}
WorkItemPropogationType workItemPropogationType = existingBackupMapping == null? WorkItemPropogationType.Enable :
WorkItemPropogationType.UpdateProtection;
WorkItemInfo workItemInfo = new WorkItemInfo
{
WorkItemType = workItemPropogationType,
ProctectionGuid = backupMappingModel.ProtectionId,
BackupPolicyUpdateGuid = backupPolicy.UniqueId
};
switch (fabricResourceType)
{
case FabricBackupResourceType.ApplicationUri:
isInputValid = await FabricClientHelper.ValidateApplicationUri(applicationNameUri, timeout, cancellationToken);
workItem = new ResolveToPartitionWorkItem(fabricResourceType, backupMappingModel.ApplicationOrServiceUri, workItemInfo);
break;
case FabricBackupResourceType.ServiceUri:
isInputValid = await FabricClientHelper.ValidateServiceUri(serviceNameUri, timeout, cancellationToken);
workItem = new ResolveToPartitionWorkItem(fabricResourceType, backupMappingModel.ApplicationOrServiceUri, workItemInfo);
break;
case FabricBackupResourceType.PartitionUri:
isInputValid = await FabricClientHelper.ValidateServiceUri(serviceNameUri, timeout, cancellationToken);
if (isInputValid)
{
isInputValid = await FabricClientHelper.ValidatePartition(serviceNameUri, partitionId, timeout, cancellationToken);
workItem = new SendToServiceNodeWorkItem(serviceNameUri, partitionId, workItemInfo);
}
break;
case FabricBackupResourceType.Error:
throw new ArgumentException("Invalid argument");
}
if (!isInputValid)
{
throw new ArgumentException("Invalid Arguments for Application / Service / Partitions Details.");
}
using (var transaction = this.StatefulService.StateManager.CreateTransaction())
{
await
this.BackupMappingStore.AddOrUpdateAsync(key, backupMappingModel,
(key1, BackupMappingModel1) => backupMappingModel, timeout, cancellationToken);
await this.WorkItemQueue.AddWorkItem(workItem, timeout, cancellationToken, transaction);
BackupPolicyModel existingBackupPolicy = await this.BackupPolicyStore.GetValueWithUpdateLockModeAsync(backupMappingModel.BackupPolicyName, timeout,
cancellationToken, transaction);
if (existingBackupMapping != null)
{
BackupPolicyModel previousBackupPolicy = await this.BackupPolicyStore.GetValueWithUpdateLockModeAsync(existingBackupMapping.BackupPolicyName, timeout,
cancellationToken, transaction);
await this.BackupPolicyStore.RemoveProtectionEntity(previousBackupPolicy, key, timeout, cancellationToken, transaction);
}
await this.BackupPolicyStore.AddProtectionEntity(existingBackupPolicy, key, timeout, cancellationToken, transaction);
cancellationToken.ThrowIfCancellationRequested();
await transaction.CommitAsync();
}
return(new HttpResponseMessage(HttpStatusCode.Accepted));
}
private async Task <bool> IsFabricEntityExisting(string fabricUri, TimeSpan timeout, CancellationToken cancellationToken)
{
string applicationUri = null;
string serviceUri = null;
string partitionId = null;
FabricBackupResourceType fabricBackupResourceType =
UtilityHelper.GetApplicationAndServicePartitionUri(fabricUri, out applicationUri, out serviceUri,
out partitionId);
switch (fabricBackupResourceType)
{
case FabricBackupResourceType.ApplicationUri:
try
{
return
(await FabricClientHelper.ValidateApplicationUri(applicationUri, timeout, cancellationToken));
}
catch (Exception exception)
{
FabricException fabricException = exception as FabricException;
if (fabricException != null && fabricException.ErrorCode == FabricErrorCode.ApplicationNotFound)
{
return(false);
}
}
break;
case FabricBackupResourceType.ServiceUri:
try
{
return
(await FabricClientHelper.ValidateServiceUri(serviceUri, timeout, cancellationToken));
}
catch (Exception exception)
{
FabricException fabricException = exception as FabricException;
if (fabricException != null &&
(fabricException.ErrorCode == FabricErrorCode.ServiceNotFound || fabricException.ErrorCode == FabricErrorCode.ApplicationNotFound))
{
return(false);
}
}
break;
case FabricBackupResourceType.PartitionUri:
try
{
return
(await FabricClientHelper.ValidatePartition(serviceUri, partitionId, timeout, cancellationToken));
}
catch (Exception exception)
{
FabricException fabricException = exception as FabricException;
if (fabricException != null && fabricException.ErrorCode == FabricErrorCode.PartitionNotFound)
{
return(false);
}
}
break;
}
return(true);
}
internal override async Task <HttpResponseMessage> RunAsync(TimeSpan timeout, CancellationToken cancellationToken)
{
string applicationNameUri;
string serviceNameUri;
string partitionId;
var fabricUri = await UtilityHelper.GetFabricUriFromRequstHeaderForPartitions(this.fabricRequestHeader, timeout, cancellationToken);
this.ThrowInvalidArgumentIfNull(this.restoreRequest);
await FabricClientHelper.IsFaultServiceExisting(timeout, cancellationToken);
UtilityHelper.GetApplicationAndServicePartitionUri(fabricUri, out applicationNameUri, out serviceNameUri, out partitionId);
BackupRestoreModel.BackupStorage backupStorage;
if (this.restoreRequest.BackupStorage == null)
{
var backupProtection =
await this.BackupMappingStore.GetValueAsync(fabricUri, timeout, cancellationToken) ??
await this.BackupMappingStore.GetValueAsync(serviceNameUri, timeout, cancellationToken) ??
await this.BackupMappingStore.GetValueAsync(applicationNameUri, timeout, cancellationToken);
if (backupProtection == null)
{
throw new FabricPeriodicBackupNotEnabledException();
}
var backupPolicy =
await this.BackupPolicyStore.GetValueAsync(backupProtection.BackupPolicyName, timeout, cancellationToken);
backupStorage = backupPolicy.Storage;
}
else
{
backupStorage = BackupRestoreModel.BackupStorage.FromBackupStorageView(this.restoreRequest.BackupStorage);
}
var recoveryPointManager = RecoveryPointManagerFactory.GetRecoveryPointManager(backupStorage);
var backupDetails = await recoveryPointManager.GetRecoveryPointDetailsAsync(this.restoreRequest.BackupLocation, cancellationToken);
var retriveBackupDetails = backupDetails as RestorePoint;
if (retriveBackupDetails == null)
{
throw new FabricException(StringResources.RestoreDetailsFetchFailed, FabricErrorCode.RestoreSafeCheckFailed);
}
if (!retriveBackupDetails.BackupId.Equals(this.restoreRequest.BackupId))
{
/*
* Add validation here for the request
*/
throw new FabricException(StringResources.BackupIdAndLocationMismatch,
FabricErrorCode.RestoreSourceTargetPartitionMismatch);
}
var backupServicePartitionInformation = retriveBackupDetails.PartitionInformation;
var servicePartitionInformation = await FabricClientHelper.GetPartitionDetails(partitionId, timeout, cancellationToken);
switch (servicePartitionInformation.Kind)
{
case ServicePartitionKind.Int64Range:
var int64RangePartitionInformation = servicePartitionInformation as System.Fabric.Int64RangePartitionInformation;
var backupInt64RangePartitionInformation = backupServicePartitionInformation as BackupRestoreTypes.Int64RangePartitionInformation;
if (backupInt64RangePartitionInformation == null ||
backupInt64RangePartitionInformation.HighKey != int64RangePartitionInformation.HighKey ||
backupInt64RangePartitionInformation.LowKey != int64RangePartitionInformation.LowKey)
{
throw new FabricException(StringResources.InvalidInt64Keys,
FabricErrorCode.RestoreSourceTargetPartitionMismatch);
}
break;
case ServicePartitionKind.Named:
var namedPartitionInformation = servicePartitionInformation as System.Fabric.NamedPartitionInformation;
var backupNamedPartitionInformation = backupServicePartitionInformation as BackupRestoreTypes.NamedPartitionInformation;
if (backupNamedPartitionInformation == null ||
!namedPartitionInformation.Name.Equals(backupNamedPartitionInformation.Name))
{
throw new FabricException(StringResources.InvalidNameKey,
FabricErrorCode.RestoreSourceTargetPartitionMismatch);
}
break;
case ServicePartitionKind.Singleton:
var backupSingletonPartitionInformation = backupServicePartitionInformation as BackupRestoreTypes.SingletonPartitionInformation;
if (backupSingletonPartitionInformation == null)
{
throw new FabricException(StringResources.InvalidPartitionType,
FabricErrorCode.RestoreSourceTargetPartitionMismatch);
}
break;
}
var backupLocations =
await recoveryPointManager.GetBackupLocationsInBackupChainAsync(this.restoreRequest.BackupLocation, cancellationToken);
var dataLossGuid = Guid.NewGuid();
var restoreRequestGuid = Guid.NewGuid();
var restoreStatus = new RestoreStatus(fabricUri, backupStorage, restoreRequestGuid, dataLossGuid, backupLocations, retriveBackupDetails);
var restoreWorkItem = new RestorePartitionWorkItem(serviceNameUri, partitionId, restoreRequestGuid, dataLossGuid, this.restoreTimeoutInMinutes);
using (var transaction = this.StatefulService.StateManager.CreateTransaction())
{
await this.CheckForEitherBackupOrRestoreInProgress(fabricUri, timeout, cancellationToken, transaction);
await this.WorkItemQueue.AddWorkItem(restoreWorkItem, timeout, cancellationToken, transaction);
await this.RestoreStore.AddOrUpdateAsync(fabricUri, restoreStatus,
(fabricUri1, restoreStatus1) => restoreStatus, timeout, cancellationToken, transaction);
await transaction.CommitAsync();
}
return(new HttpResponseMessage(HttpStatusCode.Accepted));
}
internal override async Task <HttpResponseMessage> RunAsync(TimeSpan timeout, CancellationToken cancellationToken)
{
string applicationNameUri;
string serviceNameUri;
string partitionId;
var fabricUri = await UtilityHelper.GetFabricUriFromRequstHeader(this.fabricRequestHeader, timeout, cancellationToken);
WorkItem workItem = null;
FabricBackupResourceType fabricBackupResourceType =
UtilityHelper.GetApplicationAndServicePartitionUri(fabricUri, out applicationNameUri, out serviceNameUri,
out partitionId);
bool isApplicationOrServiceExisting;
switch (fabricBackupResourceType)
{
case FabricBackupResourceType.ApplicationUri:
isApplicationOrServiceExisting =
await this.IsApplicationOrServiceExisting(fabricBackupResourceType, applicationNameUri, null, timeout, cancellationToken);
if (isApplicationOrServiceExisting)
{
workItem = new ResolveToPartitionWorkItem(FabricBackupResourceType.ApplicationUri,
applicationNameUri,
new WorkItemInfo
{
WorkItemType = WorkItemPropogationType.Disable,
});
}
break;
case FabricBackupResourceType.ServiceUri:
isApplicationOrServiceExisting =
await this.IsApplicationOrServiceExisting(fabricBackupResourceType, serviceNameUri, null, timeout, cancellationToken);
if (isApplicationOrServiceExisting)
{
workItem = new ResolveToPartitionWorkItem(FabricBackupResourceType.ServiceUri, serviceNameUri,
new WorkItemInfo
{
WorkItemType = WorkItemPropogationType.Disable,
});
}
break;
case FabricBackupResourceType.PartitionUri:
isApplicationOrServiceExisting =
await this.IsApplicationOrServiceExisting(fabricBackupResourceType, serviceNameUri, partitionId, timeout, cancellationToken);
if (isApplicationOrServiceExisting)
{
serviceNameUri =
await
FabricClientHelper.GetFabricServiceUriFromPartitionId(partitionId, timeout,
cancellationToken);
workItem = new SendToServiceNodeWorkItem(serviceNameUri, partitionId,
new WorkItemInfo
{
WorkItemType = WorkItemPropogationType.Disable,
});
}
break;
case FabricBackupResourceType.Error:
throw new ArgumentException(StringResources.InvalidArguments);
}
if (workItem == null)
{
using (var transaction = this.StatefulService.StateManager.CreateTransaction())
{
var backupMapping = await this.BackupMappingStore.GetValueWithUpdateLockModeAsync(fabricUri, timeout, cancellationToken, transaction);
if (backupMapping == null)
{
throw new FabricPeriodicBackupNotEnabledException();
}
var assignedBackupPolicy =
await this.BackupPolicyStore.GetValueWithUpdateLockModeAsync(backupMapping.BackupPolicyName, timeout,
cancellationToken, transaction);
await this.BackupMappingStore.DeleteValueAsync(fabricUri, timeout, cancellationToken, transaction);
await this.BackupPolicyStore.RemoveProtectionEntity(assignedBackupPolicy, fabricUri, timeout, cancellationToken, transaction);
await transaction.CommitAsync();
}
}
else
{
RetentionManager retentionManager = await RetentionManager.CreateOrGetRetentionManager(this.StatefulService);
using (var transaction = this.StatefulService.StateManager.CreateTransaction())
{
var backupMapping = await this.BackupMappingStore.GetValueWithUpdateLockModeAsync(fabricUri, timeout, cancellationToken, transaction);
if (backupMapping == null)
{
throw new FabricPeriodicBackupNotEnabledException();
}
var assignedBackupPolicy = await this.BackupPolicyStore.GetValueWithUpdateLockModeAsync(backupMapping.BackupPolicyName, timeout,
cancellationToken, transaction);
await this.BackupMappingStore.DeleteValueAsync(fabricUri, timeout, cancellationToken, transaction);
await this.BackupPolicyStore.RemoveProtectionEntity(assignedBackupPolicy, fabricUri, timeout, cancellationToken, transaction);
await this.WorkItemQueue.AddWorkItem(workItem, timeout, cancellationToken, transaction);
if (cleanBackups)
{
await retentionManager.DisablePolicyAsync(fabricUri, backupMapping, timeout, cancellationToken, transaction);
}
await transaction.CommitAsync();
}
}
return(new HttpResponseMessage(HttpStatusCode.Accepted));
}
