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)); }