/// <summary> /// Validate Has SSD Storage value from Input Override data /// </summary> /// <param name="inputOverrideVMSpecs">The Input Override specifications</param> private static void ValidateHasSSDStorage(OverrideVMSpecs inputOverrideVMSpecs) { // Instance Name Validation if (!string.IsNullOrWhiteSpace(inputOverrideVMSpecs.InputOriginalValues.HasSSDStorage)) { // Check if String is any of the "True" list - Case insensitive if (Constants.HasSSDStorageColumnTRUEValues.Any(x => inputOverrideVMSpecs.InputOriginalValues.HasSSDStorage.Equals(x, StringComparison.OrdinalIgnoreCase))) { inputOverrideVMSpecs.HasSSDStorage = true; } else if (Constants.HasSSDStorageColumnFALSEValues.Any(x => inputOverrideVMSpecs.InputOriginalValues.HasSSDStorage.Equals(x, StringComparison.OrdinalIgnoreCase))) { inputOverrideVMSpecs.HasSSDStorage = false; } else { inputOverrideVMSpecs.IsValid = false; inputOverrideVMSpecs.ValidationMessage += string.Format(ValidationLiterals.SpecNotYesNo, OverrideVMSpecLiterals.HasSSDStorage); } } else { // Instance Name is blank inputOverrideVMSpecs.IsValid = false; inputOverrideVMSpecs.ValidationMessage += string.Format(ValidationLiterals.MissingSpec, OverrideVMSpecLiterals.HasSSDStorage); } }
/// <summary> /// Validate Memory value from Input Override data /// </summary> /// <param name="inputOverrideVMSpecs">The Input Override VM specifications</param> /// <param name="isInputMemoryInGB">Value indicating if Memory is in GB or not</param> private static void ValidateMemory(OverrideVMSpecs inputOverrideVMSpecs, bool isInputMemoryInGB) { // Memory validation if (!string.IsNullOrWhiteSpace(inputOverrideVMSpecs.InputOriginalValues.Memory)) { double result = 0; if (double.TryParse(inputOverrideVMSpecs.InputOriginalValues.Memory, out result) && (result > 0)) { if (isInputMemoryInGB) { inputOverrideVMSpecs.MemoryInMB = 1024 * result; } else { inputOverrideVMSpecs.MemoryInMB = result; } } else { inputOverrideVMSpecs.IsValid = false; inputOverrideVMSpecs.ValidationMessage += string.Format(ValidationLiterals.SpecNotAPositiveNumber, OverrideVMSpecLiterals.Memory); } } else { // Memory is blank inputOverrideVMSpecs.IsValid = false; inputOverrideVMSpecs.ValidationMessage += string.Format(ValidationLiterals.MissingSpec, OverrideVMSpecLiterals.Memory); } }
/// <summary> /// Validate mapped Azure VM SKU value from Input Override data /// </summary> /// <param name="inputOverrideVMSpecs">The Input Override specifications</param> private static void ValidateAzureProjVMSize(OverrideVMSpecs inputOverrideVMSpecs) { if (!string.IsNullOrWhiteSpace(inputOverrideVMSpecs.InputOriginalValues.AzureProjVMSize)) { inputOverrideVMSpecs.AzureProjVMSize = inputOverrideVMSpecs.InputOriginalValues.AzureProjVMSize.Length > Constants.MaxLengthAzureVMOverride ? inputOverrideVMSpecs.InputOriginalValues.AzureProjVMSize.Substring(0, Constants.MaxLengthAzureVMOverride) : inputOverrideVMSpecs.InputOriginalValues.AzureProjVMSize; } else { inputOverrideVMSpecs.AzureProjVMSize = string.Empty; } }
/// <summary> /// Generates the strings array for the output of validated Override input file and Output Override file /// </summary> /// <param name="validatedOverrideVMSpecs">Validated Override Specs object / Output Override Specs object</param> /// <param name="isOutputMemoryInGB">A value indicating if Memory is in GB or not</param> /// <param name="isUniqueProjectedList">Value indicating if the output to be written is the output override data or not</param> /// <returns> Returns the strings array for the output of validated Override and Output Override file</returns> public static String[] UnloadOverrideVMSpecsOutput(OverrideVMSpecs validatedOverrideVMSpecs, bool isOutputMemoryInGB, bool isUniqueProjectedList) { string[] outputOverrideVMSpecsStr = new string[NumberOfTotalColumnsOverrideVMSpecs]; try { int column = 0; // Write Override VM Specs column with validation results - Output outputOverrideVMSpecsStr[column++] = validatedOverrideVMSpecs.IsValid || isUniqueProjectedList ? validatedOverrideVMSpecs.OperatingSystem : validatedOverrideVMSpecs.InputOriginalValues.OperatingSystem; outputOverrideVMSpecsStr[column++] = validatedOverrideVMSpecs.IsValid || isUniqueProjectedList? validatedOverrideVMSpecs.CPUCores.ToString() : validatedOverrideVMSpecs.InputOriginalValues.CPUCores; outputOverrideVMSpecsStr[column++] = validatedOverrideVMSpecs.IsValid || isUniqueProjectedList ? (isOutputMemoryInGB ? Math.Round(validatedOverrideVMSpecs.MemoryInMB / 1024, 2).ToString() : Math.Round(validatedOverrideVMSpecs.MemoryInMB, 2).ToString()) : validatedOverrideVMSpecs.InputOriginalValues.Memory; outputOverrideVMSpecsStr[column++] = validatedOverrideVMSpecs.IsValid || isUniqueProjectedList? validatedOverrideVMSpecs.NumberOfDataDisks.ToString() : validatedOverrideVMSpecs.InputOriginalValues.NumberOfDataDisks; outputOverrideVMSpecsStr[column++] = validatedOverrideVMSpecs.IsValid || isUniqueProjectedList ? (validatedOverrideVMSpecs.HasSSDStorage ? Constants.BoolDisplayValueForTRUE : Constants.BoolDisplayValueForFALSE) : validatedOverrideVMSpecs.InputOriginalValues.HasSSDStorage; outputOverrideVMSpecsStr[column++] = isUniqueProjectedList ? string.Empty : (validatedOverrideVMSpecs.IsValid ? validatedOverrideVMSpecs.AzureVMOverride : validatedOverrideVMSpecs.InputOriginalValues.AzureVMOverride); outputOverrideVMSpecsStr[column++] = validatedOverrideVMSpecs.IsValid || isUniqueProjectedList ? validatedOverrideVMSpecs.AzureProjVMSize : validatedOverrideVMSpecs.InputOriginalValues.AzureProjVMSize; if (isUniqueProjectedList) { outputOverrideVMSpecsStr[column++] = string.IsNullOrWhiteSpace(validatedOverrideVMSpecs.AzureProjVMSize) ? string.Empty : validatedOverrideVMSpecs.AzureProjVMCores.ToString(); outputOverrideVMSpecsStr[column++] = string.IsNullOrWhiteSpace(validatedOverrideVMSpecs.AzureProjVMSize) ? string.Empty : (isOutputMemoryInGB ? Math.Round((double)validatedOverrideVMSpecs.AzureProjVMMemory / 1024, 2).ToString() : validatedOverrideVMSpecs.AzureProjVMMemory.ToString()); } outputOverrideVMSpecsStr[column++] = isUniqueProjectedList ? string.Empty : (validatedOverrideVMSpecs.IsValid ? validatedOverrideVMSpecs.Comments : validatedOverrideVMSpecs.InputOriginalValues.Comments); if (!isUniqueProjectedList) { outputOverrideVMSpecsStr[column++] = validatedOverrideVMSpecs.IsValid ? Constants.BoolDisplayValueForTRUE : Constants.BoolDisplayValueForFALSE; outputOverrideVMSpecsStr[column++] = validatedOverrideVMSpecs.ValidationMessage; } } catch (Exception) { throw; } return(outputOverrideVMSpecsStr); }
/// <summary> /// Validate Comments value from Input Override data /// </summary> /// <param name="inputOverrideVMSpecs">The Input Override specifications</param> private static void ValidateComments(OverrideVMSpecs inputOverrideVMSpecs) { if (!string.IsNullOrWhiteSpace(inputOverrideVMSpecs.InputOriginalValues.Comments)) { if (inputOverrideVMSpecs.InputOriginalValues.Comments.Length <= Constants.MaxLengthComments) { inputOverrideVMSpecs.Comments = inputOverrideVMSpecs.InputOriginalValues.Comments; } else { inputOverrideVMSpecs.Comments = inputOverrideVMSpecs.InputOriginalValues.Comments.Substring(0, Constants.MaxLengthComments); inputOverrideVMSpecs.ValidationMessage += string.Format(ValidationLiterals.SpecExceedsStringLimit, OverrideVMSpecLiterals.Comments, Constants.MaxLengthComments); } } else { inputOverrideVMSpecs.Comments = string.Empty; } }
/// <summary> /// Validate Operating System value from Input Override data /// </summary> /// <param name="inputOverrideVMSpecs">The Input Override VM specifications</param> /// <param name="os_WindowsList">The list of Windows OS keywords</param> /// <param name="os_LinuxList">The list of Linux OS keywords</param> private static void ValidateOperatingSystem(OverrideVMSpecs inputOverrideVMSpecs, List <string> os_WindowsList, List <string> os_LinuxList) { // Operating System Validation if (!string.IsNullOrWhiteSpace(inputOverrideVMSpecs.InputOriginalValues.OperatingSystem)) { // Check if String is any of the "Windows" list - Case insensitive if (os_WindowsList.Any(x => inputOverrideVMSpecs.InputOriginalValues.OperatingSystem.Equals(x, StringComparison.OrdinalIgnoreCase))) { inputOverrideVMSpecs.OperatingSystem = Constants.OSWindows; } else if (os_LinuxList.Any(x => inputOverrideVMSpecs.InputOriginalValues.OperatingSystem.Equals(x, StringComparison.OrdinalIgnoreCase))) { // String is any of the "Linux" list - Case insensitive inputOverrideVMSpecs.OperatingSystem = Constants.OSLinux; } else if (os_WindowsList.Any(x => inputOverrideVMSpecs.InputOriginalValues.OperatingSystem.ToUpper().Contains(x.ToUpper()))) { // String CONTAINS any of the "Windows" list - Case insensitive inputOverrideVMSpecs.OperatingSystem = Constants.OSWindows; inputOverrideVMSpecs.ValidationMessage += string.Format(ValidationLiterals.SpecValueAssumed, OverrideVMSpecLiterals.OperatingSystem, inputOverrideVMSpecs.InputOriginalValues.OperatingSystem, Constants.OSWindows); } else if (os_LinuxList.Any(x => inputOverrideVMSpecs.InputOriginalValues.OperatingSystem.ToUpper().Contains(x.ToUpper()))) { // String CONTAINS any of the "Linux" list - Case insensitive inputOverrideVMSpecs.OperatingSystem = Constants.OSLinux; inputOverrideVMSpecs.ValidationMessage += string.Format(ValidationLiterals.SpecValueAssumed, OverrideVMSpecLiterals.OperatingSystem, inputOverrideVMSpecs.InputOriginalValues.OperatingSystem, Constants.OSLinux); } else { inputOverrideVMSpecs.IsValid = false; inputOverrideVMSpecs.ValidationMessage += string.Format(ValidationLiterals.InvalidSpec, VMSpecLiterals.OperatingSystem); } } else { // Operating System is blank inputOverrideVMSpecs.IsValid = false; inputOverrideVMSpecs.ValidationMessage += string.Format(ValidationLiterals.MissingSpec, OverrideVMSpecLiterals.OperatingSystem); } }
/// <summary> /// Validate Number of Data Disks value from Input Override data /// </summary> /// <param name="inputOverrideVMSpecs">The Input Override specifications</param> private static void ValidateNumberOfDataDisks(OverrideVMSpecs inputOverrideVMSpecs) { // Number of Data Disks Validation if (!string.IsNullOrWhiteSpace(inputOverrideVMSpecs.InputOriginalValues.NumberOfDataDisks)) { int result = 0; if (int.TryParse(inputOverrideVMSpecs.InputOriginalValues.NumberOfDataDisks, out result) && result >= 0) { inputOverrideVMSpecs.NumberOfDataDisks = result; } else { inputOverrideVMSpecs.IsValid = false; inputOverrideVMSpecs.ValidationMessage += string.Format(ValidationLiterals.SpecNotANumber, OverrideVMSpecLiterals.NumberOfDataDisks); } } else { // CPU Cores is blank inputOverrideVMSpecs.IsValid = false; inputOverrideVMSpecs.ValidationMessage += string.Format(ValidationLiterals.MissingSpec, OverrideVMSpecLiterals.NumberOfDataDisks); } }
/// <summary> /// Get the validated Input Override data /// </summary> /// <param name="inputOverrideVMSpecs">The Input Override data to be validated</param> /// <param name="isInputMemoryInGB">A value indicating if the Input memory values are in GB</param> /// <param name="os_WindowsList">The list of Windows OS keywords</param> /// <param name="os_LinuxList">The list of Linux OS keywords</param> /// <returns> Returns the validated Input Override data</returns> public static OverrideVMSpecs ValidateOverrideVMSpecs(OverrideVMSpecs inputOverrideVMSpecs, bool isInputMemoryInGB, List <string> os_WindowsList, List <string> os_LinuxList) { OverrideVMSpecs validatedOverrideVMSpecs = null; try { inputOverrideVMSpecs.IsValid = true; ValidateOperatingSystem(inputOverrideVMSpecs, os_WindowsList, os_LinuxList); ValidateCPUCores(inputOverrideVMSpecs); ValidateMemory(inputOverrideVMSpecs, isInputMemoryInGB); ValidateNumberOfDataDisks(inputOverrideVMSpecs); ValidateHasSSDStorage(inputOverrideVMSpecs); ValidateAzureProjVMSize(inputOverrideVMSpecs); ValidateAzureVMOverride(inputOverrideVMSpecs); ValidateComments(inputOverrideVMSpecs); if (!inputOverrideVMSpecs.IsValid) { inputOverrideVMSpecs.ValidationMessage = ValidationLiterals.SpecValidationFailed + inputOverrideVMSpecs.ValidationMessage; } // Check if last two chars is ", " and remove them if (inputOverrideVMSpecs.ValidationMessage.Length > 2 && inputOverrideVMSpecs.ValidationMessage.Substring(inputOverrideVMSpecs.ValidationMessage.Length - 2).Equals("; ")) { inputOverrideVMSpecs.ValidationMessage = inputOverrideVMSpecs.ValidationMessage.Remove(inputOverrideVMSpecs.ValidationMessage.Length - 2); } validatedOverrideVMSpecs = inputOverrideVMSpecs; } catch (Exception) { throw; } return(validatedOverrideVMSpecs); }
/// <summary> /// Validate CPU Cores value from Input Override data /// </summary> /// <param name="inputOverrideVMSpecs">The Input Override VM specifications</param> private static void ValidateCPUCores(OverrideVMSpecs inputOverrideVMSpecs) { // CPU Cores Validation if (!string.IsNullOrWhiteSpace(inputOverrideVMSpecs.InputOriginalValues.CPUCores)) { int result = 0; if (int.TryParse(inputOverrideVMSpecs.InputOriginalValues.CPUCores, out result) && (result > 0)) { inputOverrideVMSpecs.CPUCores = result; } if (result <= 0) { inputOverrideVMSpecs.IsValid = false; inputOverrideVMSpecs.ValidationMessage += string.Format(ValidationLiterals.SpecNotAPositiveInteger, OverrideVMSpecLiterals.CPUCores); } } else { // CPU Cores is blank inputOverrideVMSpecs.IsValid = false; inputOverrideVMSpecs.ValidationMessage += string.Format(ValidationLiterals.MissingSpec, OverrideVMSpecLiterals.CPUCores); } }
/// <summary> /// Maps the instance to an Azure VM SKU /// </summary> /// <param name="vmRes">The object that will contain the mapping output</param> /// <param name="location">The Azure location</param> /// <param name="azureVMSizeList">The list of Azure VM SKUs</param> /// <param name="rateCalc">The object that can fetch the rates for Azure resources</param> /// <param name="listOfOverrideVMSizes">The list of Input Override Azure VM SKUs if provided</param> /// <param name="mappingCoefficientCoresSelection">Mapping Coefficient for CPU Cores</param> /// <param name="mappingCoefficientMemorySelection">Mapping Coefficient for Memory</param> public static void ProjectAzureVM(VMResult vmRes, string location, List <AzureVMSizeListItem> azureVMSizeList, AzureResourceRateCalc rateCalc, List <OverrideVMSpecs> listOfOverrideVMSizes, double mappingCoefficientCoresSelection, double mappingCoefficientMemorySelection) { AzureVMProjector.rateCalc = rateCalc; AzureVMProjector.location = location; try { int dataDiskCount = 0; dataDiskCount = GetDataDiskCount(vmRes); // Check if Preferred VM Size Exists bool isPreferredVMSizeValid = false; AzureVMSizeListItem vmListItemForMatchedOverride = null; // Override with VM Specific if provided if (!string.IsNullOrWhiteSpace(vmRes.Specs.AzureVMOverride)) { vmListItemForMatchedOverride = azureVMSizeList.Find(x => x.Name.Equals(vmRes.Specs.AzureVMOverride, StringComparison.OrdinalIgnoreCase)); if (vmListItemForMatchedOverride != null) { if (vmListItemForMatchedOverride.MaxDataDiskCount >= dataDiskCount) { isPreferredVMSizeValid = true; vmRes.ProjAzureVM.ComputeHoursRate = GetAzureVMCost(vmListItemForMatchedOverride, vmRes.Specs); vmRes.ProjAzureVM.VMSize = vmListItemForMatchedOverride; vmRes.ProjAzureVM.AzureProjectionComments = AzureVMProjectionCommentsLiterals.ProjectionCommentsVMMapasperSpecificOverride; } else { vmRes.ProjAzureVM.AzureProjectionComments = AzureVMProjectionCommentsLiterals.ProjectionCommentsSpecificOverrideExceedDiskCount; } } else { vmRes.ProjAzureVM.AzureProjectionComments = AzureVMProjectionCommentsLiterals.ProjectionCommentsSpecificOverrideNotFound; } } // Override with generic Override file if match found and not already mapped by specific override value if (!isPreferredVMSizeValid && listOfOverrideVMSizes != null) { OverrideVMSpecs matchedOverrideVMDetails = listOfOverrideVMSizes.Find(x => (x.IsValid && vmRes.Specs.CPUCores == x.CPUCores && vmRes.Specs.MemoryInMB == x.MemoryInMB && vmRes.Specs.OperatingSystem.Equals(x.OperatingSystem, StringComparison.OrdinalIgnoreCase) && ((x.HasSSDStorage && vmRes.Specs.SSDStorageInGB > 0) || (!x.HasSSDStorage && vmRes.Specs.SSDStorageInGB == 0)) && (x.NumberOfDataDisks == dataDiskCount) && !string.IsNullOrWhiteSpace(x.AzureVMOverride))); if (matchedOverrideVMDetails != null) { vmListItemForMatchedOverride = azureVMSizeList.Find(x => x.Name.Equals(matchedOverrideVMDetails.AzureVMOverride, StringComparison.OrdinalIgnoreCase)); if (vmListItemForMatchedOverride != null) { if (vmListItemForMatchedOverride.MaxDataDiskCount >= dataDiskCount) { isPreferredVMSizeValid = true; vmRes.ProjAzureVM.ComputeHoursRate = GetAzureVMCost(vmListItemForMatchedOverride, vmRes.Specs); vmRes.ProjAzureVM.VMSize = vmListItemForMatchedOverride; vmRes.ProjAzureVM.AzureProjectionComments = AzureVMProjectionCommentsLiterals.ProjectionCommentsVMMappedasperGenericOverride; } else { vmRes.ProjAzureVM.AzureProjectionComments = AzureVMProjectionCommentsLiterals.ProjectionCommentsGenericOverrideExceedDiskCount; } } else { vmRes.ProjAzureVM.AzureProjectionComments = AzureVMProjectionCommentsLiterals.ProjectionCommentsGenericOverrideNotFound; } } } // If PreferredVMSize does not exist or if PreferredVMSize is not valid, loop thru' the list to project using projection algorithm if (!isPreferredVMSizeValid) { foreach (AzureVMSizeListItem vmListItem in azureVMSizeList) { bool considerListItem = false; // If Current Azure VM Size does not support Premium Disks and VM contains mapped premium disks - skip the size if (vmRes.ProjAzureVM.PremiumDisks != null && vmRes.ProjAzureVM.PremiumDisks.Count > 0 && !AzureVMMeterHelper.CheckIfAzureVMInstanceTypeIsPremiumSupported(vmListItem)) { continue; } // If Current Azure VM Size does is for Premium Disks and VM contains does not contains premium disks - skip the size if ((vmRes.ProjAzureVM.PremiumDisks == null || (vmRes.ProjAzureVM.PremiumDisks != null && vmRes.ProjAzureVM.PremiumDisks.Count == 0)) && AzureVMMeterHelper.CheckIfAzureVMInstanceTypeIsPremiumSupported(vmListItem)) { continue; } // Skip if number of data disks mapped is more than maximum of current item if (dataDiskCount > vmListItem.MaxDataDiskCount) { continue; } if (vmListItem.NumberOfCores >= mappingCoefficientCoresSelection * vmRes.Specs.CPUCores) { if (vmListItem.MemoryInMB >= mappingCoefficientMemorySelection * vmRes.Specs.MemoryInMB) { considerListItem = true; } } if (considerListItem) { bool mapCurrentItem = false; double currentVMSizeListItemRate = GetAzureVMCost(vmListItem, vmRes.Specs); if (vmRes.ProjAzureVM.VMSize == null) { mapCurrentItem = true; } else { if (vmRes.ProjAzureVM.ComputeHoursRate > currentVMSizeListItemRate) { mapCurrentItem = true; } } if (mapCurrentItem) { vmRes.ProjAzureVM.IsMappedasperOverride = false; vmRes.ProjAzureVM.VMSize = vmListItem; vmRes.ProjAzureVM.ComputeHoursRate = currentVMSizeListItemRate; } } } } else { vmRes.ProjAzureVM.IsMappedasperOverride = true; } if (vmRes.ProjAzureVM.VMSize == null) { vmRes.ProjAzureVM.IsNoMapFound = true; vmRes.ProjAzureVM.AzureProjectionComments = AzureVMProjectionCommentsLiterals.ProjectionCommentsVMCannotbeMapped; } else { vmRes.ProjAzureVM.IsNoMapFound = false; } } catch (Exception) { throw; } }
/// <summary> /// Converts the specified Input Override Specifications data that is in form of strings array to Input Override specifications object /// </summary> /// <param name="inputOverrideVMSpecsStr">String array containing the Input Override specifications</param> /// <param name="sequenceOfInputOverrideVMSpecs">Sequence of Input Override specifications in the input string array provided</param> /// <returns> Returns the Input Override specifications object with data loaded from the strings array</returns> public static OverrideVMSpecs LoadOverrideVMSpecs(string[] inputOverrideVMSpecsStr, OverrideVMSpecsSequenceId[] sequenceOfInputOverrideVMSpecs = null) { OverrideVMSpecs inputOverrideVMSpecs = null; try { OverrideVMSpecs overrideVMSpecsObj = new OverrideVMSpecs(); for (int i = 0; i < sequenceOfInputOverrideVMSpecs.Count(); i++) { switch (sequenceOfInputOverrideVMSpecs[i]) { case OverrideVMSpecsSequenceId.OperatingSystem: overrideVMSpecsObj.InputOriginalValues.OperatingSystem = inputOverrideVMSpecsStr[i]; break; case OverrideVMSpecsSequenceId.CPUCores: overrideVMSpecsObj.InputOriginalValues.CPUCores = inputOverrideVMSpecsStr[i]; break; case OverrideVMSpecsSequenceId.MemoryInMB: overrideVMSpecsObj.InputOriginalValues.Memory = inputOverrideVMSpecsStr[i]; break; case OverrideVMSpecsSequenceId.NumberOfDataDisks: overrideVMSpecsObj.InputOriginalValues.NumberOfDataDisks = inputOverrideVMSpecsStr[i]; break; case OverrideVMSpecsSequenceId.HasSSDStorage: overrideVMSpecsObj.InputOriginalValues.HasSSDStorage = inputOverrideVMSpecsStr[i]; break; case OverrideVMSpecsSequenceId.AzureVMOverride: overrideVMSpecsObj.InputOriginalValues.AzureVMOverride = inputOverrideVMSpecsStr[i]; break; case OverrideVMSpecsSequenceId.AzureProjVMSize: overrideVMSpecsObj.InputOriginalValues.AzureProjVMSize = inputOverrideVMSpecsStr[i]; break; case OverrideVMSpecsSequenceId.AzureProjVMCores: overrideVMSpecsObj.InputOriginalValues.AzureProjVMCores = inputOverrideVMSpecsStr[i]; break; case OverrideVMSpecsSequenceId.AzureProjVMMemory: overrideVMSpecsObj.InputOriginalValues.AzureProjVMMemory = inputOverrideVMSpecsStr[i]; break; case OverrideVMSpecsSequenceId.Comments: overrideVMSpecsObj.InputOriginalValues.Comments = inputOverrideVMSpecsStr[i]; break; default: break; } } inputOverrideVMSpecs = overrideVMSpecsObj; } catch (Exception) { throw; } return(inputOverrideVMSpecs); }