Esempio n. 1
0
        public static VolumePatchPropertiesDataProtection ConvertToPatchFromPs(this PSNetAppFilesVolumeDataProtection psDataProtection)
        {
            var dataProtection = new VolumePatchPropertiesDataProtection();

            if (psDataProtection.Backup != null)
            {
                var backup = new VolumeBackupProperties();
                backup.BackupEnabled  = psDataProtection.Backup.BackupEnabled;
                backup.BackupPolicyId = psDataProtection.Backup.BackupPolicyId;
                backup.PolicyEnforced = psDataProtection.Backup.PolicyEnforced;
                backup.VaultId        = psDataProtection.Backup.VaultId;
                dataProtection.Backup = backup;
            }
            return(dataProtection);
        }
Esempio n. 2
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);
            }
        }
Esempio n. 3
0
        public void CreateDeleteBackup()
        {
            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, poolName: ResourceUtils.backupPoolName1, location: ResourceUtils.backupLocation);
                if (Environment.GetEnvironmentVariable("AZURE_TEST_MODE") == "Record")
                {
                    Thread.Sleep(delay);
                }
                //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.CreateVolume(netAppMgmtClient, location: ResourceUtils.backupLocation, accountName: ResourceUtils.volumeBackupAccountName1, poolName: ResourceUtils.backupPoolName1, volumeName: ResourceUtils.backupVolumeName1, vnet: ResourceUtils.backupVnet, volumeOnly: true);
                if (Environment.GetEnvironmentVariable("AZURE_TEST_MODE") == "Record")
                {
                    Thread.Sleep(delay);
                }
                var createGetVolume = netAppMgmtClient.Volumes.Get(ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1, ResourceUtils.backupPoolName1, ResourceUtils.backupVolumeName1);
                Assert.Equal("Succeeded", createGetVolume.ProvisioningState);
                //volume update with backup setting
                var dataProtection = new VolumePatchPropertiesDataProtection
                {
                    Backup = new VolumeBackupProperties {
                        BackupEnabled = true, VaultId = vaultID
                    }
                };
                var volumePatch = new VolumePatch()
                {
                    DataProtection = dataProtection
                };

                var updatedVolume = netAppMgmtClient.Volumes.Update(volumePatch, ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1, ResourceUtils.backupPoolName1, 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.backupPoolName1, ResourceUtils.backupVolumeName1);
                Assert.NotNull(getVolume.DataProtection);
                Assert.NotNull(getVolume.DataProtection.Backup);
                Assert.NotNull(getVolume.DataProtection.Backup.VaultId);

                //create adhoc backup
                var backup = new Backup()
                {
                    Location = ResourceUtils.backupLocation,
                    Label    = "sdkTestBackup1"
                };
                var createdBackup = netAppMgmtClient.Backups.Create(ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1, ResourceUtils.backupPoolName1, ResourceUtils.backupVolumeName1, ResourceUtils.backupName1, backup);
                if (Environment.GetEnvironmentVariable("AZURE_TEST_MODE") == "Record")
                {
                    Thread.Sleep(delay);
                }
                Assert.NotNull(createdBackup);
                Assert.NotNull(createdBackup.Name);
                Assert.Equal($"{ResourceUtils.volumeBackupAccountName1}/{ResourceUtils.backupPoolName1}/{ResourceUtils.backupVolumeName1}/{ResourceUtils.backupName1}", createdBackup.Name);

                WaitForBackupSucceeded(netAppMgmtClient, ResourceUtils.volumeBackupAccountName1, ResourceUtils.backupPoolName1, ResourceUtils.backupVolumeName1, ResourceUtils.backupName1);

                if (Environment.GetEnvironmentVariable("AZURE_TEST_MODE") == "Record")
                {
                    Thread.Sleep(delay);
                }
                //create second backup
                var backup2 = new Backup()
                {
                    Location = ResourceUtils.backupLocation,
                    Label    = "sdkTestBackup1"
                };
                var createdBackup2 = netAppMgmtClient.Backups.Create(ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1, ResourceUtils.backupPoolName1, ResourceUtils.backupVolumeName1, ResourceUtils.backupName2, backup);
                if (Environment.GetEnvironmentVariable("AZURE_TEST_MODE") == "Record")
                {
                    Thread.Sleep(delay);
                }
                Assert.NotNull(createdBackup2);
                Assert.NotNull(createdBackup2.Name);
                Assert.Equal($"{ResourceUtils.volumeBackupAccountName1}/{ResourceUtils.backupPoolName1}/{ResourceUtils.backupVolumeName1}/{ResourceUtils.backupName2}", createdBackup2.Name);

                WaitForBackupSucceeded(netAppMgmtClient, ResourceUtils.volumeBackupAccountName1, ResourceUtils.backupPoolName1, ResourceUtils.backupVolumeName1, ResourceUtils.backupName2);

                var getBackup = netAppMgmtClient.Backups.Get(ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1, ResourceUtils.backupPoolName1, ResourceUtils.backupVolumeName1, ResourceUtils.backupName2);
                Assert.NotNull(getBackup);

                //Get Volume backup status
                var getBackupStatus = netAppMgmtClient.Backups.GetStatus(ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1, ResourceUtils.backupPoolName1, ResourceUtils.backupVolumeName1);
                Assert.NotNull(getBackupStatus);

                //Get by account backups
                var getAccountBackup2 = netAppMgmtClient.AccountBackups.Get(ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1, ResourceUtils.backupName2);
                Assert.NotNull(getAccountBackup2);
                Assert.NotNull(getAccountBackup2.Name);
                Assert.Equal($"{ResourceUtils.volumeBackupAccountName1}/{ResourceUtils.backupName2}", getAccountBackup2.Name);

                //Get List backups
                var getBackupList = netAppMgmtClient.Backups.List(ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1, ResourceUtils.backupPoolName1, ResourceUtils.backupVolumeName1);
                Assert.NotNull(getBackupList);
                Assert.Equal(2, getBackupList.Count());

                //Get List AccountBackups
                var getAccountBackupList = netAppMgmtClient.AccountBackups.List(ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1);
                Assert.NotNull(getBackupList);
                Assert.Equal(2, getBackupList.Count());

                //Delete backup 1
                WaitForBackupDeleteSucceeded(netAppMgmtClient, ResourceUtils.volumeBackupAccountName1, ResourceUtils.backupPoolName1, ResourceUtils.backupVolumeName1, ResourceUtils.backupName1);

                //Get List backups
                getBackupList = netAppMgmtClient.Backups.List(ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1, ResourceUtils.backupPoolName1, ResourceUtils.backupVolumeName1);
                Assert.NotNull(getBackupList);
                Assert.Single(getBackupList);

                // clean up
                // Delete volume so we can delete last backup
                ResourceUtils.DeleteVolume(netAppMgmtClient, accountName: ResourceUtils.volumeBackupAccountName1, poolName: ResourceUtils.backupPoolName1, volumeName: ResourceUtils.backupVolumeName1);
                //Delete last backup from AccountBackups
                if (Environment.GetEnvironmentVariable("AZURE_TEST_MODE") == "Record")
                {
                    Thread.Sleep(delay);
                }
                netAppMgmtClient.AccountBackups.Delete(ResourceUtils.resourceGroup, ResourceUtils.volumeBackupAccountName1, ResourceUtils.backupName2);
                ResourceUtils.DeletePool(netAppMgmtClient, accountName: ResourceUtils.volumeBackupAccountName1, poolName: ResourceUtils.backupPoolName1);
                ResourceUtils.DeleteAccount(netAppMgmtClient, accountName: ResourceUtils.volumeBackupAccountName1);
            }
        }