private void ValidateVMDisk(MigrationTarget.Disk targetDisk)
{
if (targetDisk.IsManagedDisk)
{
// All Managed Disks are included in the Export Artifacts, so we aren't including a call here to ValidateDiskStandards for Managed Disks.
// Only non Managed Disks are validated against Disk Standards below.
// VM References a managed disk, ensure it is included in the Export Artifacts
bool targetDiskInExport = false;
foreach (Azure.MigrationTarget.Disk exportDisk in this.Disks)
{
if (targetDisk.SourceName == exportDisk.SourceName)
{
targetDiskInExport = true;
}
}
if (!targetDiskInExport && targetDisk.ParentVirtualMachine != null)
{
this.AddAlert(AlertType.Error, "Virtual Machine '" + targetDisk.ParentVirtualMachine.SourceName + "' references Managed Disk '" + targetDisk.SourceName + "' which has not been added as an export resource.", targetDisk.ParentVirtualMachine);
}
}
else
{
// We are calling Validate Disk Standards here (only for non-managed disks, as noted above) as all Managed Disks are validated for Disk Standards through the ExportArtifacts.Disks Collection
ValidateDiskStandards(targetDisk);
}
}
private void ValidateDiskStandards(MigrationTarget.Disk targetDisk)
{
if (targetDisk.DiskSizeInGB == 0)
{
this.AddAlert(AlertType.Error, "Disk '" + targetDisk.ToString() + "' does not have a Disk Size defined. Disk Size (not to exceed 4095 GB) is required.", targetDisk);
}
if (targetDisk.IsSmallerThanSourceDisk)
{
this.AddAlert(AlertType.Error, "Disk '" + targetDisk.ToString() + "' Size of " + targetDisk.DiskSizeInGB.ToString() + " GB cannot be smaller than the source Disk Size of " + targetDisk.SourceDisk.DiskSizeGb.ToString() + " GB.", targetDisk);
}
if (targetDisk.IsTargetLunDifferentThanSourceLun)
{
this.AddAlert(AlertType.Warning, "Disk '" + targetDisk.ToString() + "' target LUN " + targetDisk.Lun.ToString() + " does not match the source LUN " + targetDisk.SourceDisk.Lun.ToString() + ".", targetDisk);
}
if (targetDisk.SourceDisk != null && targetDisk.SourceDisk.GetType() == typeof(Azure.Arm.ClassicDisk))
{
if (targetDisk.SourceDisk.IsEncrypted)
{
this.AddAlert(AlertType.Error, "Disk '" + targetDisk.ToString() + "' is encrypted. MigAz does not contain support for moving encrypted Azure Compute VMs.", targetDisk);
}
}
if (targetDisk.TargetStorage == null)
{
this.AddAlert(AlertType.Error, "Disk '" + targetDisk.ToString() + "' Target Storage must be specified.", targetDisk);
}
else
{
if (targetDisk.TargetStorage.GetType() == typeof(Azure.Arm.StorageAccount))
{
Arm.StorageAccount armStorageAccount = (Arm.StorageAccount)targetDisk.TargetStorage;
if (armStorageAccount.Location.Name != this.ResourceGroup.TargetLocation.Name)
{
this.AddAlert(AlertType.Error, "Target Storage Account '" + armStorageAccount.Name + "' is not in the same region (" + armStorageAccount.Location.Name + ") as the Target Resource Group '" + this.ResourceGroup.ToString() + "' (" + this.ResourceGroup.TargetLocation.Name + ").", targetDisk);
}
}
//else if (targetDisk.TargetStorage.GetType() == typeof(Azure.MigrationTarget.StorageAccount))
//{
// Azure.MigrationTarget.StorageAccount targetStorageAccount = (Azure.MigrationTarget.StorageAccount)targetDisk.TargetStorage;
// bool targetStorageExists = false;
// foreach (Azure.MigrationTarget.StorageAccount storageAccount in this.StorageAccounts)
// {
// if (storageAccount.ToString() == targetStorageAccount.ToString())
// {
// targetStorageExists = true;
// break;
// }
// }
// if (!targetStorageExists)
// this.AddAlert(AlertType.Error, "Target Storage Account '" + targetStorageAccount.ToString() + "' for Disk '" + targetDisk.ToString() + "' is invalid, as it is not included in the migration / template.", targetDisk);
//}
if (targetDisk.TargetStorage.GetType() == typeof(Azure.MigrationTarget.StorageAccount) ||
targetDisk.TargetStorage.GetType() == typeof(Azure.Arm.StorageAccount))
{
if (targetDisk.TargetStorageAccountBlob == null || targetDisk.TargetStorageAccountBlob.Trim().Length == 0)
{
this.AddAlert(AlertType.Error, "Target Storage Blob Name is required.", targetDisk);
}
else if (!targetDisk.TargetStorageAccountBlob.ToLower().EndsWith(".vhd"))
{
this.AddAlert(AlertType.Error, "Target Storage Blob Name '" + targetDisk.TargetStorageAccountBlob + "' for Disk is invalid, as it must end with '.vhd'.", targetDisk);
}
}
if (targetDisk.TargetStorage.StorageAccountType == StorageAccountType.Premium_LRS)
{
if (targetDisk.DiskSizeInGB > 0 && targetDisk.DiskSizeInGB < 32)
{
this.AddAlert(AlertType.Recommendation, "Consider using disk size 32GB (P4), as this disk will be billed at that capacity per Azure Premium Storage billing sizes.", targetDisk);
}
else if (targetDisk.DiskSizeInGB > 32 && targetDisk.DiskSizeInGB < 64)
{
this.AddAlert(AlertType.Recommendation, "Consider using disk size 64GB (P6), as this disk will be billed at that capacity per Azure Premium Storage billing sizes.", targetDisk);
}
else if (targetDisk.DiskSizeInGB > 64 && targetDisk.DiskSizeInGB < 128)
{
this.AddAlert(AlertType.Recommendation, "Consider using disk size 128GB (P10), as this disk will be billed at that capacity per Azure Premium Storage billing sizes.", targetDisk);
}
else if (targetDisk.DiskSizeInGB > 128 && targetDisk.DiskSizeInGB < 512)
{
this.AddAlert(AlertType.Recommendation, "Consider using disk size 512GB (P20), as this disk will be billed at that capacity per Azure Premium Storage billing sizes.", targetDisk);
}
else if (targetDisk.DiskSizeInGB > 512 && targetDisk.DiskSizeInGB < 1023)
{
this.AddAlert(AlertType.Recommendation, "Consider using disk size 1023GB (P30), as this disk will be billed at that capacity per Azure Premium Storage billing sizes.", targetDisk);
}
else if (targetDisk.DiskSizeInGB > 1023 && targetDisk.DiskSizeInGB < 2047)
{
this.AddAlert(AlertType.Recommendation, "Consider using disk size 2047GB (P40), as this disk will be billed at that capacity per Azure Premium Storage billing sizes.", targetDisk);
}
else if (targetDisk.DiskSizeInGB > 2047 && targetDisk.DiskSizeInGB < 4095)
{
this.AddAlert(AlertType.Recommendation, "Consider using disk size 4095GB (P50), as this disk will be billed at that capacity per Azure Premium Storage billing sizes.", targetDisk);
}
}
}
}
public VirtualMachine(Asm.VirtualMachine virtualMachine, TargetSettings targetSettings) : base(ArmConst.MicrosoftCompute, ArmConst.VirtualMachines)
{
this.Source = virtualMachine;
this.SetTargetName(virtualMachine.RoleName, targetSettings);
this.OSVirtualHardDisk = new Disk(virtualMachine.OSVirtualHardDisk, this, targetSettings);
this.OSVirtualHardDiskOS = virtualMachine.OSVirtualHardDiskOS;
if (targetSettings.DefaultTargetDiskType == ArmDiskType.ClassicDisk)
{
this.OSVirtualHardDisk.TargetStorage = SeekTargetStorageAccount(virtualMachine.AzureSubscription.AsmTargetStorageAccounts, virtualMachine.OSVirtualHardDisk.StorageAccountName);
}
foreach (Asm.Disk asmDataDisk in virtualMachine.DataDisks)
{
Disk targetDataDisk = new Disk(asmDataDisk, this, targetSettings);
EnsureDataDiskTargetLunIsNotNull(ref targetDataDisk);
if (targetSettings.DefaultTargetDiskType == ArmDiskType.ClassicDisk)
{
targetDataDisk.TargetStorage = SeekTargetStorageAccount(virtualMachine.AzureSubscription.AsmTargetStorageAccounts, asmDataDisk.StorageAccountName);
}
this.DataDisks.Add(targetDataDisk);
}
foreach (Asm.NetworkInterface asmNetworkInterface in virtualMachine.NetworkInterfaces)
{
NetworkInterface migrationNetworkInterface = new NetworkInterface(virtualMachine, asmNetworkInterface, virtualMachine.AzureSubscription.AsmTargetVirtualNetworks, virtualMachine.AzureSubscription.AsmTargetNetworkSecurityGroups, targetSettings);
migrationNetworkInterface.ParentVirtualMachine = this;
this.NetworkInterfaces.Add(migrationNetworkInterface);
}
#region Seek ARM Target Size
// Get ARM Based Location (that matches location of Source ASM VM
Arm.Location armLocation = virtualMachine.AzureSubscription.GetAzureARMLocation(virtualMachine.Location);
if (armLocation != null)
{
this.TargetSize = armLocation.SeekVmSize(virtualMachine.RoleSize.Name);
if (this.TargetSize == null)
{
// if not found, defer to alternate matching options
Dictionary <string, string> VMSizeTable = new Dictionary <string, string>();
VMSizeTable.Add("ExtraSmall", "Standard_A0");
VMSizeTable.Add("Small", "Standard_A1");
VMSizeTable.Add("Medium", "Standard_A2");
VMSizeTable.Add("Large", "Standard_A3");
VMSizeTable.Add("ExtraLarge", "Standard_A4");
VMSizeTable.Add("A5", "Standard_A5");
VMSizeTable.Add("A6", "Standard_A6");
VMSizeTable.Add("A7", "Standard_A7");
VMSizeTable.Add("A8", "Standard_A8");
VMSizeTable.Add("A9", "Standard_A9");
VMSizeTable.Add("A10", "Standard_A10");
VMSizeTable.Add("A11", "Standard_A11");
if (VMSizeTable.ContainsKey(virtualMachine.RoleSize.Name))
{
this.TargetSize = armLocation.SeekVmSize(VMSizeTable[virtualMachine.RoleSize.Name]);
}
}
}
#endregion
}
public VirtualMachine(Arm.VirtualMachine virtualMachine, TargetSettings targetSettings) : base(ArmConst.MicrosoftCompute, ArmConst.VirtualMachines)
{
this.Source = virtualMachine;
this.SetTargetName(virtualMachine.Name, targetSettings);
this.TargetSize = virtualMachine.VmSize;
this.OSVirtualHardDiskOS = virtualMachine.OSVirtualHardDiskOS;
if (virtualMachine.OSVirtualHardDisk != null && virtualMachine.OSVirtualHardDisk.GetType() == typeof(Azure.Arm.ManagedDisk))
{
Azure.Arm.ManagedDisk sourceManagedDisk = (Azure.Arm.ManagedDisk)virtualMachine.OSVirtualHardDisk;
foreach (Disk targetDisk in virtualMachine.AzureSubscription.ArmTargetManagedDisks)
{
if ((targetDisk.SourceDisk != null) && (targetDisk.SourceDisk.GetType() == typeof(Azure.Arm.ManagedDisk)))
{
Azure.Arm.ManagedDisk targetDiskSourceDisk = (Azure.Arm.ManagedDisk)targetDisk.SourceDisk;
if (String.Compare(targetDiskSourceDisk.Name, sourceManagedDisk.Name, true) == 0)
{
this.OSVirtualHardDisk = targetDisk;
targetDisk.ParentVirtualMachine = this;
targetDisk.HostCaching = sourceManagedDisk.HostCaching;
break;
}
}
}
}
else
{
if (virtualMachine.OSVirtualHardDisk != null)
{
this.OSVirtualHardDisk = new Disk(virtualMachine.OSVirtualHardDisk, this, targetSettings);
}
}
if (virtualMachine.OSVirtualHardDisk != null && virtualMachine.OSVirtualHardDisk.GetType() == typeof(Arm.ClassicDisk))
{
Arm.ClassicDisk armDisk = (Arm.ClassicDisk)virtualMachine.OSVirtualHardDisk;
if (targetSettings.DefaultTargetDiskType == ArmDiskType.ClassicDisk)
{
this.OSVirtualHardDisk.TargetStorage = SeekTargetStorageAccount(virtualMachine.AzureSubscription.ArmTargetStorageAccounts, armDisk.StorageAccountName);
}
}
foreach (IArmDisk dataDisk in virtualMachine.DataDisks)
{
if (dataDisk.GetType() == typeof(Azure.Arm.ManagedDisk))
{
Azure.Arm.ManagedDisk sourceManagedDisk = (Azure.Arm.ManagedDisk)dataDisk;
MigrationTarget.Disk targetDataDisk = null;
foreach (Disk targetDisk in virtualMachine.AzureSubscription.ArmTargetManagedDisks)
{
if ((targetDisk.SourceDisk != null) && (targetDisk.SourceDisk.GetType() == typeof(Azure.Arm.ManagedDisk)))
{
Azure.Arm.ManagedDisk targetDiskSourceDisk = (Azure.Arm.ManagedDisk)targetDisk.SourceDisk;
if (String.Compare(targetDiskSourceDisk.Name, sourceManagedDisk.Name, true) == 0)
{
targetDataDisk = targetDisk;
break;
}
}
}
if (targetDataDisk != null)
{
EnsureDataDiskTargetLunIsNotNull(ref targetDataDisk);
targetDataDisk.ParentVirtualMachine = this;
targetDataDisk.Lun = sourceManagedDisk.Lun;
targetDataDisk.HostCaching = sourceManagedDisk.HostCaching;
this.DataDisks.Add(targetDataDisk);
}
}
else if (dataDisk.GetType() == typeof(Arm.ClassicDisk))
{
Disk targetDataDisk = new Disk(dataDisk, this, targetSettings);
Arm.ClassicDisk armDisk = (Arm.ClassicDisk)dataDisk;
if (targetSettings.DefaultTargetDiskType == ArmDiskType.ClassicDisk)
{
targetDataDisk.TargetStorage = SeekTargetStorageAccount(virtualMachine.AzureSubscription.ArmTargetStorageAccounts, armDisk.StorageAccountName);
}
EnsureDataDiskTargetLunIsNotNull(ref targetDataDisk);
this.DataDisks.Add(targetDataDisk);
}
}
foreach (Arm.NetworkInterface armNetworkInterface in virtualMachine.NetworkInterfaces)
{
foreach (NetworkInterface targetNetworkInterface in virtualMachine.AzureSubscription.ArmTargetNetworkInterfaces)
{
if ((targetNetworkInterface.SourceNetworkInterface != null) && (targetNetworkInterface.SourceNetworkInterface.GetType() == typeof(Azure.Arm.NetworkInterface)))
{
Azure.Arm.NetworkInterface targetNetworkInterfaceSourceInterface = (Azure.Arm.NetworkInterface)targetNetworkInterface.SourceNetworkInterface;
if (String.Compare(targetNetworkInterfaceSourceInterface.Name, armNetworkInterface.Name, true) == 0)
{
this.NetworkInterfaces.Add(targetNetworkInterface);
targetNetworkInterface.ParentVirtualMachine = this;
break;
}
}
}
}
if (virtualMachine.HasPlan)
{
_PlanAttributes = new Dictionary <string, string>();
foreach (JProperty planAttribute in virtualMachine.ResourceToken["plan"])
{
_PlanAttributes.Add(planAttribute.Name, planAttribute.Value.ToString());
}
}
}
