/// <summary>
/// Gets Invoked When a policy is created.
/// </summary>
/// <returns></returns>
internal async Task CreatePolicyAsync(BackupPolicy backupPolicy, TimeSpan timeout, CancellationToken cancellationToken, ITransaction transaction)
{
// create a metadata and initialise the RetentionMetadata.
BackupRestoreTrace.TraceSource.WriteInfo(TraceType, "Scheduling retention for backupPolicy : {0}", backupPolicy.Name);
RetentionPolicy retentionPolicy = backupPolicy.RetentionPolicy;
if (null == retentionPolicy)
{
// there is nothing to be done.
BackupRestoreTrace.TraceSource.WriteInfo(TraceType, "RetentionPolicy for backupPolicy : {0} is not defined.", backupPolicy.Name);
}
else
{
RetentionMetadata retentionMetadata = new RetentionMetadata(backupPolicy.RetentionPolicy);
await this.RetentionStore.AddAsync(backupPolicy.Name, retentionMetadata, timeout, cancellationToken, transaction);
RetentionScheduler retentionScheduler = new RetentionScheduler(backupPolicy.Name, backupPolicy.RetentionPolicy, timerCallback);
if (!RetentionSchedulerDict.TryAdd(backupPolicy.Name, retentionScheduler))
{
BackupRestoreTrace.TraceSource.WriteError(TraceType, "CreatePolicyAsync: Not able to add retention scheduler for backupPolicy : {0}", backupPolicy.Name);
throw new InvalidOperationException(string.Format("{0}: Key already exists ", backupPolicy.Name));
}
retentionScheduler.ArmTimer(retentionMetadata);
}
}
/// <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 async Task CleanUpTask(string partitionId, BackupPolicy backupPolicy, CancellationToken cancellationToken)
{
// Update the cleanUpStore to add the partition in partition list.
List <string> partitionList = await this.CleanupStore.GetValueAsync(backupPolicy.Name, this.timeout, cancellationToken);
await DeleteFilesForPartition(partitionId, DateTime.UtcNow, 0, backupPolicy.Storage, backupPolicy.Name, true);
// Since, the files are deleted, update the cleanup store.
partitionList = await this.CleanupStore.GetValueAsync(backupPolicy.Name, this.timeout, cancellationToken);
partitionList.Remove(partitionId);
await this.CleanupStore.UpdateValueAsync(backupPolicy.Name, partitionList, this.timeout, cancellationToken, null);
}
private static BackupPolicy CreateBackupPolicy(string location, string name = "")
{
// Create basic policy records with a selection of data
BackupPolicy testBackupPolicy = new BackupPolicy(location: location, name: name)
{
Enabled = true,
DailyBackupsToKeep = 4,
WeeklyBackupsToKeep = 3,
MonthlyBackupsToKeep = 2
};
return(testBackupPolicy);
}
public PSBackupPolicy(BackupPolicy backupPolicy)
{
if (backupPolicy is PeriodicModeBackupPolicy)
{
PeriodicModeBackupPolicy periodicModeBackupPolicy = backupPolicy as PeriodicModeBackupPolicy;
BackupIntervalInMinutes = periodicModeBackupPolicy.PeriodicModeProperties.BackupIntervalInMinutes;
BackupRetentionIntervalInHours = periodicModeBackupPolicy.PeriodicModeProperties.BackupRetentionIntervalInHours;
BackupType = PeriodicModeBackupType;
}
else
{
return;
}
}
public PSBackupPolicy(BackupPolicy backupPolicy)
{
if (backupPolicy is PeriodicModeBackupPolicy)
{
PeriodicModeBackupPolicy periodicModeBackupPolicy = backupPolicy as PeriodicModeBackupPolicy;
BackupIntervalInMinutes = periodicModeBackupPolicy.PeriodicModeProperties.BackupIntervalInMinutes;
BackupRetentionIntervalInHours = periodicModeBackupPolicy.PeriodicModeProperties.BackupRetentionIntervalInHours;
BackupType = PeriodicModeBackupType;
BackupStorageRedundancy = periodicModeBackupPolicy.PeriodicModeProperties.BackupStorageRedundancy;
}
else if (backupPolicy is ContinuousModeBackupPolicy)
{
BackupType = ContinuousModeBackupType;
}
}
internal async Task CleanUpTaskUtil(string partitionId, BackupPolicy backupPolicy)
{
try
{
BackupRestoreTrace.TraceSource.WriteInfo(TraceType, " Running CleanUp task for partitionId : {0} and backupPolicy: {1}", partitionId, backupPolicy.Name);
await IntroduceRandomDelay();
RetentionMetadata retentionMetadata = await this.RetentionStore.GetValueAsync(backupPolicy.Name, this.timeout, this.tokenSource.Token);
Func <bool> condition = () =>
{
if (retentionMetadata == null || retentionMetadata.LastRetentionStartTime == DateTime.MinValue || retentionMetadata.LastRetentionCompletionTime > retentionMetadata.LastRetentionStartTime ||
!retentionMetadata.OnGoingRetentionFile.ContainsKey(partitionId))
{
return(true);
}
return(false);
};
bool cleanUpComplete = await BackupRestoreUtility.TryPerformOperationWithWaitAsync(
(partition, token) =>
{
return(CleanUpTask(partition, backupPolicy, token));
}, condition, partitionId,
this.tokenSource.Token,
minimumWaitTimeForRetryOperationInMs,
maxRetryCountForCleanup,
maximumWaitTimeForCleanUpRetryOperationInMs
);
if (!cleanUpComplete)
{
BackupRestoreTrace.TraceSource.WriteWarning(TraceType, " CleanUp task for partitionId : {0} and backupPolicy : {1} was not completed." +
"It could be because retention of the partition was going on from a long time which did not complete 40 seconds.", partitionId, backupPolicy.Name);
}
}
catch (Exception ex)
{
if (ex is OperationCanceledException)
{
BackupRestoreTrace.TraceSource.WriteWarning(TraceType, " CleanUp task for partitionId : {0} and backupPolicy : {1} is canceled", partitionId, backupPolicy.Name);
}
else
{
BackupRestoreTrace.TraceSource.WriteError(TraceType, " CleanUp task for partitionId : {0} and backupPolicy : {1} has thrown an exception : {2}", partitionId, backupPolicy.Name, ex);
}
}
}
internal BackupTimer(BackupMetadata metadata, Action timerCallback)
{
this.policy = metadata.Policy;
this.backupMetadata = metadata;
backupTimer = new BRSTimer(timerCallback);
if (metadata.Policy.PolicyType == BackupPolicyType.ScheduleBased)
{
// Order the time of day and day of week lists
var derivedPolicy = (ScheduleBasedBackupPolicy)metadata.Policy;
derivedPolicy.RunTimes = derivedPolicy.RunTimes.OrderBy(t => t).ToList();
derivedPolicy.RunDays = derivedPolicy.RunDays.OrderBy(t => t).ToList();
}
LoadJiterConfig();
}
private async Task AddPartitionToCleanUpStore(string partitionId, BackupPolicy backupPolicy, CancellationToken cancellationToken, ITransaction transaction)
{
// There should only be one callers of this function(Only from disable).
List <string> partitionList = await this.CleanupStore.GetValueAsync(backupPolicy.Name, this.timeout, cancellationToken, transaction);
if (partitionList != null && partitionList.Contains(partitionId))
{
// Cleanup Task is already running.
return;
}
if (partitionList == null)
{
partitionList = new List <string>();
}
partitionList.Add(partitionId);
await this.CleanupStore.UpdateValueAsync(backupPolicy.Name, partitionList, this.timeout, cancellationToken, transaction);
}
NativeCommon.IFabricAsyncOperationContext NativeBackupRestoreRuntime.IFabricBackupRestoreHandler.BeginUpdateBackupSchedulePolicy(IntPtr backupPolicy, uint timeoutMilliseconds, NativeCommon.IFabricAsyncOperationCallback callback)
{
var managedTimout = TimeSpan.FromMilliseconds(timeoutMilliseconds);
BackupPolicy managedPolicy = null;
if (backupPolicy != IntPtr.Zero)
{
managedPolicy = BackupPolicy.FromNative(backupPolicy);
}
return(Utility.WrapNativeAsyncMethodImplementation(
cancellationToken =>
this.Handler.UpdateBackupSchedulingPolicyAsync(
managedPolicy,
managedTimout,
cancellationToken),
callback,
"BackupRestoreBroker.BeginUpdateBackupSchedulePolicy",
ThreadErrorMessageSetter));
}
/// <summary>
/// Helper method to create backup policy for a given set of volumes.
/// </summary>
private BackupPolicy CreateBackupPolicy(string deviceName, string name, IList <string> volumeIds)
{
var bp = new BackupPolicy()
{
Kind = Kind.Series8000,
VolumeIds = volumeIds
};
var backupPolicy = this.Client.BackupPolicies.CreateOrUpdate(
deviceName.GetDoubleEncoded(),
name.GetDoubleEncoded(),
bp,
this.ResourceGroupName,
this.ManagerName);
Assert.NotNull(backupPolicy);
Assert.Equal(backupPolicy.SchedulesCount, 0);
List <string> scheduleNames = new List <string>()
{
"schedule1",
"schedule2",
};
// Create a backup schedule
BackupSchedule bs1 = CreateBackupSchedule(deviceName, backupPolicy.Name, scheduleNames.ElementAt(0), RecurrenceType.Daily, TestConstants.Schedule1StartTime);
BackupSchedule bs2 = CreateBackupSchedule(deviceName, backupPolicy.Name, scheduleNames.ElementAt(1), RecurrenceType.Weekly, TestConstants.Schedule2StartTime);
//validate one of the schedules
var schedule = this.Client.BackupSchedules.Get(
deviceName.GetDoubleEncoded(),
backupPolicy.Name.GetDoubleEncoded(),
scheduleNames.First().GetDoubleEncoded(),
this.ResourceGroupName,
this.ManagerName);
Assert.True(schedule != null && schedule.Name.Equals(scheduleNames.First()) &&
schedule.ScheduleRecurrence.RecurrenceType.Equals(RecurrenceType.Daily), "Schedule creation was not successful.");
return(backupPolicy);
}
internal DatabaseAccountData(ResourceIdentifier id, string name, ResourceType resourceType, SystemData systemData, IDictionary <string, string> tags, AzureLocation location, DatabaseAccountKind?kind, ManagedServiceIdentity identity, string provisioningState, string documentEndpoint, string databaseAccountOfferType, IList <IPAddressOrRange> ipRules, bool?isVirtualNetworkFilterEnabled, bool?enableAutomaticFailover, ConsistencyPolicy consistencyPolicy, IList <DatabaseAccountCapability> capabilities, IReadOnlyList <DatabaseAccountLocation> writeLocations, IReadOnlyList <DatabaseAccountLocation> readLocations, IReadOnlyList <DatabaseAccountLocation> locations, IReadOnlyList <FailoverPolicy> failoverPolicies, IList <VirtualNetworkRule> virtualNetworkRules, IReadOnlyList <CosmosDBPrivateEndpointConnectionData> privateEndpointConnections, bool?enableMultipleWriteLocations, bool?enableCassandraConnector, ConnectorOffer?connectorOffer, bool?disableKeyBasedMetadataWriteAccess, Uri keyVaultKeyUri, string defaultIdentity, PublicNetworkAccess?publicNetworkAccess, bool?enableFreeTier, ApiProperties apiProperties, bool?enableAnalyticalStorage, AnalyticalStorageConfiguration analyticalStorageConfiguration, string instanceId, CreateMode?createMode, RestoreParameters restoreParameters, BackupPolicy backupPolicy, IList <CorsPolicy> cors, NetworkAclBypass?networkAclBypass, IList <string> networkAclBypassResourceIds, bool?disableLocalAuth, Capacity capacity) : base(id, name, resourceType, systemData, tags, location)
{
Kind = kind;
Identity = identity;
ProvisioningState = provisioningState;
DocumentEndpoint = documentEndpoint;
DatabaseAccountOfferType = databaseAccountOfferType;
IPRules = ipRules;
IsVirtualNetworkFilterEnabled = isVirtualNetworkFilterEnabled;
EnableAutomaticFailover = enableAutomaticFailover;
ConsistencyPolicy = consistencyPolicy;
Capabilities = capabilities;
WriteLocations = writeLocations;
ReadLocations = readLocations;
Locations = locations;
FailoverPolicies = failoverPolicies;
VirtualNetworkRules = virtualNetworkRules;
PrivateEndpointConnections = privateEndpointConnections;
EnableMultipleWriteLocations = enableMultipleWriteLocations;
EnableCassandraConnector = enableCassandraConnector;
ConnectorOffer = connectorOffer;
DisableKeyBasedMetadataWriteAccess = disableKeyBasedMetadataWriteAccess;
KeyVaultKeyUri = keyVaultKeyUri;
DefaultIdentity = defaultIdentity;
PublicNetworkAccess = publicNetworkAccess;
EnableFreeTier = enableFreeTier;
ApiProperties = apiProperties;
EnableAnalyticalStorage = enableAnalyticalStorage;
AnalyticalStorageConfiguration = analyticalStorageConfiguration;
InstanceId = instanceId;
CreateMode = createMode;
RestoreParameters = restoreParameters;
BackupPolicy = backupPolicy;
Cors = cors;
NetworkAclBypass = networkAclBypass;
NetworkAclBypassResourceIds = networkAclBypassResourceIds;
DisableLocalAuth = disableLocalAuth;
Capacity = capacity;
}
public void CreateBackupPolicyTest()
{
StatefulServiceContext statefulServiceContext = new StatefulServiceContext();
var mockStatefulService = new Mock <StatefulService>();
mockStatefulService.SetupGet <IReliableStateManager>((mockStatefulService1) =>
mockStatefulService1.StateManager
).Returns(new MockIReliableStateManager());
BackupPolicy backupPolicy = new BackupPolicy {
BackupPolicyName = "SampleBackupPolicy1"
};
ControllerSetting controllerSetting = new ControllerSetting(mockStatefulService.Object, new CancellationToken());
BackupPolicyController backupPolicyController = new BackupPolicyController(controllerSetting);
backupPolicyController.AddBackupPolicy(backupPolicy).Wait();
BackupPolicy queryBackupPolicy = backupPolicyController.GetBackupPolicyByName(backupPolicy.BackupPolicyName).Result;
if (queryBackupPolicy.Equals(backupPolicy))
{
Assert.Equals(queryBackupPolicy, backupPolicy);
}
}
private NativeCommon.IFabricAsyncOperationContext UpdateBackupSchedulePolicyBeginWrapper(
Uri serviceName,
Guid partitionId,
BackupPolicy policy,
TimeSpan timeout,
NativeCommon.IFabricAsyncOperationCallback callback)
{
var timeoutMilliseconds = Utility.ToMilliseconds(timeout, "timeout");
var partitionInfo = new BackupPartitionInfo
{
PartitionId = partitionId,
ServiceName = serviceName.ToString(),
};
using (var pin = new PinCollection())
{
return(this._nativeAgent.BeginUpdateBackupSchedulePolicy(
partitionInfo.ToNative(pin),
policy == null ? IntPtr.Zero : policy.ToNative(pin),
timeoutMilliseconds,
callback));
}
}
/// <summary>
/// Create a backup policy
/// </summary>
/// <remarks>
/// Create a backup policy for Netapp Account
/// </remarks>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group.
/// </param>
/// <param name='accountName'>
/// The name of the NetApp account
/// </param>
/// <param name='backupPolicyName'>
/// Backup policy Name which uniquely identify backup policy.
/// </param>
/// <param name='body'>
/// Backup policy object supplied in the body of the operation.
/// </param>
public static BackupPolicy BeginCreate(this IBackupPoliciesOperations operations, string resourceGroupName, string accountName, string backupPolicyName, BackupPolicy body)
{
return(operations.BeginCreateAsync(resourceGroupName, accountName, backupPolicyName, body).GetAwaiter().GetResult());
}
public async Task <HttpResponseMessage> UpdateBackupPolicyByName([FromBody] BackupPolicy backupPolicy, string backupPolicyName, [FromUri(Name = "api-version")] string apiVersion = "0.0", [FromUri] int timeout = 60)
{
return(await this.RunAsync(new UpdateBackupPolicyOperation(backupPolicyName, backupPolicy, apiVersion, this.statefulService), timeout));
}
public GetBackupSchedulePolicyResult(BackupPolicy policy)
{
this.policy = policy;
}
internal UpdateBackupPolicyOperation(string backupPolicyName, BackupPolicy backupPolicy, string apiVersion, StatefulService statefulService) : base(apiVersion, statefulService)
{
this.backupPolicy = backupPolicy;
this.backupPolicyName = backupPolicyName;
}
/// <summary>
/// Gets called when a policy is updated
/// </summary>
internal async Task UpdatePolicyAsync(string backupPolicyName, TimeSpan timeout, CancellationToken cancellationToken, ITransaction transaction)
{
/**
* Cases:
* 1. UpdateRetention ----> Re-arm the timer.
* 0. Add Retention.
* a. Remove retention --> dispose the timer.
* b. update the retention.
* 2. UpdateStorage ---->
* 3. Update Backup Schedule. --> no need to do anything/
*
*/
try
{
BackupRestoreTrace.TraceSource.WriteInfo(TraceType, " In UpdatePolicyAsync of Retention Manager for Backup policy: {0}", backupPolicyName);
var backupPolicyStore = await BackupPolicyStore.CreateOrGetBackupPolicyStore(this.StatefulService);
RetentionMetadata retentionMetadata = await this.RetentionStore.GetValueAsync(backupPolicyName, timeout, cancellationToken, transaction);
BackupPolicy backupPolicy = await backupPolicyStore.GetValueAsync(backupPolicyName, timeout, cancellationToken, transaction);
if (retentionMetadata == null)
{
if (backupPolicy.RetentionPolicy != null)
{
retentionMetadata = new RetentionMetadata(backupPolicy.RetentionPolicy);
await this.RetentionStore.AddAsync(backupPolicyName, retentionMetadata, timeout, cancellationToken, transaction);
RetentionScheduler retentionScheduler = new RetentionScheduler(backupPolicy.Name, backupPolicy.RetentionPolicy, timerCallback);
// Here we have updated the policy to introduce retention.
retentionScheduler.ArmTimer(retentionMetadata, true);
if (!RetentionSchedulerDict.TryAdd(backupPolicyName, retentionScheduler))
{
// If we are not able to add retention in RetentionSchedulerDict then, stop timer in retention scheduler
retentionScheduler.Stop();
BackupRestoreTrace.TraceSource.WriteWarning(TraceType, "UpdatePolicyAsync, Not able to add retentionScheduler to dict for policy : {0} ", backupPolicyName);
throw new InvalidOperationException(string.Format("{0}: Key already exists.", backupPolicyName));
}
}
}
else if (backupPolicy.RetentionPolicy == null)
{
// need to remove the retentionScheduler from RetentionStore.
Func <bool> condition = () =>
{
if (retentionMetadata.LastRetentionCompletionTime > retentionMetadata.LastRetentionStartTime || retentionMetadata.LastRetentionStartTime == DateTime.MinValue)
{
return(true);
}
return(false);
};
bool disposeComplete = await BackupRestoreUtility.TryPerformOperationWithWaitAsync(
(policyName, token) =>
{
return(DisposeRetentionScheduler(policyName, timeout, token, transaction));
},
condition,
backupPolicyName,
cancellationToken,
minimumWaitTimeForRetryOperationInMs,
maxRetryCountForDisposingRetention,
minimumWaitTimeForRetryOperationInMs);
if (!disposeComplete)
{
BackupRestoreTrace.TraceSource.WriteError(TraceType, "Dispose retention did not complete for {0}", backupPolicyName);
throw new FabricBackupRestoreLocalRetryException();
}
}
else
{
if (retentionMetadata.UpdateRetentionPolicyMetadata(backupPolicy.RetentionPolicy))
{
// Update the retention Scheduler store and arm the timer.
RetentionScheduler retentionScheduler;
if (!RetentionSchedulerDict.TryGetValue(backupPolicyName, out retentionScheduler))
{
BackupRestoreTrace.TraceSource.WriteError(TraceType, "UpdateBackupPolicy: Not able to get retention scheduler for backupPolicy {0}", backupPolicyName);
throw new KeyNotFoundException();
}
retentionScheduler.RearmTimer(false, retentionMetadata);
await this.RetentionStore.UpdateValueAsync(backupPolicyName, retentionMetadata, timeout, cancellationToken, transaction);
}
}
}
catch (Exception ex)
{
if (ex is OperationCanceledException)
{
BackupRestoreTrace.TraceSource.WriteWarning(TraceType, " DisposeRetentionScheduler ended with Timeout as the operation was cencelled: {0}", backupPolicyName);
BackupRestoreTrace.TraceSource.WriteWarning(TraceType, " It could be because the retention was in progress and user tried to remove the retention policy during UpdatePolicy: {0}", backupPolicyName);
}
else
{
// Check for the exceptions of DisposeRetentionScheduler Timeout Retries.
BackupRestoreTrace.TraceSource.WriteError(TraceType, " UpdateBackupPolicy resulted in the exception : {0}", backupPolicyName);
}
throw;
}
}
/// <summary>
/// Creates or updates the backup policy.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='deviceName'>
/// The device name
/// </param>
/// <param name='backupPolicyName'>
/// The name of the backup policy to be created/updated.
/// </param>
/// <param name='parameters'>
/// The backup policy.
/// </param>
/// <param name='resourceGroupName'>
/// The resource group name
/// </param>
/// <param name='managerName'>
/// The manager name
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <BackupPolicy> BeginCreateOrUpdateAsync(this IBackupPoliciesOperations operations, string deviceName, string backupPolicyName, BackupPolicy parameters, string resourceGroupName, string managerName, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.BeginCreateOrUpdateWithHttpMessagesAsync(deviceName, backupPolicyName, parameters, resourceGroupName, managerName, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <summary>
/// Create a backup policy
/// </summary>
/// <remarks>
/// Create a backup policy for Netapp Account
/// </remarks>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group.
/// </param>
/// <param name='accountName'>
/// The name of the NetApp account
/// </param>
/// <param name='backupPolicyName'>
/// Backup policy Name which uniquely identify backup policy.
/// </param>
/// <param name='body'>
/// Backup policy object supplied in the body of the operation.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <BackupPolicy> BeginCreateAsync(this IBackupPoliciesOperations operations, string resourceGroupName, string accountName, string backupPolicyName, BackupPolicy body, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.BeginCreateWithHttpMessagesAsync(resourceGroupName, accountName, backupPolicyName, body, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
private static void CreateDcsInstance(DcsClient dcsClient)
{
List <String> azCodes = new List <string>();
azCodes.Add("cn-north-7b");
List <int?> backupAt = new List <int?>();
backupAt.Add(1);
backupAt.Add(2);
backupAt.Add(3);
backupAt.Add(4);
backupAt.Add(5);
backupAt.Add(6);
backupAt.Add(7);
var backupPlan = new BackupPlan()
{
BackupAt = backupAt,
BeginAt = "16:00-17:00",
PeriodType = "weekly"
};
var backupPolicy = new BackupPolicy()
{
BackupType = "auto",
PeriodicalBackupPlan = backupPlan,
SaveDays = 7
};
var createDcsInstanceRequest = new CreateDCSInstanceRequest()
{
Body = new CreateInstanceBody()
{
Capacity = 2,
Name = "dcs_create_instance_test",
Engine = "Redis",
EngineVersion = "4.0",
NoPasswordAccess = true,
VpcId = "5e37b3be-950a-48e1-b498-65b63d336481",
SubnetId = "a4112635-3ec0-471c-95c3-5cf49b9533af",
SpecCode = "redis.ha.au1.large.2",
AzCodes = azCodes,
InstanceBackupPolicy = backupPolicy
}
};
try
{
var response = dcsClient.CreateDCSInstance(createDcsInstanceRequest);
Console.WriteLine(response.GetHttpBody());
}
catch (RequestTimeoutException requestTimeoutException)
{
Console.WriteLine(requestTimeoutException.ErrorMessage);
}
catch (ServiceResponseException clientRequestException)
{
Console.WriteLine(clientRequestException.HttpStatusCode);
Console.WriteLine(clientRequestException.ErrorCode);
Console.WriteLine(clientRequestException.ErrorMsg);
}
catch (ConnectionException connectionException)
{
Console.WriteLine(connectionException.ErrorMessage);
}
}
internal AddBackupPolicyOperation(BackupPolicy backupPolicy, string apiVersion, StatefulService statefulService) : base(apiVersion, statefulService)
{
this.backupPolicy = backupPolicy;
}
internal static DatabaseAccountData DeserializeDatabaseAccountData(JsonElement element)
{
Optional <DatabaseAccountKind> kind = default;
Optional <ManagedServiceIdentity> identity = default;
IDictionary <string, string> tags = default;
AzureLocation location = default;
ResourceIdentifier id = default;
string name = default;
ResourceType type = default;
SystemData systemData = default;
Optional <string> provisioningState = default;
Optional <string> documentEndpoint = default;
Optional <string> databaseAccountOfferType = default;
Optional <IList <IPAddressOrRange> > ipRules = default;
Optional <bool> isVirtualNetworkFilterEnabled = default;
Optional <bool> enableAutomaticFailover = default;
Optional <ConsistencyPolicy> consistencyPolicy = default;
Optional <IList <DatabaseAccountCapability> > capabilities = default;
Optional <IReadOnlyList <DatabaseAccountLocation> > writeLocations = default;
Optional <IReadOnlyList <DatabaseAccountLocation> > readLocations = default;
Optional <IReadOnlyList <DatabaseAccountLocation> > locations = default;
Optional <IReadOnlyList <FailoverPolicy> > failoverPolicies = default;
Optional <IList <VirtualNetworkRule> > virtualNetworkRules = default;
Optional <IReadOnlyList <PrivateEndpointConnectionData> > privateEndpointConnections = default;
Optional <bool> enableMultipleWriteLocations = default;
Optional <bool> enableCassandraConnector = default;
Optional <ConnectorOffer> connectorOffer = default;
Optional <bool> disableKeyBasedMetadataWriteAccess = default;
Optional <Uri> keyVaultKeyUri = default;
Optional <string> defaultIdentity = default;
Optional <PublicNetworkAccess> publicNetworkAccess = default;
Optional <bool> enableFreeTier = default;
Optional <ApiProperties> apiProperties = default;
Optional <bool> enableAnalyticalStorage = default;
Optional <AnalyticalStorageConfiguration> analyticalStorageConfiguration = default;
Optional <string> instanceId = default;
Optional <CreateMode> createMode = default;
Optional <RestoreParameters> restoreParameters = default;
Optional <BackupPolicy> backupPolicy = default;
Optional <IList <CorsPolicy> > cors = default;
Optional <NetworkAclBypass> networkAclBypass = default;
Optional <IList <string> > networkAclBypassResourceIds = default;
Optional <bool> disableLocalAuth = default;
Optional <Capacity> capacity = default;
foreach (var property in element.EnumerateObject())
{
if (property.NameEquals("kind"))
{
if (property.Value.ValueKind == JsonValueKind.Null)
{
property.ThrowNonNullablePropertyIsNull();
continue;
}
kind = new DatabaseAccountKind(property.Value.GetString());
continue;
}
if (property.NameEquals("identity"))
{
if (property.Value.ValueKind == JsonValueKind.Null)
{
property.ThrowNonNullablePropertyIsNull();
continue;
}
var serializeOptions = new JsonSerializerOptions {
Converters = { new ManagedServiceIdentityTypeV3Converter() }
};
identity = JsonSerializer.Deserialize <ManagedServiceIdentity>(property.Value.ToString(), serializeOptions);
continue;
}
if (property.NameEquals("tags"))
{
Dictionary <string, string> dictionary = new Dictionary <string, string>();
foreach (var property0 in property.Value.EnumerateObject())
{
dictionary.Add(property0.Name, property0.Value.GetString());
}
tags = dictionary;
continue;
}
if (property.NameEquals("location"))
{
location = property.Value.GetString();
continue;
}
if (property.NameEquals("id"))
{
id = new ResourceIdentifier(property.Value.GetString());
continue;
}
if (property.NameEquals("name"))
{
name = property.Value.GetString();
continue;
}
if (property.NameEquals("type"))
{
type = property.Value.GetString();
continue;
}
if (property.NameEquals("systemData"))
{
systemData = JsonSerializer.Deserialize <SystemData>(property.Value.ToString());
continue;
}
if (property.NameEquals("properties"))
{
if (property.Value.ValueKind == JsonValueKind.Null)
{
property.ThrowNonNullablePropertyIsNull();
continue;
}
foreach (var property0 in property.Value.EnumerateObject())
{
if (property0.NameEquals("provisioningState"))
{
provisioningState = property0.Value.GetString();
continue;
}
if (property0.NameEquals("documentEndpoint"))
{
documentEndpoint = property0.Value.GetString();
continue;
}
if (property0.NameEquals("databaseAccountOfferType"))
{
databaseAccountOfferType = property0.Value.GetString();
continue;
}
if (property0.NameEquals("ipRules"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
List <IPAddressOrRange> array = new List <IPAddressOrRange>();
foreach (var item in property0.Value.EnumerateArray())
{
array.Add(IPAddressOrRange.DeserializeIPAddressOrRange(item));
}
ipRules = array;
continue;
}
if (property0.NameEquals("isVirtualNetworkFilterEnabled"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
isVirtualNetworkFilterEnabled = property0.Value.GetBoolean();
continue;
}
if (property0.NameEquals("enableAutomaticFailover"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
enableAutomaticFailover = property0.Value.GetBoolean();
continue;
}
if (property0.NameEquals("consistencyPolicy"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
consistencyPolicy = ConsistencyPolicy.DeserializeConsistencyPolicy(property0.Value);
continue;
}
if (property0.NameEquals("capabilities"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
List <DatabaseAccountCapability> array = new List <DatabaseAccountCapability>();
foreach (var item in property0.Value.EnumerateArray())
{
array.Add(DatabaseAccountCapability.DeserializeDatabaseAccountCapability(item));
}
capabilities = array;
continue;
}
if (property0.NameEquals("writeLocations"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
List <DatabaseAccountLocation> array = new List <DatabaseAccountLocation>();
foreach (var item in property0.Value.EnumerateArray())
{
array.Add(DatabaseAccountLocation.DeserializeDatabaseAccountLocation(item));
}
writeLocations = array;
continue;
}
if (property0.NameEquals("readLocations"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
List <DatabaseAccountLocation> array = new List <DatabaseAccountLocation>();
foreach (var item in property0.Value.EnumerateArray())
{
array.Add(DatabaseAccountLocation.DeserializeDatabaseAccountLocation(item));
}
readLocations = array;
continue;
}
if (property0.NameEquals("locations"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
List <DatabaseAccountLocation> array = new List <DatabaseAccountLocation>();
foreach (var item in property0.Value.EnumerateArray())
{
array.Add(DatabaseAccountLocation.DeserializeDatabaseAccountLocation(item));
}
locations = array;
continue;
}
if (property0.NameEquals("failoverPolicies"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
List <FailoverPolicy> array = new List <FailoverPolicy>();
foreach (var item in property0.Value.EnumerateArray())
{
array.Add(FailoverPolicy.DeserializeFailoverPolicy(item));
}
failoverPolicies = array;
continue;
}
if (property0.NameEquals("virtualNetworkRules"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
List <VirtualNetworkRule> array = new List <VirtualNetworkRule>();
foreach (var item in property0.Value.EnumerateArray())
{
array.Add(VirtualNetworkRule.DeserializeVirtualNetworkRule(item));
}
virtualNetworkRules = array;
continue;
}
if (property0.NameEquals("privateEndpointConnections"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
List <PrivateEndpointConnectionData> array = new List <PrivateEndpointConnectionData>();
foreach (var item in property0.Value.EnumerateArray())
{
array.Add(PrivateEndpointConnectionData.DeserializePrivateEndpointConnectionData(item));
}
privateEndpointConnections = array;
continue;
}
if (property0.NameEquals("enableMultipleWriteLocations"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
enableMultipleWriteLocations = property0.Value.GetBoolean();
continue;
}
if (property0.NameEquals("enableCassandraConnector"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
enableCassandraConnector = property0.Value.GetBoolean();
continue;
}
if (property0.NameEquals("connectorOffer"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
connectorOffer = new ConnectorOffer(property0.Value.GetString());
continue;
}
if (property0.NameEquals("disableKeyBasedMetadataWriteAccess"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
disableKeyBasedMetadataWriteAccess = property0.Value.GetBoolean();
continue;
}
if (property0.NameEquals("keyVaultKeyUri"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
keyVaultKeyUri = null;
continue;
}
keyVaultKeyUri = new Uri(property0.Value.GetString());
continue;
}
if (property0.NameEquals("defaultIdentity"))
{
defaultIdentity = property0.Value.GetString();
continue;
}
if (property0.NameEquals("publicNetworkAccess"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
publicNetworkAccess = new PublicNetworkAccess(property0.Value.GetString());
continue;
}
if (property0.NameEquals("enableFreeTier"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
enableFreeTier = property0.Value.GetBoolean();
continue;
}
if (property0.NameEquals("apiProperties"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
apiProperties = ApiProperties.DeserializeApiProperties(property0.Value);
continue;
}
if (property0.NameEquals("enableAnalyticalStorage"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
enableAnalyticalStorage = property0.Value.GetBoolean();
continue;
}
if (property0.NameEquals("analyticalStorageConfiguration"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
analyticalStorageConfiguration = AnalyticalStorageConfiguration.DeserializeAnalyticalStorageConfiguration(property0.Value);
continue;
}
if (property0.NameEquals("instanceId"))
{
instanceId = property0.Value.GetString();
continue;
}
if (property0.NameEquals("createMode"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
createMode = new CreateMode(property0.Value.GetString());
continue;
}
if (property0.NameEquals("restoreParameters"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
restoreParameters = RestoreParameters.DeserializeRestoreParameters(property0.Value);
continue;
}
if (property0.NameEquals("backupPolicy"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
backupPolicy = BackupPolicy.DeserializeBackupPolicy(property0.Value);
continue;
}
if (property0.NameEquals("cors"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
List <CorsPolicy> array = new List <CorsPolicy>();
foreach (var item in property0.Value.EnumerateArray())
{
array.Add(CorsPolicy.DeserializeCorsPolicy(item));
}
cors = array;
continue;
}
if (property0.NameEquals("networkAclBypass"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
networkAclBypass = property0.Value.GetString().ToNetworkAclBypass();
continue;
}
if (property0.NameEquals("networkAclBypassResourceIds"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
List <string> array = new List <string>();
foreach (var item in property0.Value.EnumerateArray())
{
array.Add(item.GetString());
}
networkAclBypassResourceIds = array;
continue;
}
if (property0.NameEquals("disableLocalAuth"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
disableLocalAuth = property0.Value.GetBoolean();
continue;
}
if (property0.NameEquals("capacity"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
capacity = Capacity.DeserializeCapacity(property0.Value);
continue;
}
}
continue;
}
}
return(new DatabaseAccountData(id, name, type, systemData, tags, location, Optional.ToNullable(kind), identity, provisioningState.Value, documentEndpoint.Value, databaseAccountOfferType.Value, Optional.ToList(ipRules), Optional.ToNullable(isVirtualNetworkFilterEnabled), Optional.ToNullable(enableAutomaticFailover), consistencyPolicy.Value, Optional.ToList(capabilities), Optional.ToList(writeLocations), Optional.ToList(readLocations), Optional.ToList(locations), Optional.ToList(failoverPolicies), Optional.ToList(virtualNetworkRules), Optional.ToList(privateEndpointConnections), Optional.ToNullable(enableMultipleWriteLocations), Optional.ToNullable(enableCassandraConnector), Optional.ToNullable(connectorOffer), Optional.ToNullable(disableKeyBasedMetadataWriteAccess), keyVaultKeyUri.Value, defaultIdentity.Value, Optional.ToNullable(publicNetworkAccess), Optional.ToNullable(enableFreeTier), apiProperties.Value, Optional.ToNullable(enableAnalyticalStorage), analyticalStorageConfiguration.Value, instanceId.Value, Optional.ToNullable(createMode), restoreParameters.Value, backupPolicy.Value, Optional.ToList(cors), Optional.ToNullable(networkAclBypass), Optional.ToList(networkAclBypassResourceIds), Optional.ToNullable(disableLocalAuth), capacity.Value));
}
/// <summary>
/// Gets invoked when the RetentionScheduler's timer's time is elapsed
/// </summary>
internal void timerCallback(string backupPolicyName)
{
RetentionScheduler retentionScheduler;
if (!RetentionSchedulerDict.TryGetValue(backupPolicyName, out retentionScheduler))
{
BackupRestoreTrace.TraceSource.WriteWarning(TraceType, "RetentionScheduler object is not found in retentionScheduler dict for policy: {0}", backupPolicyName);
return;
}
bool toRearm = true;
RetentionMetadata retentionMetadata = this.RetentionStore.GetValueAsync(backupPolicyName, this.timeout, this.tokenSource.Token).GetAwaiter().GetResult();
try
{
BackupRestoreTrace.TraceSource.WriteInfo(TraceType, " TimerCallback running for backupPolicy : {0}", backupPolicyName);
var backupPolicyStore = BackupPolicyStore.CreateOrGetBackupPolicyStore(this.StatefulService).GetAwaiter().GetResult();
BackupPolicy backupPolicy = backupPolicyStore.GetValueAsync(backupPolicyName, this.timeout, this.tokenSource.Token).GetAwaiter().GetResult();
if (backupPolicy == null)
{
/**
* This is used to garbage collect the retention scheduler. It could happen while deleting\updating policy retention scheduler object was not
* stopped properly. So, timer will call its callback again just to find that the backup policy does not exists.
* In this case, we should stop the retentionScheduler.
* **/
RetentionScheduler retentionSchedulerToDelete;
if (RetentionSchedulerDict.TryRemove(backupPolicyName, out retentionSchedulerToDelete))
{
retentionSchedulerToDelete.Stop();
}
else
{
BackupRestoreTrace.TraceSource.WriteInfo(TraceType, "TimerCallback TryRemove retentionSchedulerDict failed of policy {0}. It could happen" +
" when residual callback already scheduled on threadpool thread is getting invoked.", backupPolicyName);
}
toRearm = false;
return;
}
HashSet <string> partitionsEnabledByPolicy = FindParititionsEnabledByPolicy(backupPolicy).GetAwaiter().GetResult();
retentionMetadata.UpdateLastRetentionStartTime();
this.RetentionStore.UpdateValueAsync(backupPolicyName, retentionMetadata, this.timeout, this.tokenSource.Token, null).GetAwaiter().GetResult();
var derivedRetentionPolicy = (BasicRetentionPolicy)retentionMetadata.CurrentRetentionPolicy;
TimeSpan retentionDuration = derivedRetentionPolicy.RetentionDuration;
int minimumNumberOfBackups = derivedRetentionPolicy.MinimumNumberOfBackups;
foreach (var partitionId in partitionsEnabledByPolicy)
{
BackupRestoreTrace.TraceSource.WriteInfo(TraceType, " Deleting backups for partitionId : {0}", partitionId);
List <string> partitionList = this.CleanupStore.GetValueAsync(backupPolicyName, this.timeout, this.tokenSource.Token).GetAwaiter().GetResult();
if (!(partitionList == null || partitionList.Count == 0) && partitionList.Contains(partitionId))
{
// Cleanup is going on for this partition.
continue;
}
DateTime endDateFilter = DateTime.UtcNow - retentionDuration;
BackupStorage storage = backupPolicy.Storage;
DeleteFilesForPartition(partitionId, endDateFilter, minimumNumberOfBackups, storage, backupPolicyName).GetAwaiter().GetResult();
this.tokenSource.Token.ThrowIfCancellationRequested();
}
// --> Introduce some wait time here so that CompletionTime is never equal to StartTime.
retentionMetadata.UpdateLastRetentionCompletionTime();
this.RetentionStore.UpdateValueAsync(backupPolicyName, retentionMetadata).GetAwaiter().GetResult();
retentionScheduler.ArmTimer(retentionMetadata);
toRearm = false;
}
catch (Exception ex)
{
if (ex is OperationCanceledException)
{
// Since, timercallback was cancelled, therefore, there is no need to rearm the timer.
BackupRestoreTrace.TraceSource.WriteWarning(TraceType, " TimerCallback for backupPolicy : {0} was cancelled ", backupPolicyName);
toRearm = false;
}
else
{
BackupRestoreTrace.TraceSource.WriteWarning(TraceType, " TimerCallback for backupPolicy : {0} has thrown an exception : {1}", backupPolicyName, ex);
}
}
finally
{
if (toRearm)
{
retentionScheduler.RearmTimer(true, retentionMetadata);
}
}
}
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);
}
/// <summary>
/// Creates or updates the backup policy.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='deviceName'>
/// The device name
/// </param>
/// <param name='backupPolicyName'>
/// The name of the backup policy to be created/updated.
/// </param>
/// <param name='parameters'>
/// The backup policy.
/// </param>
/// <param name='resourceGroupName'>
/// The resource group name
/// </param>
/// <param name='managerName'>
/// The manager name
/// </param>
public static BackupPolicy BeginCreateOrUpdate(this IBackupPoliciesOperations operations, string deviceName, string backupPolicyName, BackupPolicy parameters, string resourceGroupName, string managerName)
{
return(operations.BeginCreateOrUpdateAsync(deviceName, backupPolicyName, parameters, resourceGroupName, managerName).GetAwaiter().GetResult());
}