/// <summary>
/// Gets the mapping output object for specified input without Override input value
/// </summary>
/// <param name="res">The mapping output object with input specifications</param>
/// <returns> Returns the mapping output object for specified input without Override input value</returns>
public static VMResult GetVMResultforMapwithoutOverride(VMResult res)
{
VMSpecs specsWithoutOverride = new VMSpecs()
{
InputOriginalValues = null,
InstanceName = string.Empty,
OperatingSystem = res.Specs.OperatingSystem,
CPUCores = res.Specs.CPUCores,
MemoryInMB = res.Specs.MemoryInMB,
SSDStorageInGB = res.Specs.SSDStorageInGB,
SSDNumOfDisks = res.Specs.SSDNumOfDisks,
HDDStorageInGB = res.Specs.HDDStorageInGB,
HDDNumOfDisks = res.Specs.HDDNumOfDisks,
PricePerMonth = 0,
AzureVMOverride = string.Empty,
Comments = string.Empty,
IsValid = true,
ValidationMessage = string.Empty
};
VMResult vmResWithoutInputOverride = new VMResult(specsWithoutOverride);
vmResWithoutInputOverride.ProjAzureVM.PremiumDisks = res.ProjAzureVM.PremiumDisks;
vmResWithoutInputOverride.ProjAzureVM.StandardDisks = res.ProjAzureVM.StandardDisks;
return(vmResWithoutInputOverride);
}
/// <summary>
/// Validate Memory value in Input specifications
/// </summary>
/// <param name="inputVMSpecs">The Input specifications</param>
/// <param name="isInputMemoryInGB">Value indicating if input memory is in GB or not</param>
private static void ValidateMemory(VMSpecs inputVMSpecs, bool isInputMemoryInGB)
{
// Memory validation
if (!string.IsNullOrWhiteSpace(inputVMSpecs.InputOriginalValues.Memory))
{
double result = 0;
if (double.TryParse(inputVMSpecs.InputOriginalValues.Memory, out result) && (result > 0))
{
if (isInputMemoryInGB)
{
inputVMSpecs.MemoryInMB = 1024 * result;
}
else
{
inputVMSpecs.MemoryInMB = result;
}
}
else
{
inputVMSpecs.IsValid = false;
inputVMSpecs.ValidationMessage += string.Format(ValidationLiterals.SpecNotAPositiveNumber, VMSpecLiterals.Memory);
}
}
else
{
// Memory is blank
inputVMSpecs.IsValid = false;
inputVMSpecs.ValidationMessage += string.Format(ValidationLiterals.MissingSpec, VMSpecLiterals.Memory);
}
}
/// <summary>
/// Generates the strings array for the output of VM Specs Sample file
/// </summary>
/// <param name="specs">Object containing the sample data for VM Specs</param>
/// <param name="isOutputMemoryInGB">A value indicating if Memory is in GB or not</param>
/// <returns> Returns the strings array for the output of VM Specs Sample file</returns>
public static String[] UnloadVMSpecsSampleOutput(VMSpecs specs, bool isOutputMemoryInGB)
{
string[] outputVMSpecsStr = new string[NumberOfTotalColumnsVMResult];
try
{
// Write Input VM Specs including validation results columns
int column = 0;
outputVMSpecsStr[column++] = specs.InstanceName;
outputVMSpecsStr[column++] = specs.OperatingSystem;
outputVMSpecsStr[column++] = specs.CPUCores.ToString();
outputVMSpecsStr[column++] = isOutputMemoryInGB ? Math.Round(specs.MemoryInMB / 1024, 2).ToString()
: Math.Round(specs.MemoryInMB, 2).ToString();
outputVMSpecsStr[column++] = Math.Round(specs.SSDStorageInGB, 2).ToString();
outputVMSpecsStr[column++] = specs.SSDNumOfDisks.ToString();
outputVMSpecsStr[column++] = Math.Round(specs.HDDStorageInGB, 2).ToString();
outputVMSpecsStr[column++] = specs.HDDNumOfDisks.ToString();
outputVMSpecsStr[column++] = Math.Round(specs.PricePerMonth, 2).ToString();
outputVMSpecsStr[column++] = specs.AzureVMOverride;
outputVMSpecsStr[column++] = specs.Comments;
}
catch (Exception)
{
throw;
}
return(outputVMSpecsStr);
}
/// <summary>
/// Validate Azure VM SKU Override value in Input specifications
/// </summary>
/// <param name="inputVMSpecs">The Input specifications</param>
private static void ValidateAzureVMOverride(VMSpecs inputVMSpecs)
{
if (!string.IsNullOrWhiteSpace(inputVMSpecs.InputOriginalValues.AzureVMOverride))
{
inputVMSpecs.AzureVMOverride = inputVMSpecs.InputOriginalValues.AzureVMOverride.Length > Constants.MaxLengthAzureVMOverride ?
inputVMSpecs.InputOriginalValues.AzureVMOverride.Substring(0, Constants.MaxLengthAzureVMOverride) : inputVMSpecs.InputOriginalValues.AzureVMOverride;
}
else
{
inputVMSpecs.AzureVMOverride = string.Empty;
}
}
/// <summary>
/// Validate Instance name value in Input specifications
/// </summary>
/// <param name="inputVMSpecs">The Input specifications</param>
private static void ValidateInstanceName(VMSpecs inputVMSpecs)
{
// Instance Name Validation
if (!string.IsNullOrWhiteSpace(inputVMSpecs.InputOriginalValues.InstanceName))
{
inputVMSpecs.InstanceName = inputVMSpecs.InputOriginalValues.InstanceName;
}
else
{
// Instance Name is blank
inputVMSpecs.IsValid = false;
inputVMSpecs.ValidationMessage += string.Format(ValidationLiterals.MissingSpec, VMSpecLiterals.InstanceName);
}
}
/// <summary>
/// Get the Azure VM SKU cost
/// </summary>
/// <param name="vmListItem">The Azure VM SKU</param>
/// <param name="specs">The input specifications</param>
/// <returns> Returns the Azure VM SKU cost</returns>
private static double GetAzureVMCost(AzureVMSizeListItem vmListItem, VMSpecs specs)
{
double rate = 0;
try
{
AzureResourceInfo resourceInfo = AzureVMMeterHelper.GetAzureResourceInfoForAzureVM(vmListItem.Name, specs.OperatingSystem, location);
rate = rateCalc.GetResourceRate(resourceInfo);
}
catch (Exception)
{
throw;
}
return(rate);
}
/// <summary>
/// Validate Comments value in Input specifications
/// </summary>
/// <param name="inputVMSpecs">The Input specifications</param>
private static void ValidateComments(VMSpecs inputVMSpecs)
{
if (!string.IsNullOrWhiteSpace(inputVMSpecs.InputOriginalValues.Comments))
{
if (inputVMSpecs.InputOriginalValues.Comments.Length <= Constants.MaxLengthComments)
{
inputVMSpecs.Comments = inputVMSpecs.InputOriginalValues.Comments;
}
else
{
inputVMSpecs.Comments = inputVMSpecs.InputOriginalValues.Comments.Substring(0, Constants.MaxLengthComments);
inputVMSpecs.ValidationMessage += string.Format(ValidationLiterals.SpecExceedsStringLimit, VMSpecLiterals.Comments, Constants.MaxLengthComments);
}
}
else
{
inputVMSpecs.Comments = string.Empty;
}
}
/// <summary>
/// Validate Price per month value in Input specifications
/// </summary>
/// <param name="inputVMSpecs">The Input specifications</param>
private static void ValidatePricePerMonth(VMSpecs inputVMSpecs)
{
if (!string.IsNullOrWhiteSpace(inputVMSpecs.InputOriginalValues.PricePerMonth))
{
double result = 0;
if (double.TryParse(inputVMSpecs.InputOriginalValues.PricePerMonth, out result) && (result >= 0))
{
inputVMSpecs.PricePerMonth = result;
}
else
{
inputVMSpecs.IsValid = false;
inputVMSpecs.ValidationMessage += string.Format(ValidationLiterals.SpecNotANumber, VMSpecLiterals.PricePerMonth);
}
}
else
{
inputVMSpecs.PricePerMonth = 0;
}
}
/// <summary>
/// Validate HDD Number of Disks value in Input specifications
/// </summary>
/// <param name="inputVMSpecs">The Input specifications</param>
private static void ValidateHDDNumOfDisks(VMSpecs inputVMSpecs)
{
// Number of Data Disks Validation
if (!string.IsNullOrWhiteSpace(inputVMSpecs.InputOriginalValues.HDDNumOfDisks))
{
int result = 0;
if (int.TryParse(inputVMSpecs.InputOriginalValues.HDDNumOfDisks, out result) && result >= 0)
{
inputVMSpecs.HDDNumOfDisks = result;
}
else
{
inputVMSpecs.IsValid = false;
inputVMSpecs.ValidationMessage += string.Format(ValidationLiterals.SpecNotANumber, VMSpecLiterals.HDDNumOfDisks);
}
}
else
{
inputVMSpecs.HDDNumOfDisks = 0;
}
}
/// <summary>
/// Get the validated virtual machine specifications for the data provided
/// </summary>
/// <param name="inputVMSpecs">The Input specifications</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 virtual machine specifications</returns>
public static VMSpecs ValidateVMSpecs(VMSpecs inputVMSpecs, bool isInputMemoryInGB, List <string> os_WindowsList, List <string> os_LinuxList)
{
VMSpecs validatedVMSpecs = null;
try
{
inputVMSpecs.IsValid = true;
ValidateInstanceName(inputVMSpecs);
ValidateOperatingSystem(inputVMSpecs, os_WindowsList, os_LinuxList);
ValidateCPUCores(inputVMSpecs);
ValidateMemory(inputVMSpecs, isInputMemoryInGB);
ValidateSSDStorageInGB(inputVMSpecs);
ValidateSSDNumOfDisks(inputVMSpecs);
ValidateHDDStorageInGB(inputVMSpecs);
ValidateHDDNumOfDisks(inputVMSpecs);
ValidatePricePerMonth(inputVMSpecs);
ValidateAzureVMOverride(inputVMSpecs);
ValidateComments(inputVMSpecs);
if (!inputVMSpecs.IsValid)
{
inputVMSpecs.ValidationMessage = ValidationLiterals.SpecValidationFailed + inputVMSpecs.ValidationMessage;
}
// Check if last two chars is "; " and remove them
if (inputVMSpecs.ValidationMessage.Length > 2 && inputVMSpecs.ValidationMessage.Substring(inputVMSpecs.ValidationMessage.Length - 2).Equals("; "))
{
inputVMSpecs.ValidationMessage = inputVMSpecs.ValidationMessage.Remove(inputVMSpecs.ValidationMessage.Length - 2);
}
validatedVMSpecs = inputVMSpecs;
}
catch (Exception)
{
throw;
}
return(validatedVMSpecs);
}
/// <summary>
/// Validate Operating System value in Input specifications
/// </summary>
/// <param name="inputVMSpecs">The Input 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(VMSpecs inputVMSpecs, List <string> os_WindowsList, List <string> os_LinuxList)
{
// Operating System Validation
if (!string.IsNullOrWhiteSpace(inputVMSpecs.InputOriginalValues.OperatingSystem))
{
// Check if String is any of the "Windows" list - Case insensitive
if (os_WindowsList.Any(x => inputVMSpecs.InputOriginalValues.OperatingSystem.Equals(x, StringComparison.OrdinalIgnoreCase)))
{
inputVMSpecs.OperatingSystem = Constants.OSWindows;
}
else if (os_LinuxList.Any(x => inputVMSpecs.InputOriginalValues.OperatingSystem.Equals(x, StringComparison.OrdinalIgnoreCase)))
{
// String is any of the "Linux" list - Case insensitive
inputVMSpecs.OperatingSystem = Constants.OSLinux;
}
else if (os_WindowsList.Any(x => inputVMSpecs.InputOriginalValues.OperatingSystem.ToUpper().Contains(x.ToUpper())))
{
// String CONTAINS any of the "Windows" list - Case insensitive
inputVMSpecs.OperatingSystem = Constants.OSWindows;
inputVMSpecs.ValidationMessage += string.Format(ValidationLiterals.SpecValueAssumed, VMSpecLiterals.OperatingSystem, inputVMSpecs.InputOriginalValues.OperatingSystem, Constants.OSWindows);
}
else if (os_LinuxList.Any(x => inputVMSpecs.InputOriginalValues.OperatingSystem.ToUpper().Contains(x.ToUpper())))
{
// String CONTAINS any of the "Linux" list - Case insensitive
inputVMSpecs.OperatingSystem = Constants.OSLinux;
inputVMSpecs.ValidationMessage += string.Format(ValidationLiterals.SpecValueAssumed, VMSpecLiterals.OperatingSystem, inputVMSpecs.InputOriginalValues.OperatingSystem, Constants.OSLinux);
}
else
{
inputVMSpecs.IsValid = false;
inputVMSpecs.ValidationMessage += string.Format(ValidationLiterals.InvalidSpec, VMSpecLiterals.OperatingSystem);
}
}
else
{
// Operating System is blank
inputVMSpecs.IsValid = false;
inputVMSpecs.ValidationMessage += string.Format(ValidationLiterals.MissingSpec, VMSpecLiterals.OperatingSystem);
}
}
/// <summary>
/// Maps the storage to managed disks
/// </summary>
/// <param name="specs">the object containing the input specifications</param>
/// <param name="vmRes">the mapping output object</param>
/// <param name="osDiskSSDSelection">The size of the OS Disk to be mapped if SSD</param>
/// <param name="osDiskHDDSelection">The size of the OS Disk to be mapped if HDD</param>
public static void MapStorage(VMSpecs specs, VMResult vmRes, string osDiskSSDSelection, string osDiskHDDSelection)
{
try
{
bool isOSDiskPremium = specs.SSDStorageInGB > 0 ? true : false;
if (specs.SSDStorageInGB > 0)
{
vmRes.ProjAzureVM.PremiumDisks = MapStorageToManagedDisks(premiumManagedDiskList, specs.SSDStorageInGB, specs.SSDNumOfDisks, isOSDiskPremium);
}
if (specs.HDDStorageInGB > 0)
{
vmRes.ProjAzureVM.StandardDisks = MapStorageToManagedDisks(standardManagedDiskList, specs.HDDStorageInGB, specs.HDDNumOfDisks, !isOSDiskPremium);
}
if (isOSDiskPremium)
{
vmRes.ProjAzureVM.PremiumDisks = AddOSDisk(premiumManagedDiskList, vmRes.ProjAzureVM.PremiumDisks, osDiskSSDSelection);
}
else
{
vmRes.ProjAzureVM.StandardDisks = AddOSDisk(standardManagedDiskList, vmRes.ProjAzureVM.StandardDisks, osDiskHDDSelection);
}
if (vmRes.ProjAzureVM.PremiumDisks != null && vmRes.ProjAzureVM.PremiumDisks.Count > 0)
{
vmRes.ProjAzureVM.PremiumDisksStr = GetDiskListStr(vmRes.ProjAzureVM.PremiumDisks);
}
if (vmRes.ProjAzureVM.StandardDisks != null && vmRes.ProjAzureVM.StandardDisks.Count > 0)
{
vmRes.ProjAzureVM.StandardDisksStr = GetDiskListStr(vmRes.ProjAzureVM.StandardDisks);
}
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// Validate CPU Cores value in Input specifications
/// </summary>
/// <param name="inputVMSpecs">The Input specifications</param>
private static void ValidateCPUCores(VMSpecs inputVMSpecs)
{
// CPU Cores Validation
if (!string.IsNullOrWhiteSpace(inputVMSpecs.InputOriginalValues.CPUCores))
{
int result = 0;
if (int.TryParse(inputVMSpecs.InputOriginalValues.CPUCores, out result) && (result > 0))
{
inputVMSpecs.CPUCores = result;
}
if (result <= 0)
{
inputVMSpecs.IsValid = false;
inputVMSpecs.ValidationMessage += string.Format(ValidationLiterals.SpecNotAPositiveInteger, VMSpecLiterals.CPUCores);
}
}
else
{
// CPU Cores is blank
inputVMSpecs.IsValid = false;
inputVMSpecs.ValidationMessage += string.Format(ValidationLiterals.MissingSpec, VMSpecLiterals.CPUCores);
}
}
/// <summary>
/// Converts the specified Input Specifications data that is in form of strings array to Input specifications object
/// </summary>
/// <param name="inputVMSpecsStr">String array containing the Input specifications</param>
/// <param name="sequenceOfInputVMSpecs">Sequence of Input specifications in the input string array provided</param>
/// <returns> Returns the Input specifications object with data loaded from the strings array</returns>
public static VMSpecs LoadVMSpecs(string[] inputVMSpecsStr, VMSpecsSequenceId[] sequenceOfInputVMSpecs)
{
VMSpecs inputVMSpecs = null;
try
{
VMSpecs vmSpecsObj = new VMSpecs();
for (int i = 0; i < sequenceOfInputVMSpecs.Count(); i++)
{
switch (sequenceOfInputVMSpecs[i])
{
case VMSpecsSequenceId.InstanceName:
vmSpecsObj.InputOriginalValues.InstanceName = inputVMSpecsStr[i];
break;
case VMSpecsSequenceId.OperatingSystem:
vmSpecsObj.InputOriginalValues.OperatingSystem = inputVMSpecsStr[i];
break;
case VMSpecsSequenceId.CPUCores:
vmSpecsObj.InputOriginalValues.CPUCores = inputVMSpecsStr[i];
break;
case VMSpecsSequenceId.MemoryInMB:
vmSpecsObj.InputOriginalValues.Memory = inputVMSpecsStr[i];
break;
case VMSpecsSequenceId.SSDStorageInGB:
vmSpecsObj.InputOriginalValues.SSDStorageInGB = inputVMSpecsStr[i];
break;
case VMSpecsSequenceId.SSDNumOfDisks:
vmSpecsObj.InputOriginalValues.SSDNumOfDisks = inputVMSpecsStr[i];
break;
case VMSpecsSequenceId.HDDStorageInGB:
vmSpecsObj.InputOriginalValues.HDDStorageInGB = inputVMSpecsStr[i];
break;
case VMSpecsSequenceId.HDDNumOfDisks:
vmSpecsObj.InputOriginalValues.HDDNumOfDisks = inputVMSpecsStr[i];
break;
case VMSpecsSequenceId.PricePerMonth:
vmSpecsObj.InputOriginalValues.PricePerMonth = inputVMSpecsStr[i];
break;
case VMSpecsSequenceId.AzureVMOverride:
vmSpecsObj.InputOriginalValues.AzureVMOverride = inputVMSpecsStr[i];
break;
case VMSpecsSequenceId.Comments:
vmSpecsObj.InputOriginalValues.Comments = inputVMSpecsStr[i];
break;
default:
break;
}
}
inputVMSpecs = vmSpecsObj;
}
catch (Exception)
{
throw;
}
return(inputVMSpecs);
}
