internal override async Task <HttpResponseMessage> RunAsync(TimeSpan timeout, CancellationToken cancellationToken)
{
this.ThrowInvalidArgumentIfNull(this.backupPolicy);
if (string.IsNullOrEmpty(this.backupPolicyName))
{
throw new ArgumentException();
}
var workItemQueue = await WorkItemQueue.CreateOrGetWorkItemQueue(this.StatefulService);
var modelBackupPolicy = BackupPolicyModel.FromBackupPolicyView(this.backupPolicy);
var policyBuilder = modelBackupPolicy.ToBuilder()
.WithName(this.backupPolicyName);
RetentionManager retentionManager = await RetentionManager.CreateOrGetRetentionManager(this.StatefulService);
using (var transaction = this.StatefulService.StateManager.CreateTransaction())
{
var existingBackupPolicy = await this.BackupPolicyStore.GetValueWithUpdateLockModeAsync(this.backupPolicyName, timeout, cancellationToken, transaction);
if (existingBackupPolicy == null)
{
throw new FabricException(StringResources.BackupPolicyDoesNotExist, FabricErrorCode.BackupPolicyDoesNotExist);
}
var existingEnablementSet = existingBackupPolicy.BackupEnabledSet;
policyBuilder.WithBackupEnabledSet(existingEnablementSet);
var updatedBackupPolicy = policyBuilder.Build();
await this.BackupPolicyStore.UpdateValueAsync(this.backupPolicyName, existingBackupPolicy, updatedBackupPolicy, timeout, cancellationToken, transaction);
if (existingEnablementSet.Count > 0)
{
await
workItemQueue.AddWorkItem(
new UpdateEnablementWorkItem(existingEnablementSet.ToList(),
new WorkItemInfo {
WorkItemType = WorkItemPropogationType.UpdateBackupPolicy,
BackupPolicyUpdateGuid = updatedBackupPolicy.UniqueId
} ), timeout, cancellationToken, transaction);
}
await retentionManager.UpdatePolicyAsync(this.backupPolicyName, timeout, cancellationToken, transaction);
await transaction.CommitAsync();
}
return(new HttpResponseMessage(HttpStatusCode.OK));
}
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));
}
