Example #1
0
        public void PatchBackupPolicy()
        {
            HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
            using (MockContext context = MockContext.Start(this.GetType()))
            {
                var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
                    StatusCodeToReturn = HttpStatusCode.OK
                });
                //Create acccount

                ResourceUtils.CreateAccount(netAppMgmtClient, location: ResourceUtils.backupLocation, accountName: ResourceUtils.volumeBackupAccountName1);
                //create the backupPolicy
                var backupPolicy       = CreateBackupPolicy(ResourceUtils.backupLocation, ResourceUtils.backupPolicyName1);
                var createBackupPolicy = netAppMgmtClient.BackupPolicies.Create(ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1, ResourceUtils.backupPolicyName1, backupPolicy);

                // Now try and modify it
                var patchBackupPolicy = new BackupPolicyPatch()
                {
                    DailyBackupsToKeep = 1
                };

                var resultbackupPolicy = netAppMgmtClient.BackupPolicies.Update(ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1, ResourceUtils.backupPolicyName1, patchBackupPolicy);
                Assert.NotNull(resultbackupPolicy);

                if (Environment.GetEnvironmentVariable("AZURE_TEST_MODE") == "Record")
                {
                    Thread.Sleep(delay);
                }
                var getResultbackupPolicy = netAppMgmtClient.BackupPolicies.Get(ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1, ResourceUtils.backupPolicyName1);
                Assert.NotNull(getResultbackupPolicy);
                Assert.NotNull(getResultbackupPolicy.DailyBackupsToKeep);
                Assert.Equal(patchBackupPolicy.DailyBackupsToKeep, getResultbackupPolicy.DailyBackupsToKeep);

                if (Environment.GetEnvironmentVariable("AZURE_TEST_MODE") == "Record")
                {
                    Thread.Sleep(delay);
                }
                // cleanup
                netAppMgmtClient.BackupPolicies.Delete(ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1, ResourceUtils.backupPolicyName1);
                ResourceUtils.DeletePool(netAppMgmtClient, accountName: ResourceUtils.volumeBackupAccountName1);
                ResourceUtils.DeleteAccount(netAppMgmtClient, accountName: ResourceUtils.volumeBackupAccountName1);
            }
        }
Example #2
0
 /// <summary>
 /// Patch a backup policy
 /// </summary>
 /// <remarks>
 /// Patch 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> BeginUpdateAsync(this IBackupPoliciesOperations operations, string resourceGroupName, string accountName, string backupPolicyName, BackupPolicyPatch body, CancellationToken cancellationToken = default(CancellationToken))
 {
     using (var _result = await operations.BeginUpdateWithHttpMessagesAsync(resourceGroupName, accountName, backupPolicyName, body, null, cancellationToken).ConfigureAwait(false))
     {
         return(_result.Body);
     }
 }
Example #3
0
        //[Fact]
        public void CreateVolumeWithBackupPolicy()
        {
            HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
            using (MockContext context = MockContext.Start(this.GetType()))
            {
                var netAppMgmtClient = NetAppTestUtilities.GetNetAppManagementClient(context, new RecordedDelegatingHandler {
                    StatusCodeToReturn = HttpStatusCode.OK
                });
                // create the Pool and account
                ResourceUtils.CreatePool(netAppMgmtClient, accountName: ResourceUtils.volumeBackupAccountName1, location: ResourceUtils.backupLocation);
                // create the backupPolicy
                var backupPolicy       = CreateBackupPolicy(ResourceUtils.backupLocation, ResourceUtils.backupPolicyName1);
                var createBackupPolicy = netAppMgmtClient.BackupPolicies.Create(ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1, ResourceUtils.backupPolicyName1, backupPolicy);

                //Get vault
                var vaultsList = netAppMgmtClient.Vaults.List(ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1);
                Assert.NotEmpty(vaultsList);
                string vaultID = vaultsList.ElementAt(0).Id;

                if (Environment.GetEnvironmentVariable("AZURE_TEST_MODE") == "Record")
                {
                    Thread.Sleep(delay);
                }
                // Create volume
                //var createVolume = ResourceUtils.CreateBackedupVolume(netAppMgmtClient, location: ResourceUtils.backupLocation, accountName:ResourceUtils.volumeBackupAccountName1, vnet: ResourceUtils.backupVnet, backupPolicyId: null, backupVaultId: vaultID);
                var createVolume = ResourceUtils.CreateVolume(netAppMgmtClient, location: ResourceUtils.backupLocation, accountName: ResourceUtils.volumeBackupAccountName1, volumeName: ResourceUtils.backupVolumeName1, vnet: ResourceUtils.backupVnet, volumeOnly: true);
                Assert.Equal("Succeeded", createVolume.ProvisioningState);
                //Get volume and check
                if (Environment.GetEnvironmentVariable("AZURE_TEST_MODE") == "Record")
                {
                    Thread.Sleep(delay);
                }
                var createGetVolume = netAppMgmtClient.Volumes.Get(ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1, ResourceUtils.poolName1, ResourceUtils.backupVolumeName1);
                Assert.Equal("Succeeded", createGetVolume.ProvisioningState);
                // Now try and modify the backuppolicy
                var patchBackupPolicy = new BackupPolicyPatch()
                {
                    DailyBackupsToKeep = 1
                };

                var resultbackupPolicy = netAppMgmtClient.BackupPolicies.Update(ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1, ResourceUtils.backupPolicyName1, patchBackupPolicy);

                //check volume again
                createGetVolume = netAppMgmtClient.Volumes.Get(ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1, ResourceUtils.poolName1, ResourceUtils.backupVolumeName1);
                Assert.Equal("Succeeded", createGetVolume.ProvisioningState);

                // Now try and set dataprotection on the volume
                var dataProtection = new VolumePatchPropertiesDataProtection
                {
                    Backup = new VolumeBackupProperties {
                        PolicyEnforced = true, BackupEnabled = true, BackupPolicyId = createBackupPolicy.Id, VaultId = vaultID
                    }
                };
                var volumePatch = new VolumePatch()
                {
                    DataProtection = dataProtection
                };

                // patch and enable backups
                var updatedVolume = netAppMgmtClient.Volumes.Update(volumePatch, ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1, ResourceUtils.poolName1, ResourceUtils.backupVolumeName1);

                //Get volume and check
                if (Environment.GetEnvironmentVariable("AZURE_TEST_MODE") == "Record")
                {
                    Thread.Sleep(delay);
                }
                var getVolume = netAppMgmtClient.Volumes.Get(ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1, ResourceUtils.poolName1, ResourceUtils.backupVolumeName1);
                Assert.NotNull(getVolume.DataProtection);
                Assert.NotNull(getVolume.DataProtection.Backup);
                Assert.NotNull(getVolume.DataProtection.Backup.BackupPolicyId);
                Assert.Equal(createBackupPolicy.Id, getVolume.DataProtection.Backup.BackupPolicyId);

                if (Environment.GetEnvironmentVariable("AZURE_TEST_MODE") == "Record")
                {
                    Thread.Sleep(delay);
                }

                // Try and disable backups
                var disableDataProtection = new VolumePatchPropertiesDataProtection
                {
                    Backup = new VolumeBackupProperties {
                        BackupEnabled = false, VaultId = vaultID
                    }
                };
                var disableVolumePatch = new VolumePatch()
                {
                    DataProtection = disableDataProtection
                };

                if (Environment.GetEnvironmentVariable("AZURE_TEST_MODE") == "Record")
                {
                    Thread.Sleep(delay);
                }
                // patch
                var disabledBackupVolume = netAppMgmtClient.Volumes.Update(disableVolumePatch, ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1, ResourceUtils.poolName1, ResourceUtils.backupVolumeName1);
                if (Environment.GetEnvironmentVariable("AZURE_TEST_MODE") == "Record")
                {
                    Thread.Sleep(delay);
                }
                var getDisabledVolume = netAppMgmtClient.Volumes.Get(ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1, ResourceUtils.poolName1, ResourceUtils.backupVolumeName1);

                //check
                Assert.NotNull(getDisabledVolume.DataProtection);
                Assert.NotNull(getDisabledVolume.DataProtection.Backup);
                Assert.False(getDisabledVolume.DataProtection.Backup.BackupEnabled);

                if (Environment.GetEnvironmentVariable("AZURE_TEST_MODE") == "Record")
                {
                    Thread.Sleep(delay);
                }
                // clean up
                ResourceUtils.DeleteVolume(netAppMgmtClient, accountName: ResourceUtils.volumeBackupAccountName1, volumeName: ResourceUtils.backupVolumeName1);
                netAppMgmtClient.BackupPolicies.Delete(ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1, ResourceUtils.backupPolicyName1);
                ResourceUtils.DeletePool(netAppMgmtClient, accountName: ResourceUtils.volumeBackupAccountName1);
                ResourceUtils.DeleteAccount(netAppMgmtClient, accountName: ResourceUtils.volumeBackupAccountName1);
            }
        }
Example #4
0
 /// <summary>
 /// Patch a backup policy
 /// </summary>
 /// <remarks>
 /// Patch 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 BeginUpdate(this IBackupPoliciesOperations operations, string resourceGroupName, string accountName, string backupPolicyName, BackupPolicyPatch body)
 {
     return(operations.BeginUpdateAsync(resourceGroupName, accountName, backupPolicyName, body).GetAwaiter().GetResult());
 }