Added Azure File Share support to New, Modify and Remove Policy

Author: siddharth7

src/ResourceManager/RecoveryServices/Commands.RecoveryServices.Backup.Models/CommonModels/Utils.cs

@@ -47,6 +47,7 @@ public class PolicyConstants
         // month constants
         public const int NumOfMonthsInYear = 12;
 
+        // SQL constants
         public const int MaxAllowedRetentionDurationCountWeeklySql = 520;
         public const int MaxAllowedRetentionDurationCountMonthlySql = 120;
         public const int MaxAllowedRetentionDurationCountYearlySql = 10;
@@ -277,5 +278,30 @@ public static WorkloadType GetPsWorkloadType(string workloadType)
                 throw new Exception("Unsupported WorkloadType: " + workloadType);
             }
         }
+
+        /// <summary>
+        /// Returns the Service Client backup management type given the PS workload type.
+        /// </summary>
+        /// <param name="workloadType">PS workload type</param>
+        /// <returns>Service Client workload type</returns>
+        public static string GetServiceClientWorkloadType(string workloadType)
+        {
+            if (workloadType == WorkloadType.AzureVM.ToString())
+            {
+                return ServiceClientModel.WorkloadType.VM;
+            }
+            if (workloadType == WorkloadType.AzureSQLDatabase.ToString())
+            {
+                return ServiceClientModel.WorkloadType.AzureSqlDb;
+            }
+            if (workloadType == WorkloadType.AzureFiles.ToString())
+            {
+                return ServiceClientModel.WorkloadType.AzureFileShare;
+            }
+            else
+            {
+                throw new Exception("Unsupported WorkloadType: " + workloadType);
+            }
+        }
     }
 }

src/ResourceManager/RecoveryServices/Commands.RecoveryServices.Backup.Providers/AzureWorkloadProviderHelper.cs

@@ -235,6 +235,73 @@ public List<ProtectedItemResource> ListProtectedItemsByContainer(
             return ConversionHelpers.GetContainerModelList(listResponse);
         }
 
+        public void ValidateSimpleSchedulePolicy(CmdletModel.SchedulePolicyBase policy)
+        {
+            if (policy == null || policy.GetType() != typeof(CmdletModel.SimpleSchedulePolicy))
+            {
+                throw new ArgumentException(string.Format(Resources.InvalidSchedulePolicyException,
+                                            typeof(CmdletModel.SimpleSchedulePolicy).ToString()));
+            }
+
+            // call validation
+            policy.Validate();
+        }
+
+        public void ValidateLongTermRetentionPolicy(CmdletModel.RetentionPolicyBase policy)
+        {
+            if (policy == null || policy.GetType() != typeof(CmdletModel.LongTermRetentionPolicy))
+            {
+                throw new ArgumentException(
+                    string.Format(
+                        Resources.InvalidRetentionPolicyException,
+                        typeof(CmdletModel.LongTermRetentionPolicy).ToString()));
+            }
+
+            // perform validation
+            policy.Validate();
+        }
+
+        public DateTime GenerateRandomScheduleTime()
+        {
+            //Schedule time will be random to avoid the load in service (same is in portal as well)
+            Random rand = new Random();
+            int hour = rand.Next(0, 24);
+            int minute = (rand.Next(0, 2) == 0) ? 0 : 30;
+            return new DateTime(DateTime.Now.Year,
+                DateTime.Now.Month,
+                DateTime.Now.Day,
+                hour,
+                minute,
+                00,
+                DateTimeKind.Utc);
+        }
+
+        public void CopyScheduleTimeToRetentionTimes(CmdletModel.LongTermRetentionPolicy retPolicy,
+                                                      CmdletModel.SimpleSchedulePolicy schPolicy)
+        {
+            // schedule runTimes is already validated if in UTC/not during validate()
+            // now copy times from schedule to retention policy
+            if (retPolicy.IsDailyScheduleEnabled && retPolicy.DailySchedule != null)
+            {
+                retPolicy.DailySchedule.RetentionTimes = schPolicy.ScheduleRunTimes;
+            }
+
+            if (retPolicy.IsWeeklyScheduleEnabled && retPolicy.WeeklySchedule != null)
+            {
+                retPolicy.WeeklySchedule.RetentionTimes = schPolicy.ScheduleRunTimes;
+            }
+
+            if (retPolicy.IsMonthlyScheduleEnabled && retPolicy.MonthlySchedule != null)
+            {
+                retPolicy.MonthlySchedule.RetentionTimes = schPolicy.ScheduleRunTimes;
+            }
+
+            if (retPolicy.IsYearlyScheduleEnabled && retPolicy.YearlySchedule != null)
+            {
+                retPolicy.YearlySchedule.RetentionTimes = schPolicy.ScheduleRunTimes;
+            }
+        }
+
         public List<CmdletModel.RecoveryPointBase> ListRecoveryPoints(Dictionary<Enum, object> ProviderData)
         {
             string vaultName = (string)ProviderData[CmdletModel.VaultParams.VaultName];

src/ResourceManager/RecoveryServices/Commands.RecoveryServices.Backup.Providers/Providers/AzureFilesPsBackupProvider.cs

@@ -37,6 +37,9 @@ public class AzureFilesPsBackupProvider : IPsBackupProvider
     {
         private const int defaultOperationStatusRetryTimeInMilliSec = 5 * 1000; // 5 sec
         private const string separator = ";";
+        private const CmdletModel.RetentionDurationType defaultFileRetentionType =
+            CmdletModel.RetentionDurationType.Days;
+        private const int defaultFileRetentionCount = 30;
 
         Dictionary<Enum, object> ProviderData { get; set; }
 
@@ -429,12 +432,126 @@ public List<RecoveryPointBase> ListRecoveryPoints()
 
         public ProtectionPolicyResource CreatePolicy()
         {
-            throw new NotImplementedException();
+            return CreateorModifyPolicy().Body;
         }
 
         public RestAzureNS.AzureOperationResponse<ProtectionPolicyResource> ModifyPolicy()
         {
-            throw new NotImplementedException();
+            return CreateorModifyPolicy();
+        }
+
+        private RestAzureNS.AzureOperationResponse<ProtectionPolicyResource> CreateorModifyPolicy()
+        {
+            string vaultName = (string)ProviderData[VaultParams.VaultName];
+            string resourceGroupName = (string)ProviderData[VaultParams.ResourceGroupName];
+            string policyName = ProviderData.ContainsKey(PolicyParams.PolicyName) ?
+                (string)ProviderData[PolicyParams.PolicyName] : null;
+            RetentionPolicyBase retentionPolicy =
+                ProviderData.ContainsKey(PolicyParams.RetentionPolicy) ?
+                (RetentionPolicyBase)ProviderData[PolicyParams.RetentionPolicy] :
+                null;
+            SchedulePolicyBase schedulePolicy =
+                ProviderData.ContainsKey(PolicyParams.SchedulePolicy) ?
+                (SchedulePolicyBase)ProviderData[PolicyParams.SchedulePolicy] :
+                null;
+            PolicyBase policy =
+                ProviderData.ContainsKey(PolicyParams.ProtectionPolicy) ?
+                (PolicyBase)ProviderData[PolicyParams.ProtectionPolicy] :
+                null;
+            ProtectionPolicyResource serviceClientRequest = new ProtectionPolicyResource();
+
+            if (policy != null)
+            {
+                // do validations
+                ValidateAzureFileProtectionPolicy(policy);
+                Logger.Instance.WriteDebug("Validation of Protection Policy is successful");
+
+                // RetentionPolicy and SchedulePolicy both should not be empty
+                if (retentionPolicy == null && schedulePolicy == null)
+                {
+                    throw new ArgumentException(Resources.BothRetentionAndSchedulePoliciesEmpty);
+                }
+
+                // validate RetentionPolicy and SchedulePolicy
+                if (schedulePolicy != null)
+                {
+                    AzureWorkloadProviderHelper.ValidateSimpleSchedulePolicy(schedulePolicy);
+                    ((AzureFileSharePolicy)policy).SchedulePolicy = schedulePolicy;
+                    Logger.Instance.WriteDebug("Validation of Schedule policy is successful");
+                }
+                if (retentionPolicy != null)
+                {
+                    AzureWorkloadProviderHelper.ValidateLongTermRetentionPolicy(retentionPolicy);
+                    ((AzureFileSharePolicy)policy).RetentionPolicy = retentionPolicy;
+                    Logger.Instance.WriteDebug("Validation of Retention policy is successful");
+                }
+
+                // copy the backupSchedule time to retentionPolicy after converting to UTC
+                AzureWorkloadProviderHelper.CopyScheduleTimeToRetentionTimes(
+                    (CmdletModel.LongTermRetentionPolicy)((AzureFileSharePolicy)policy).RetentionPolicy,
+                    (CmdletModel.SimpleSchedulePolicy)((AzureFileSharePolicy)policy).SchedulePolicy);
+                Logger.Instance.WriteDebug("Copy of RetentionTime from with SchedulePolicy to RetentionPolicy is successful");
+
+                // Now validate both RetentionPolicy and SchedulePolicy matches or not
+                PolicyHelpers.ValidateLongTermRetentionPolicyWithSimpleRetentionPolicy(
+                    (CmdletModel.LongTermRetentionPolicy)((AzureFileSharePolicy)policy).RetentionPolicy,
+                    (CmdletModel.SimpleSchedulePolicy)((AzureFileSharePolicy)policy).SchedulePolicy);
+                Logger.Instance.WriteDebug("Validation of Retention policy with Schedule policy is successful");
+
+                // construct Service Client policy request            
+                AzureFileShareProtectionPolicy azureFileShareProtectionPolicy = new AzureFileShareProtectionPolicy();
+                azureFileShareProtectionPolicy.RetentionPolicy = PolicyHelpers.GetServiceClientLongTermRetentionPolicy(
+                                (CmdletModel.LongTermRetentionPolicy)((AzureFileSharePolicy)policy).RetentionPolicy);
+                azureFileShareProtectionPolicy.SchedulePolicy = PolicyHelpers.GetServiceClientSimpleSchedulePolicy(
+                                (CmdletModel.SimpleSchedulePolicy)((AzureFileSharePolicy)policy).SchedulePolicy);
+                azureFileShareProtectionPolicy.TimeZone = DateTimeKind.Utc.ToString();
+                azureFileShareProtectionPolicy.WorkLoadType = ConversionUtils.GetServiceClientWorkloadType(policy.WorkloadType.ToString());
+                serviceClientRequest.Properties = azureFileShareProtectionPolicy;
+
+            }
+            else
+            {
+                CmdletModel.WorkloadType workloadType =
+                (CmdletModel.WorkloadType)ProviderData[PolicyParams.WorkloadType];
+
+                // do validations
+                ValidateAzureFilesWorkloadType(workloadType);
+                AzureWorkloadProviderHelper.ValidateSimpleSchedulePolicy(schedulePolicy);
+                Logger.Instance.WriteDebug("Validation of Schedule policy is successful");
+
+                // validate RetentionPolicy
+                AzureWorkloadProviderHelper.ValidateLongTermRetentionPolicy(retentionPolicy);
+                Logger.Instance.WriteDebug("Validation of Retention policy is successful");
+
+                // update the retention times from backupSchedule to retentionPolicy after converting to UTC           
+                AzureWorkloadProviderHelper.CopyScheduleTimeToRetentionTimes((CmdletModel.LongTermRetentionPolicy)retentionPolicy,
+                                                 (CmdletModel.SimpleSchedulePolicy)schedulePolicy);
+                Logger.Instance.WriteDebug("Copy of RetentionTime from with SchedulePolicy to RetentionPolicy is successful");
+
+                // Now validate both RetentionPolicy and SchedulePolicy together
+                PolicyHelpers.ValidateLongTermRetentionPolicyWithSimpleRetentionPolicy(
+                                    (CmdletModel.LongTermRetentionPolicy)retentionPolicy,
+                                    (CmdletModel.SimpleSchedulePolicy)schedulePolicy);
+                Logger.Instance.WriteDebug("Validation of Retention policy with Schedule policy is successful");
+
+                // construct Service Client policy request            
+                AzureFileShareProtectionPolicy azureFileShareProtectionPolicy = new AzureFileShareProtectionPolicy();
+                azureFileShareProtectionPolicy.RetentionPolicy = PolicyHelpers.GetServiceClientLongTermRetentionPolicy(
+                                                    (CmdletModel.LongTermRetentionPolicy)retentionPolicy);
+                azureFileShareProtectionPolicy.RetentionPolicy = PolicyHelpers.GetServiceClientLongTermRetentionPolicy(
+                                                    (CmdletModel.LongTermRetentionPolicy)retentionPolicy);
+                azureFileShareProtectionPolicy.SchedulePolicy = PolicyHelpers.GetServiceClientSimpleSchedulePolicy(
+                                                    (CmdletModel.SimpleSchedulePolicy)schedulePolicy);
+                azureFileShareProtectionPolicy.TimeZone = DateTimeKind.Utc.ToString();
+                azureFileShareProtectionPolicy.WorkLoadType = ConversionUtils.GetServiceClientWorkloadType(workloadType.ToString());
+                serviceClientRequest.Properties = azureFileShareProtectionPolicy;
+            }
+
+            return ServiceClientAdapter.CreateOrUpdateProtectionPolicy(
+                policyName = policyName ?? policy.Name,
+                serviceClientRequest,
+                vaultName: vaultName,
+                resourceGroupName: resourceGroupName);
         }
 
         public RPMountScriptDetails ProvisionItemLevelRecoveryAccess()
@@ -466,12 +583,28 @@ public void DeletePolicy()
 
         public SchedulePolicyBase GetDefaultSchedulePolicyObject()
         {
-            throw new NotImplementedException();
+            CmdletModel.SimpleSchedulePolicy defaultSchedule = new CmdletModel.SimpleSchedulePolicy();
+            defaultSchedule.ScheduleRunFrequency = CmdletModel.ScheduleRunType.Daily;
+
+            DateTime scheduleTime = AzureWorkloadProviderHelper.GenerateRandomScheduleTime();
+            defaultSchedule.ScheduleRunTimes = new List<DateTime>();
+            defaultSchedule.ScheduleRunTimes.Add(scheduleTime);
+
+            return defaultSchedule;
         }
 
         public RetentionPolicyBase GetDefaultRetentionPolicyObject()
         {
-            throw new NotImplementedException();
+            CmdletModel.LongTermRetentionPolicy defaultRetention = new CmdletModel.LongTermRetentionPolicy();
+            DateTime retentionTime = AzureWorkloadProviderHelper.GenerateRandomScheduleTime();
+
+            //Daily Retention policy
+            defaultRetention.IsDailyScheduleEnabled = true;
+            defaultRetention.DailySchedule = new CmdletModel.DailyRetentionSchedule();
+            defaultRetention.DailySchedule.RetentionTimes = new List<DateTime>();
+            defaultRetention.DailySchedule.RetentionTimes.Add(retentionTime);
+            defaultRetention.DailySchedule.DurationCountInDays = defaultFileRetentionCount;
+            return defaultRetention;
         }
 
         public List<ItemBase> ListProtectedItems()
@@ -611,5 +744,19 @@ private void ValidateAzureStorageBackupManagementType(
                                             backupManagementType.ToString()));
             }
         }
+
+        private void ValidateAzureFileProtectionPolicy(PolicyBase policy)
+        {
+            if (policy == null || policy.GetType() != typeof(AzureFileSharePolicy))
+            {
+                throw new ArgumentException(string.Format(Resources.InvalidProtectionPolicyException,
+                                            typeof(AzureFileSharePolicy).ToString()));
+            }
+
+            ValidateAzureFilesWorkloadType(policy.WorkloadType);
+
+            // call validation
+            policy.Validate();
+        }
     }
 }