public async Task <VmExtendedDto> GetExtendedInfo(string resourceGroupName, string resourceName, CancellationToken cancellationToken = default)
{
var vm = await GetInternalAsync(resourceGroupName, resourceName);
var result = new VmExtendedDto
{
PowerState = AzureVmUtil.GetPowerState(vm),
OsType = AzureVmUtil.GetOsType(vm)
};
if (vm == null)
{
return(result);
}
result.SizeName = vm.Size.ToString();
await DecorateWithNetworkProperties(vm, result, cancellationToken);
result.Disks.Add(await CreateDiskDto(vm.OSDiskId, true, cancellationToken));
foreach (var curDiskKvp in vm.DataDisks.Values)
{
result.Disks.Add(CreateDiskDto(curDiskKvp, false));
}
return(result);
}
async Task <string> CreateVmSettingsString(string region, int vmId, int studyId, int sandboxId, VirtualMachineCreateDto userInput)
{
var vmSettings = _mapper.Map <VmSettingsDto>(userInput);
var availableOs = await _virtualMachineOperatingSystemService.AvailableOperatingSystems(region);
vmSettings.OperatingSystemCategory = AzureVmUtil.GetOsCategory(availableOs, vmSettings.OperatingSystem);
vmSettings.Password = await StoreNewVmPasswordAsKeyVaultSecretAndReturnReference(studyId, sandboxId, vmSettings.Password);
var diagStorageResource = await CloudResourceQueries.GetDiagStorageAccountEntry(_db, sandboxId);
vmSettings.DiagnosticStorageAccountName = diagStorageResource.ResourceName;
var networkResource = await CloudResourceQueries.GetNetworkEntry(_db, sandboxId);
vmSettings.NetworkName = networkResource.ResourceName;
var networkSetting = CloudResourceConfigStringSerializer.NetworkSettings(networkResource.ConfigString);
vmSettings.SubnetName = networkSetting.SandboxSubnetName;
vmSettings.Rules = VmRuleUtils.CreateInitialVmRules(vmId);
return(CloudResourceConfigStringSerializer.Serialize(vmSettings));
}
public void Vm_getDiskSize_shouldReturnGBDiskSize()
{
var result = AzureVmUtil.GetDiskSizeDisplayTextForDropdown(5);
var expectedResult = "5 GB";
Assert.Equal(expectedResult, result);
}
public void Vm_getOsCategory_shouldThrowWithcorrectMessage()
{
List <VmOsDto> osList = new List <VmOsDto>();
osList.Add(new VmOsDto()
{
Key = "windows1", Category = "test1", DisplayValue = "disp1"
});
var ex = Assert.Throws <Exception>(() => AzureVmUtil.GetOsCategory(osList, "asdasas"));
Assert.Equal("Unable to find Operating System record in list of available", ex.Message);
}
void ThrowIfRuleExists(List <VmRuleDto> rules, VmRuleDto ruleToCompare)
{
if (rules != null)
{
foreach (var curExistingRule in rules)
{
if (AzureVmUtil.IsSameRule(ruleToCompare, curExistingRule))
{
throw new Exception($"Same rule allready exists");
}
}
}
}
public void VmRule_IsSameRule_witthDifferentRules_shouldBeFalse()
{
var rule1 = new VmRuleDto()
{
Direction = 0, Protocol = "tcp", Ip = "192.168.1.1", Port = 443
};
var rule2 = new VmRuleDto()
{
Direction = 0, Protocol = "tcp", Ip = "192.168.1.1", Port = 80
};
var result = AzureVmUtil.IsSameRule(rule1, rule2);
Assert.False(result);
}
public void VmRule_IsSameRule_withSameRule_shouldBeTrue()
{
var rule1 = new VmRuleDto()
{
Direction = 0, Protocol = "tcp", Ip = "192.168.1.1", Port = 443
};
var rule2 = new VmRuleDto()
{
Direction = 0, Protocol = "tcp", Ip = "192.168.1.1", Port = 443
};
var result = AzureVmUtil.IsSameRule(rule1, rule2);
Assert.True(result);
}
public void Vm_getOsCategory_shouldReturnExpectedResult()
{
List <VmOsDto> osList = new List <VmOsDto>();
osList.Add(new VmOsDto()
{
Key = "windows1", Category = "test1", DisplayValue = "disp1"
});
var result = AzureVmUtil.GetOsCategory(osList, "windows1");
var expectedResult = "test1";
Assert.Equal(expectedResult, result);
}
public async Task Import(CancellationToken cancellationToken = default)
{
var currentUser = await _userService.GetCurrentUserAsync();
var regionsFromDb = await _db.Regions.Include(r => r.DiskSizeAssociations).ThenInclude(va => va.DiskSize).Where(r => !r.Disabled).ToListAsync();
if (regionsFromDb.Count() == 0)
{
throw new Exception($"Could not update Vm Disk Cache, No regions found in DB");
}
var diskEntriesFromAzure = await _azureDiskPriceService.GetDiskPrices(cancellationToken : cancellationToken);
if (diskEntriesFromAzure == null || (diskEntriesFromAzure != null && diskEntriesFromAzure.Count() == 0))
{
throw new Exception("No VM Disk Size and Price found in Azure");
}
foreach (var curRegionFromDb in regionsFromDb)
{
_logger.LogInformation($"Updating VM Disk Cache for Region: {curRegionFromDb.Key}");
try
{
if (diskEntriesFromAzure.TryGetValue(curRegionFromDb.KeyInPriceApi, out AzureDiskPriceForRegion diskSizesForRegion))
{
_logger.LogInformation($"Updating VM Size Cache for Region: {curRegionFromDb.Key}. Found {diskSizesForRegion.Types.Count} Disk sizes for region");
var existingDbItemsForRegion = curRegionFromDb.DiskSizeAssociations.ToDictionary(r => r.DiskSize.Key, r => r.DiskSize);
var validDiskSizesFromAzure = new HashSet <string>();
DiskSize curDiskSizeInDb;
foreach (var curDiskSizeForRegion in diskSizesForRegion.Types)
{
if (existingDbItemsForRegion.TryGetValue(curDiskSizeForRegion.Key, out curDiskSizeInDb))
{
//Get updated price for VM Size
var regionAssociation = curDiskSizeInDb.RegionAssociations.Where(ra => ra.RegionKey == curRegionFromDb.Key).SingleOrDefault();
regionAssociation.Price = curDiskSizeForRegion.Value.price;
await _db.SaveChangesAsync();
validDiskSizesFromAzure.Add(curDiskSizeInDb.Key);
}
else
{
//Size item might exist in db for other region
curDiskSizeInDb = await _db.DiskSizes.FirstOrDefaultAsync(r => r.Key == curDiskSizeForRegion.Key);
if (curDiskSizeInDb == null)
{
curDiskSizeInDb = new DiskSize()
{
Key = curDiskSizeForRegion.Key,
Size = curDiskSizeForRegion.Value.size,
DisplayText = AzureVmUtil.GetDiskSizeDisplayTextForDropdown(curDiskSizeForRegion.Value.size),
CreatedBy = currentUser.UserName
};
}
;
//Add to lookup
existingDbItemsForRegion.Add(curDiskSizeForRegion.Key, curDiskSizeInDb);
//Add to DB
curRegionFromDb.DiskSizeAssociations.Add(new RegionDiskSize()
{
Region = curRegionFromDb, DiskSize = curDiskSizeInDb, Price = curDiskSizeForRegion.Value.price
});
await _db.SaveChangesAsync();
validDiskSizesFromAzure.Add(curDiskSizeForRegion.Key);
}
}
//Delete those that are no longer present in Azure, or that does not pass the filter
foreach (var curDbDiskSize in existingDbItemsForRegion.Values)
{
if (!validDiskSizesFromAzure.Contains(curDbDiskSize.Key))
{
var toRemoveFromDb = curRegionFromDb.DiskSizeAssociations.FirstOrDefault(ra => ra.VmDiskKey == curDbDiskSize.Key);
if (toRemoveFromDb != null)
{
curRegionFromDb.DiskSizeAssociations.Remove(toRemoveFromDb);
}
}
}
await _db.SaveChangesAsync();
_logger.LogInformation($"Done updating VM Disk Size and Price Cache for Region: {curRegionFromDb.Name}");
}
else
{
_logger.LogError($"Update VM Size cache: Unable to update Size cache for Region {curRegionFromDb.Key}. No items for region in response");
}
}
catch (Exception ex)
{
_logger.LogError($"Update VM Size cache: Unable to update Size cache for Region {curRegionFromDb.Key}. Se inner exception for details", ex);
continue;
}
}
_logger.LogInformation($"Deleting Disk size entries not associated with any region");
foreach (var curDiskSize in await _db.DiskSizes.Include(s => s.RegionAssociations).ToListAsync())
{
if (curDiskSize.RegionAssociations == null || (curDiskSize.RegionAssociations != null && curDiskSize.RegionAssociations.Count == 0))
{
_db.DiskSizes.Remove(curDiskSize);
}
}
await _db.SaveChangesAsync();
_logger.LogInformation($"Done updating VM Disk size cache");
}
public void Vm_getSizeCategory_ShouldReturn_string(string vmName, string expectedResult)
{
var result = AzureVmUtil.GetSizeCategory(vmName);
Assert.Equal(expectedResult, result);
}
public void Vm_getPowerState_WithNull_shouldReturnString()
{
var result = AzureVmUtil.GetPowerState(null);
Assert.Equal("not found", result);
}
public void Vm_getOsCategory_WithNullasOsList_shouldThrowWithcorrectMessage()
{
var ex = Assert.Throws <ArgumentException>(() => AzureVmUtil.GetOsCategory(null, "aaa"));
Assert.Equal("List of OS is null", ex.Message);
}
public async Task UpdateVmSizeCache(CancellationToken cancellationToken = default)
{
var currentUser = await _userService.GetCurrentUserAsync();
var regionsFromDb = await _db.Regions.Include(r => r.VmSizeAssociations).ThenInclude(va => va.VmSize).Where(r => !r.Disabled).ToListAsync();
if (regionsFromDb == null || (regionsFromDb != null & regionsFromDb.Count() == 0))
{
throw new Exception($"Could not update Vm Size Cache, No regions found in DB");
}
foreach (var curRegionFromDb in regionsFromDb)
{
_logger.LogInformation($"Updating VM Size Cache for Region: {curRegionFromDb.Key}");
try
{
var resourceSkusFromAzure = await _azureResourceSkuService.GetSKUsForRegion(curRegionFromDb.Key, "virtualMachines", filterBasedOnResponseRestrictions : true, cancellationToken);
if (resourceSkusFromAzure == null || (resourceSkusFromAzure != null && resourceSkusFromAzure.Count() == 0))
{
throw new Exception($"No VM SKUs found in Azure for region {curRegionFromDb.Key}");
}
_logger.LogInformation($"Updating VM Size Cache for Region: {curRegionFromDb.Key}. Found {resourceSkusFromAzure.Count()} SKUs for region");
var existingSizeItemsForRegion = curRegionFromDb.VmSizeAssociations.ToDictionary(r => r.VmSize.Key, r => r.VmSize);
var validSkusFromAzure = new HashSet <string>();
VmSize curVmSizeInDb;
foreach (var curAzureSku in resourceSkusFromAzure)
{
if (existingSizeItemsForRegion.TryGetValue(curAzureSku.Name, out curVmSizeInDb))
{
curVmSizeInDb.Category = AzureVmUtil.GetSizeCategory(curAzureSku.Name);
if (ShouldBeExcluded(curVmSizeInDb))
{
var toRemoveFromDb = curRegionFromDb.VmSizeAssociations.FirstOrDefault(ra => ra.VmSizeKey == curVmSizeInDb.Key);
curRegionFromDb.VmSizeAssociations.Remove(toRemoveFromDb);
await _db.SaveChangesAsync();
continue;
}
else
{
PopulateVmSizeProps(curAzureSku, curVmSizeInDb);
curVmSizeInDb.DisplayText = VmSizeUtil.GetDisplayTextSizeForDropdown(curVmSizeInDb);
//Get updated price for VM Size and set on db entry
var regionAssociation = curVmSizeInDb.RegionAssociations.Where(ra => ra.RegionKey == curRegionFromDb.Key).SingleOrDefault();
regionAssociation.Price = await _azureCostManagementService.GetVmPrice(curRegionFromDb.Key, curVmSizeInDb.Key);
await _db.SaveChangesAsync();
validSkusFromAzure.Add(curVmSizeInDb.Key);
}
}
else
{
//Size item might exist in db for other region
curVmSizeInDb = await _db.VmSizes.FirstOrDefaultAsync(r => r.Key == curAzureSku.Name);
if (curVmSizeInDb == null)
{
curVmSizeInDb = new VmSize()
{
Key = curAzureSku.Name, CreatedBy = currentUser.UserName, Category = AzureVmUtil.GetSizeCategory(curAzureSku.Name)
};
}
else
{
curVmSizeInDb.Category = AzureVmUtil.GetSizeCategory(curAzureSku.Name);
}
if (ShouldBeExcluded(curVmSizeInDb))
{
//Dont want to include these
continue;
}
PopulateVmSizeProps(curAzureSku, curVmSizeInDb);
curVmSizeInDb.DisplayText = VmSizeUtil.GetDisplayTextSizeForDropdown(curVmSizeInDb);
//Add to lookup
existingSizeItemsForRegion.Add(curAzureSku.Name, curVmSizeInDb);
var priceOfVm = await _azureCostManagementService.GetVmPrice(curRegionFromDb.Key, curVmSizeInDb.Key);
//Add to DB
curRegionFromDb.VmSizeAssociations.Add(new RegionVmSize()
{
Region = curRegionFromDb, VmSize = curVmSizeInDb, Price = priceOfVm
});
await _db.SaveChangesAsync();
validSkusFromAzure.Add(curVmSizeInDb.Key);
}
}
//Delete those that are no longer present in Azure, or that does not pass the filter
foreach (var curDbSize in existingSizeItemsForRegion.Values)
{
if (!validSkusFromAzure.Contains(curDbSize.Key))
{
var toRemoveFromDb = curRegionFromDb.VmSizeAssociations.FirstOrDefault(ra => ra.VmSizeKey == curDbSize.Key);
if (toRemoveFromDb != null)
{
curRegionFromDb.VmSizeAssociations.Remove(toRemoveFromDb);
}
}
}
await _db.SaveChangesAsync();
_logger.LogInformation($"Done updating VM Size Cache for Region: {curRegionFromDb.Name}");
}
catch (Exception ex)
{
_logger.LogError($"Update VM Size cache: Unable to update Size cache for Region {curRegionFromDb.Key}. Se inner exception for details", ex);
continue;
}
}
_logger.LogInformation($"Deleting Vm Size entries not associated with any region");
foreach (var curVmSize in await _db.VmSizes.Include(s => s.RegionAssociations).ToListAsync())
{
if (curVmSize.RegionAssociations == null || (curVmSize.RegionAssociations != null && curVmSize.RegionAssociations.Count == 0))
{
_db.VmSizes.Remove(curVmSize);
}
}
await _db.SaveChangesAsync();
//TODO: Delete size records with no associated region?
_logger.LogInformation($"Done updating VM Size Cache");
}
