Merge pull request Azure#11378 from MabOneSdk/users/sarath/disk-ex

[RecoveryServices.Backup] Added support for disk exclusion during Backup and Restore

Author: isra-fel

src/RecoveryServices/RecoveryServices.Backup.Models/AzureModels/AzureItem.cs

@@ -27,6 +27,11 @@ public class AzureItem : ItemBase
         /// </summary>
         public ItemProtectionStatus ProtectionStatus { get; set; }
 
+        /// <summary>
+        /// Policy ID Associated with item
+        /// </summary>
+        public string PolicyId { get; set; }
+
         /// <summary>
         /// Protection State of the item
         /// </summary>
@@ -67,6 +72,7 @@ public AzureItem(ProtectedItemResource protectedItemResource,
             : base(protectedItemResource, containerName, containerType)
         {
             ProtectionPolicyName = policyName;
+            PolicyId = protectedItemResource.Properties.PolicyId;
         }
     }
     public class AzureItemExtendedInfo : ItemExtendedInfoBase

src/RecoveryServices/RecoveryServices.Backup.Models/CmdletParamEnums.cs

@@ -58,7 +58,10 @@ public enum RestoreBackupItemParams
     public enum RestoreVMBackupItemParams
     {
         TargetResourceGroupName,
-        OsaOption
+        OsaOption,
+        RestoreDiskList,
+        RestoreOnlyOSDisk,
+        RestoreAsUnmanagedDisks
     }
 
     public enum RestoreFSBackupItemParams
@@ -118,7 +121,11 @@ public enum ItemParams
         BackupType,
         EnableCompression,
         DeleteState,
-        FriendlyName
+        FriendlyName,
+        InclusionDisksList,
+        ExclusionDisksList,
+        ResetExclusionSettings,
+        ExcludeAllDataDisks
     }
 
     public enum ProtectionCheckParams

src/RecoveryServices/RecoveryServices.Backup.Models/Properties/Resources.Designer.cs

@@ -586,4 +586,16 @@ Please contact Microsoft for further assistance.</value>
   <data name="TargetContainerRequiredException" xml:space="preserve">
     <value>Target Container parameter is required for this operation.</value>
   </data>
+  <data name="DiskExclusionParametersRedundant" xml:space="preserve">
+    <value>Multiple Parameters Provided. Please specify only one of the parameters from InclusionDisksList, ExclusionDisksList, ResetExclusionSetting and ExcludeAllDataDisks.</value>
+  </data>
+  <data name="InclusionListRedundantError" xml:space="preserve">
+    <value>Both Inclusion and Exclusion lists provided. Please provide only one of them.</value>
+  </data>
+  <data name="TargetRGUnmanagedRestoreDuplicateParamsException" xml:space="preserve">
+    <value>Both RestoreAsUnmanagedDisks and TargetResourceGroupName can't be spceified. Please give Only one parameter and retry.</value>
+  </data>
+  <data name="UnmanagedVMRestoreWarning" xml:space="preserve">
+    <value>The disks of the managed VM will be restored as unmanaged since TargetResourceGroupName parameter is not provided. This will NOT leverage the instant restore functionality and hence can be significantly slow based on given storage account. To leverage instant restore, provide the TargetResourceGroupName parameter. Otherwise, provide the intent next time by passing the RestoreAsUnmanagedDisks parameter</value>
+  </data>
 </root>

src/RecoveryServices/RecoveryServices.Backup.Models/Properties/Resources.resx

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <PsModuleName>RecoveryServices</PsModuleName>
@@ -14,5 +14,5 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.Azure.Management.RecoveryServices.Backup" Version="4.0.1-preview" />
   </ItemGroup>
-
+  
 </Project>

src/RecoveryServices/RecoveryServices.Backup.Models/RecoveryServices.Backup.Models.csproj

@@ -19,6 +19,7 @@
 using Microsoft.Azure.Commands.RecoveryServices.Backup.Properties;
 using Microsoft.Azure.Management.Internal.Resources.Models;
 using Microsoft.Azure.Management.RecoveryServices.Backup.Models;
+using Microsoft.Rest;
 using Microsoft.Rest.Azure.OData;
 using System;
 using System.Collections.Generic;
@@ -74,21 +75,31 @@ public RestAzureNS.AzureOperationResponse<ProtectedItemResource> EnableProtectio
             string azureVMCloudServiceName = (string)ProviderData[ItemParams.AzureVMCloudServiceName];
             string azureVMResourceGroupName = (string)ProviderData[ItemParams.AzureVMResourceGroupName];
             string parameterSetName = (string)ProviderData[ItemParams.ParameterSetName];
+            string[] inclusionDisksList = (string[])ProviderData[ItemParams.InclusionDisksList];
+            string[] exclusionDisksList = (string[])ProviderData[ItemParams.ExclusionDisksList];
+            SwitchParameter resetDiskExclusionSetting = (SwitchParameter)ProviderData[ItemParams.ResetExclusionSettings];
+            bool excludeAllDataDisks = (bool)ProviderData[ItemParams.ExcludeAllDataDisks];
 
             PolicyBase policy = (PolicyBase)ProviderData[ItemParams.Policy];
 
             ItemBase itemBase = (ItemBase)ProviderData[ItemParams.Item];
 
             AzureVmItem item = (AzureVmItem)ProviderData[ItemParams.Item];
 
+            bool isDiskExclusionParamPresent = ValidateDiskExclusionParameters(
+                inclusionDisksList, exclusionDisksList, resetDiskExclusionSetting, excludeAllDataDisks);
+
             // do validations
             string containerUri = "";
             string protectedItemUri = "";
             bool isComputeAzureVM = false;
             string sourceResourceId = null;
 
             AzureVmPolicy azureVmPolicy = (AzureVmPolicy)ProviderData[ItemParams.Policy];
-            ValidateProtectedItemCount(azureVmPolicy);
+            if (azureVmPolicy != null)
+            {
+                ValidateProtectedItemCount(azureVmPolicy);
+            }
 
             if (itemBase == null)
             {
@@ -126,6 +137,14 @@ public RestAzureNS.AzureOperationResponse<ProtectedItemResource> EnableProtectio
                     sourceResourceId = iaasVmProtectableItem.VirtualMachineId;
                 }
             }
+            else if(isDiskExclusionParamPresent && parameterSetName.Contains("Modify"))
+            {
+                isComputeAzureVM = IsComputeAzureVM(item.VirtualMachineId);
+                Dictionary<UriEnums, string> keyValueDict = HelperUtils.ParseUri(item.Id);
+                containerUri = HelperUtils.GetContainerUri(keyValueDict, item.Id);
+                protectedItemUri = HelperUtils.GetProtectedItemUri(keyValueDict, item.Id);
+                sourceResourceId = item.SourceResourceId;
+            }
             else
             {
                 ValidateAzureVMWorkloadType(item.WorkloadType, policy.WorkloadType);
@@ -150,9 +169,49 @@ public RestAzureNS.AzureOperationResponse<ProtectedItemResource> EnableProtectio
                 properties = new AzureIaaSComputeVMProtectedItem();
             }
 
-            properties.PolicyId = policy.Id;
+            if(policy != null)
+            {
+                properties.PolicyId = policy.Id;
+            }
+            else
+            {
+                properties.PolicyId = item.PolicyId;
+            }
             properties.SourceResourceId = sourceResourceId;
 
+            ExtendedProperties extendedProperties = null;
+            if (resetDiskExclusionSetting.IsPresent)
+            {
+                extendedProperties = new ExtendedProperties();
+                extendedProperties.DiskExclusionProperties = null;
+            }
+            else
+            {
+                if(inclusionDisksList != null)
+                {
+                    IList<int?> inclusionList = Array.ConvertAll(inclusionDisksList, s => int.Parse(s)).OfType<int?>().ToList();
+                    DiskExclusionProperties diskExclusionProperties = new DiskExclusionProperties(inclusionList, true);
+                    extendedProperties = new ExtendedProperties();
+                    extendedProperties.DiskExclusionProperties = diskExclusionProperties;
+                }
+                else if(exclusionDisksList != null)
+                {
+                    IList<int?> exclusionList = Array.ConvertAll(exclusionDisksList, s => int.Parse(s)).OfType<int?>().ToList();
+                    DiskExclusionProperties diskExclusionProperties = new DiskExclusionProperties(exclusionList, false);
+                    extendedProperties = new ExtendedProperties();
+                    extendedProperties.DiskExclusionProperties = diskExclusionProperties;
+                }
+                else if(excludeAllDataDisks == true)
+                {
+                    IList<int?> exclusionList = new List<int?>();
+                    DiskExclusionProperties diskExclusionProperties = new DiskExclusionProperties(exclusionList, true);
+                    extendedProperties = new ExtendedProperties();
+                    extendedProperties.DiskExclusionProperties = diskExclusionProperties;
+                }
+            }
+
+            properties.ExtendedProperties = extendedProperties;
+
             ProtectedItemResource serviceClientRequest = new ProtectedItemResource()
             {
                 Properties = properties
@@ -327,6 +386,10 @@ public RestAzureNS.AzureOperationResponse TriggerRestore()
                 ProviderData.ContainsKey(RestoreVMBackupItemParams.TargetResourceGroupName) ?
                 ProviderData[RestoreVMBackupItemParams.TargetResourceGroupName].ToString() : null;
             bool osaOption = (bool)ProviderData[RestoreVMBackupItemParams.OsaOption];
+            string[] restoreDiskList = (string[])ProviderData[RestoreVMBackupItemParams.RestoreDiskList];
+            SwitchParameter restoreOnlyOSDisk = (SwitchParameter)ProviderData[RestoreVMBackupItemParams.RestoreOnlyOSDisk];
+            SwitchParameter restoreAsUnmanagedDisks = (SwitchParameter)ProviderData[RestoreVMBackupItemParams.RestoreAsUnmanagedDisks];
+
             Dictionary<UriEnums, string> uriDict = HelperUtils.ParseUri(rp.Id);
             string containerUri = HelperUtils.GetContainerUri(uriDict, rp.Id);
 
@@ -343,11 +406,36 @@ public RestAzureNS.AzureOperationResponse TriggerRestore()
                 throw new Exception(string.Format(Resources.RestoreDiskStorageTypeError, vmType));
             }
 
+            if(targetResourceGroupName != null && restoreAsUnmanagedDisks.IsPresent)
+            {
+                throw new Exception(Resources.TargetRGUnmanagedRestoreDuplicateParamsException);
+            }
+
             if (targetResourceGroupName != null && rp.IsManagedVirtualMachine == false)
             {
                 Logger.Instance.WriteWarning(Resources.UnManagedBackupVmWarning);
             }
 
+            if(rp.IsManagedVirtualMachine == true && targetResourceGroupName == null
+                && restoreAsUnmanagedDisks.IsPresent == false)
+            {
+                Logger.Instance.WriteWarning(Resources.UnmanagedVMRestoreWarning);
+            }
+
+            IList<int?> restoreDiskLUNS;
+            if(restoreOnlyOSDisk.IsPresent)
+            {
+                restoreDiskLUNS = new List<int?>();
+            }
+            else if(restoreDiskList != null)
+            {
+                restoreDiskLUNS = Array.ConvertAll(restoreDiskList, s => int.Parse(s)).OfType<int?>().ToList();
+            }
+            else
+            {
+                restoreDiskLUNS = null;
+            }
+
             IaasVMRestoreRequest restoreRequest = new IaasVMRestoreRequest()
             {
                 CreateNewCloudService = false,
@@ -360,6 +448,7 @@ public RestAzureNS.AzureOperationResponse TriggerRestore()
                     "/subscriptions/" + ServiceClientAdapter.SubscriptionId + "/resourceGroups/" + targetResourceGroupName :
                     null,
                 OriginalStorageAccountOption = useOsa,
+                RestoreDiskLunList = restoreDiskLUNS
             };
 
             RestoreRequestResource triggerRestoreRequest = new RestoreRequestResource();
@@ -987,6 +1076,33 @@ private void ValidateAzureVMModifyProtectionRequest(ItemBase itemBase,
             }
         }
 
+        private bool ValidateDiskExclusionParameters(string[] inclusionDiskList, string[] exclusionDiskList,
+            SwitchParameter resetDiskExclusion, bool excludeAllDataDisks)
+        {
+            bool isDiskExclusionParamPresent = false;
+            if(inclusionDiskList != null || exclusionDiskList != null || resetDiskExclusion.IsPresent || excludeAllDataDisks)
+            {
+                isDiskExclusionParamPresent = true;
+            }
+
+            if(inclusionDiskList != null && exclusionDiskList != null)
+            {
+                throw new ArgumentException(Resources.InclusionListRedundantError);
+            }
+
+            if(resetDiskExclusion.IsPresent && (inclusionDiskList != null && exclusionDiskList != null))
+            {
+                throw new ArgumentException(Resources.DiskExclusionParametersRedundant);
+            }
+
+            if(excludeAllDataDisks && (inclusionDiskList != null || exclusionDiskList != null || resetDiskExclusion.IsPresent))
+            {
+                throw new ArgumentException(Resources.DiskExclusionParametersRedundant);
+            }
+
+            return isDiskExclusionParamPresent;
+        }
+
         private void ValidateAzureVMDisableProtectionRequest(ItemBase itemBase)
         {
 
@@ -1140,6 +1256,7 @@ private bool IsDiscoveryNeeded(
                 {
                     IaaSVMProtectableItem iaaSVMProtectableItem =
                         (IaaSVMProtectableItem)protectableItem.Properties;
+
                     if (iaaSVMProtectableItem != null &&
                         string.Compare(iaaSVMProtectableItem.FriendlyName, vmName, true) == 0
                         && iaaSVMProtectableItem.VirtualMachineId.IndexOf(virtualMachineId,

src/RecoveryServices/RecoveryServices.Backup.Providers/Providers/IaasVmPsBackupProvider.cs

@@ -121,5 +121,14 @@ public void TestAzureVMSetVaultProperty()
             TestController.NewInstance.RunPsTest(
                 _logger, PsBackupProviderTypes.IaasVm, "Test-AzureVMSetVaultProperty");
         }
+
+        [Fact]
+        [Trait(Category.AcceptanceType, Category.CheckIn)]
+        [Trait(TestConstants.Workload, TestConstants.AzureVM)]
+        public void TestAzureVMDiskExclusion()
+        {
+            TestController.NewInstance.RunPsTest(
+                _logger, PsBackupProviderTypes.IaasVm, "Test-AzureVMDiskExclusion");
+        }
     }
 }