/// <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);
}
