public Disk(IArmDisk sourceDisk, VirtualMachine parentVirtualMachine)
{
this.SourceDisk = (IDisk)sourceDisk;
this._ParentVirtualMachine = parentVirtualMachine;
this.TargetStorage = new ManagedDiskStorage(sourceDisk);
if (sourceDisk.GetType() == typeof(Azure.Arm.ClassicDisk))
{
Azure.Arm.ClassicDisk armDisk = (Azure.Arm.ClassicDisk)sourceDisk;
this.TargetName = armDisk.Name;
this.Lun = armDisk.Lun;
this.HostCaching = armDisk.Caching;
this.DiskSizeInGB = armDisk.DiskSizeGb;
this.TargetStorageAccountBlob = armDisk.StorageAccountBlob;
this.SourceStorageAccount = armDisk.SourceStorageAccount;
}
else if (sourceDisk.GetType() == typeof(Azure.Arm.ManagedDisk))
{
Azure.Arm.ManagedDisk armManagedDisk = (Azure.Arm.ManagedDisk)sourceDisk;
this.TargetName = armManagedDisk.Name;
this.DiskSizeInGB = armManagedDisk.DiskSizeGb;
}
}
public Disk(IArmDisk sourceDisk, VirtualMachine parentVirtualMachine, TargetSettings targetSettings) : base(ArmConst.MicrosoftCompute, ArmConst.Disks)
{
this.SourceDisk = (IDisk)sourceDisk;
this._ParentVirtualMachine = parentVirtualMachine;
this.TargetStorage = new ManagedDiskStorage(sourceDisk);
if (sourceDisk != null)
{
if (sourceDisk.GetType() == typeof(Azure.Arm.ClassicDisk))
{
Azure.Arm.ClassicDisk armDisk = (Azure.Arm.ClassicDisk)sourceDisk;
this.SetTargetName(armDisk.Name, targetSettings);
this.Lun = armDisk.Lun;
this.HostCaching = armDisk.Caching;
this.DiskSizeInGB = armDisk.DiskSizeGb;
this.TargetStorageAccountBlob = armDisk.StorageAccountBlob;
this.SourceStorageAccount = armDisk.SourceStorageAccount;
}
else if (sourceDisk.GetType() == typeof(Azure.Arm.ManagedDisk))
{
Azure.Arm.ManagedDisk armManagedDisk = (Azure.Arm.ManagedDisk)sourceDisk;
this.SetTargetName(armManagedDisk.Name, targetSettings);
this.DiskSizeInGB = armManagedDisk.DiskSizeGb;
}
}
}
public Disk(IArmDisk sourceDisk, VirtualMachine parentVirtualMachine, TargetSettings targetSettings, ILogProvider logProvider) : base(ArmConst.MicrosoftCompute, ArmConst.Disks, logProvider)
{
this.SourceDisk = (IDisk)sourceDisk;
this._ParentVirtualMachine = parentVirtualMachine;
this.TargetStorage = new ManagedDiskStorage(sourceDisk);
if (sourceDisk != null)
{
if (sourceDisk.GetType() == typeof(Azure.Arm.ClassicDisk))
{
Azure.Arm.ClassicDisk armDisk = (Azure.Arm.ClassicDisk)sourceDisk;
this.SetTargetName(armDisk.Name, targetSettings);
this.Lun = armDisk.Lun;
this.HostCaching = armDisk.Caching;
this.DiskSizeInGB = armDisk.DiskSizeGb;
this.TargetStorageAccountBlob = armDisk.StorageAccountBlob;
this.SourceStorageAccount = armDisk.SourceStorageAccount;
this.IsEncrypted = armDisk.IsEncrypted;
this.DiskEncryptionKeySourceVaultId = armDisk.DiskEncryptionKeySourceVaultId;
this.DiskEncryptionKeySecretUrl = armDisk.DiskEncryptionKeySecretUrl;
this.KeyEncryptionKeySourceVaultId = armDisk.KeyEncryptionKeySourceVaultId;
this.KeyEncryptionKeyKeyUrl = armDisk.KeyEncryptionKeyKeyUrl;
}
else if (sourceDisk.GetType() == typeof(Azure.Arm.ManagedDisk))
{
Azure.Arm.ManagedDisk armManagedDisk = (Azure.Arm.ManagedDisk)sourceDisk;
this.SetTargetName(armManagedDisk.Name, targetSettings);
this.DiskSizeInGB = armManagedDisk.DiskSizeGb;
this.IsEncrypted = armManagedDisk.IsEncrypted;
this.DiskEncryptionKeySourceVaultId = armManagedDisk.DiskEncryptionKeySourceVaultId;
this.DiskEncryptionKeySecretUrl = armManagedDisk.DiskEncryptionKeySecretUrl;
this.KeyEncryptionKeySourceVaultId = armManagedDisk.KeyEncryptionKeySourceVaultId;
this.KeyEncryptionKeyKeyUrl = armManagedDisk.KeyEncryptionKeyKeyUrl;
}
}
}
private async Task BindCommon()
{
if (_TargetDisk == null)
{
throw new ArgumentException("MigrationTarget Disk object cannot be null.");
}
_IsBinding = true;
if (_TargetDisk.TargetStorage != null && _TargetDisk.TargetStorage.GetType() == typeof(Azure.MigrationTarget.ManagedDiskStorage))
{
rbManagedDisk.Checked = true;
}
if (_TargetDisk.TargetStorage != null && _TargetDisk.TargetStorage.GetType() == typeof(Azure.MigrationTarget.StorageAccount))
{
rbStorageAccountInMigration.Checked = true;
}
else if (_TargetDisk.TargetStorage != null && _TargetDisk.TargetStorage.GetType() == typeof(Azure.Arm.StorageAccount))
{
rbExistingARMStorageAccount.Checked = true;
}
lblAsmStorageAccount.Text = String.Empty;
lblDiskName.Text = _TargetDisk.TargetName;
lblHostCaching.Text = _TargetDisk.HostCaching;
lblLUN.Text = _TargetDisk.Lun.ToString();
txtTargetDiskName.Text = _TargetDisk.TargetName;
txtBlobName.Text = _TargetDisk.TargetStorageAccountBlob;
txtTargetSize.Text = _TargetDisk.DiskSizeInGB.ToString();
if (_TargetDisk.SourceDisk != null)
{
lblSourceSizeGb.Text = _TargetDisk.SourceDisk.DiskSizeGb.ToString();
if (_TargetDisk.SourceDisk.GetType() == typeof(Azure.Asm.Disk))
{
Azure.Asm.Disk asmDisk = (Azure.Asm.Disk)_TargetDisk.SourceDisk;
if (asmDisk.SourceStorageAccount != null)
{
lblAsmStorageAccount.Text = asmDisk.SourceStorageAccount.Name;
}
}
else if (_TargetDisk.SourceDisk.GetType() == typeof(Azure.Arm.ClassicDisk))
{
Azure.Arm.ClassicDisk armDisk = (Azure.Arm.ClassicDisk)_TargetDisk.SourceDisk;
if (armDisk.SourceStorageAccount != null)
{
lblAsmStorageAccount.Text = armDisk.SourceStorageAccount.Name;
}
}
}
if (_TargetTreeView.TargetResourceGroup != null && _TargetTreeView.TargetResourceGroup.TargetLocation != null)
{
rbExistingARMStorageAccount.Text = "Existing Storage in " + _TargetTreeView.TargetResourceGroup.TargetLocation.DisplayName;
List <Azure.Arm.StorageAccount> a = await _AzureContext.AzureRetriever.GetAzureARMStorageAccounts(_TargetTreeView.TargetResourceGroup.TargetLocation);
rbExistingARMStorageAccount.Enabled = a.Count() > 0;
}
else
{
// Cannot use existing ARM Storage without Target Location
rbExistingARMStorageAccount.Enabled = false;
rbExistingARMStorageAccount.Text = "<Set Resource Group Location>";
}
if (!_TargetTreeView.HasStorageAccount)
{
rbStorageAccountInMigration.Enabled = false;
}
virtualMachineSummary.Bind(_TargetDisk.ParentVirtualMachine, _TargetTreeView);
_IsBinding = false;
}
private async Task BindCommon()
{
if (_TargetDisk == null)
{
throw new ArgumentException("MigrationTarget Disk object cannot be null.");
}
_IsBinding = true;
if (_TargetDisk.TargetStorage != null && _TargetDisk.TargetStorage.GetType() == typeof(Azure.MigrationTarget.ManagedDiskStorage))
{
rbManagedDisk.Checked = true;
}
if (_TargetDisk.TargetStorage != null && _TargetDisk.TargetStorage.GetType() == typeof(Azure.MigrationTarget.StorageAccount))
{
rbStorageAccountInMigration.Checked = true;
}
else if (_TargetDisk.TargetStorage != null && _TargetDisk.TargetStorage.GetType() == typeof(Azure.Arm.StorageAccount))
{
rbExistingARMStorageAccount.Checked = true;
}
txtTargetDiskName.Text = _TargetDisk.TargetName;
txtBlobName.Text = _TargetDisk.TargetStorageAccountBlob;
txtTargetSize.Text = _TargetDisk.DiskSizeInGB.ToString();
lblAsmStorageAccount.Text = String.Empty;
if (_TargetDisk.SourceDisk != null)
{
lblDiskName.Text = _TargetDisk.TargetName;
lblHostCaching.Text = _TargetDisk.SourceDisk.HostCaching;
lblLUN.Text = _TargetDisk.SourceDisk.Lun.ToString();
lblSourceSizeGb.Text = _TargetDisk.SourceDisk.DiskSizeGb.ToString();
if (_TargetDisk.SourceDisk.GetType() == typeof(Azure.Asm.Disk))
{
Azure.Asm.Disk asmDisk = (Azure.Asm.Disk)_TargetDisk.SourceDisk;
if (asmDisk.SourceStorageAccount != null)
{
lblAsmStorageAccount.Text = asmDisk.SourceStorageAccount.Name;
}
}
else if (_TargetDisk.SourceDisk.GetType() == typeof(Azure.Arm.ClassicDisk))
{
Azure.Arm.ClassicDisk armDisk = (Azure.Arm.ClassicDisk)_TargetDisk.SourceDisk;
if (armDisk.SourceStorageAccount != null)
{
lblAsmStorageAccount.Text = armDisk.SourceStorageAccount.Name;
}
}
}
else
{
lblDiskName.Text = String.Empty;
lblHostCaching.Text = String.Empty;
lblLUN.Text = String.Empty;
lblSourceSizeGb.Text = String.Empty;
lblAsmStorageAccount.Text = String.Empty;
}
if (_TargetTreeView.TargetResourceGroup != null && _TargetTreeView.TargetResourceGroup.TargetLocation != null)
{
rbExistingARMStorageAccount.Text = "Existing Storage in " + _TargetTreeView.TargetResourceGroup.TargetLocation.DisplayName;
rbExistingARMStorageAccount.Enabled = _TargetTreeView.GetExistingArmStorageAccounts().Count > 0;
}
else
{
// Cannot use existing ARM Storage without Target Location
rbExistingARMStorageAccount.Enabled = false;
rbExistingARMStorageAccount.Text = "<Set Resource Group Location>";
}
if (!_TargetTreeView.HasStorageAccount)
{
rbStorageAccountInMigration.Enabled = false;
}
upDownLUN.Visible = _TargetDisk.Lun.HasValue;
upDownLUN.Enabled = _TargetDisk.Lun.HasValue;
if (_TargetDisk.Lun.HasValue)
{
// There is a chance that the assigned LUN Value exceeds the Max Allowed LUN Value.
// This can happen, for example, if the Disk LUN was index 15 and the VM is resized from DS3 to DS2
// thus exceeding the Max allowed. In this case, we're going to temporarily increase the Max value
// to avoid value assignment error, and then handle downsizing / scaling back the Max allowed value
// as the value is decreased (max value reassignment to occur in the UpDown ValueChanged Event).
// We are utilizing the MigAz Error validation here to tell the user their LUN index exceeds that of the VM Size.
if (upDownLUN.Maximum < _TargetDisk.Lun.Value)
{
// Since it exceeds, we'll allow the Max value increase, and downsize in the UpDown ValueChanged Event
upDownLUN.Maximum = _TargetDisk.Lun.Value;
}
if (_TargetDisk.Lun.Value == -1)
{
upDownLUN.Minimum = -1;
}
else
{
upDownLUN.Minimum = 0;
}
upDownLUN.Value = _TargetDisk.Lun.Value;
}
virtualMachineSummary.Bind(_TargetDisk.ParentVirtualMachine, _TargetTreeView, false);
_IsBinding = false;
}
private async Task AsmSelectDependencies(TreeNode selectedNode)
{
if (this.AutoSelectDependencies && (selectedNode.Checked) && (selectedNode.Tag != null))
{
if (selectedNode.Tag.GetType() == typeof(Azure.MigrationTarget.AvailabilitySet))
{
Azure.MigrationTarget.AvailabilitySet targetAvailabilitySet = (Azure.MigrationTarget.AvailabilitySet)selectedNode.Tag;
foreach (Azure.MigrationTarget.VirtualMachine targetVirtualMachine in targetAvailabilitySet.TargetVirtualMachines)
{
foreach (TreeNode treeNode in selectedNode.TreeView.Nodes.Find(targetVirtualMachine.TargetName, true))
{
if ((treeNode.Tag != null) && (treeNode.Tag.GetType() == typeof(Azure.MigrationTarget.VirtualMachine)))
{
if (!treeNode.Checked)
{
treeNode.Checked = true;
}
}
}
}
}
if (selectedNode.Tag.GetType() == typeof(Azure.MigrationTarget.VirtualMachine))
{
Azure.MigrationTarget.VirtualMachine targetVirtualMachine = (Azure.MigrationTarget.VirtualMachine)selectedNode.Tag;
if (targetVirtualMachine.Source != null)
{
if (targetVirtualMachine.Source.GetType() == typeof(Azure.Arm.VirtualMachine))
{
Azure.Arm.VirtualMachine armVirtualMachine = (Azure.Arm.VirtualMachine)targetVirtualMachine.Source;
#region process virtual network
// This source code to auto select the Virtual Network as a Parent node has been commented out purposefully.
// It was observed through use of MigAz that users were not aware that "including the Virtual Network" in multiple
// migrations was actually creating new / independent / non-connected versions of the same Virtual Network.
// It is valid that the user would want to migrate the Virtual Network during the first run migration; however, beyond
// that first pass (the Azure ARM Virtual Network exists) the user is more likely to need to migrate the Virtual Machine(s)
// into an existing Azure Virtual Network. In order to guide the user in this direction, we do not want to auto select the
// source Virtual Network to be included in the Migration Template as a new Virtual Network. We want the user to explicitly
// select and include the source Azure Virtual Network into the Migration Template (if they want to include it), or utilize
// the built in property editor dialogs to "select an existing Virtual Network and Subnet".
//foreach (Azure.Arm.NetworkInterface networkInterface in armVirtualMachine.NetworkInterfaces)
//{
// foreach (Azure.Arm.NetworkInterfaceIpConfiguration ipConfiguration in networkInterface.NetworkInterfaceIpConfigurations)
// {
// if (ipConfiguration.VirtualNetwork != null)
// {
// foreach (TreeNode treeNode in selectedNode.TreeView.Nodes.Find(ipConfiguration.VirtualNetwork.Name, true))
// {
// if ((treeNode.Tag != null) && (treeNode.Tag.GetType() == typeof(Azure.MigrationTarget.VirtualNetwork)))
// {
// if (!treeNode.Checked)
// treeNode.Checked = true;
// }
// }
// }
// }
//}
#endregion
#region process managed disks
if (armVirtualMachine.OSVirtualHardDisk.GetType() == typeof(Azure.Arm.ManagedDisk))
{
foreach (TreeNode treeNode in selectedNode.TreeView.Nodes.Find(((Azure.Arm.ManagedDisk)armVirtualMachine.OSVirtualHardDisk).Name, true))
{
if ((treeNode.Tag != null) && (treeNode.Tag.GetType() == typeof(Azure.MigrationTarget.Disk)))
{
if (!treeNode.Checked)
{
treeNode.Checked = true;
}
}
}
}
foreach (Azure.Interface.IArmDisk dataDisk in armVirtualMachine.DataDisks)
{
if (dataDisk.GetType() == typeof(Azure.Arm.ManagedDisk))
{
Azure.Arm.ManagedDisk managedDisk = (Azure.Arm.ManagedDisk)dataDisk;
foreach (TreeNode treeNode in selectedNode.TreeView.Nodes.Find(managedDisk.Name, true))
{
if ((treeNode.Tag != null) && (treeNode.Tag.GetType() == typeof(Azure.MigrationTarget.Disk)))
{
if (!treeNode.Checked)
{
treeNode.Checked = true;
}
}
}
}
}
#endregion
#region OS Disk Storage Account
if (armVirtualMachine.OSVirtualHardDisk.GetType() == typeof(Azure.Arm.ClassicDisk)) // Disk in a Storage Account, not a Managed Disk
{
foreach (TreeNode treeNode in selectedNode.TreeView.Nodes.Find(((Azure.Arm.ClassicDisk)armVirtualMachine.OSVirtualHardDisk).StorageAccountName, true))
{
if ((treeNode.Tag != null) && (treeNode.Tag.GetType() == typeof(Azure.MigrationTarget.StorageAccount)))
{
if (!treeNode.Checked)
{
treeNode.Checked = true;
}
}
}
}
#endregion
#region Data Disk(s) Storage Account(s)
foreach (IArmDisk dataDisk in armVirtualMachine.DataDisks)
{
if (dataDisk.GetType() == typeof(Azure.Arm.ClassicDisk))
{
Azure.Arm.ClassicDisk classicDisk = (Azure.Arm.ClassicDisk)dataDisk;
foreach (TreeNode treeNode in selectedNode.TreeView.Nodes.Find(classicDisk.StorageAccountName, true))
{
if ((treeNode.Tag != null) && (treeNode.Tag.GetType() == typeof(Azure.MigrationTarget.StorageAccount)))
{
if (!treeNode.Checked)
{
treeNode.Checked = true;
}
}
}
}
else if (dataDisk.GetType() == typeof(Azure.Arm.ManagedDisk))
{
Azure.Arm.ManagedDisk managedDisk = (Azure.Arm.ManagedDisk)dataDisk;
foreach (TreeNode treeNode in selectedNode.TreeView.Nodes.Find(managedDisk.Name, true))
{
if ((treeNode.Tag != null) && (treeNode.Tag.GetType() == typeof(Azure.MigrationTarget.Disk)))
{
if (!treeNode.Checked)
{
treeNode.Checked = true;
}
}
}
}
}
#endregion
#region Network Interface Card(s)
foreach (Azure.Arm.NetworkInterface networkInterface in armVirtualMachine.NetworkInterfaces)
{
foreach (TreeNode treeNode in selectedNode.TreeView.Nodes.Find(networkInterface.Name, true))
{
if ((treeNode.Tag != null) && (treeNode.Tag.GetType() == typeof(Azure.MigrationTarget.NetworkInterface)))
{
if (!treeNode.Checked)
{
treeNode.Checked = true;
}
}
}
if (networkInterface.NetworkSecurityGroup != null)
{
foreach (TreeNode treeNode in selectedNode.TreeView.Nodes.Find(networkInterface.NetworkSecurityGroup.Name, true))
{
if ((treeNode.Tag != null) && (treeNode.Tag.GetType() == typeof(Azure.MigrationTarget.NetworkSecurityGroup)))
{
if (!treeNode.Checked)
{
treeNode.Checked = true;
}
}
}
}
foreach (Azure.Arm.NetworkInterfaceIpConfiguration ipConfiguration in networkInterface.NetworkInterfaceIpConfigurations)
{
if (ipConfiguration.BackEndAddressPool != null && ipConfiguration.BackEndAddressPool.LoadBalancer != null)
{
foreach (TreeNode treeNode in selectedNode.TreeView.Nodes.Find(ipConfiguration.BackEndAddressPool.LoadBalancer.Name, true))
{
if ((treeNode.Tag != null) && (treeNode.Tag.GetType() == typeof(Azure.MigrationTarget.LoadBalancer)))
{
if (!treeNode.Checked)
{
treeNode.Checked = true;
}
}
}
}
if (ipConfiguration.PublicIP != null)
{
foreach (TreeNode treeNode in selectedNode.TreeView.Nodes.Find(ipConfiguration.PublicIP.Name, true))
{
if ((treeNode.Tag != null) && (treeNode.Tag.GetType() == typeof(Azure.MigrationTarget.PublicIp)))
{
if (!treeNode.Checked)
{
treeNode.Checked = true;
}
}
}
}
}
}
#endregion
#region Parent Availability Set
if (armVirtualMachine.AvailabilitySet != null)
{
foreach (TreeNode treeNode in selectedNode.TreeView.Nodes.Find(armVirtualMachine.AvailabilitySet.Name, true))
{
if ((treeNode.Tag != null) && (treeNode.Tag.GetType() == typeof(Azure.MigrationTarget.AvailabilitySet)))
{
if (!treeNode.Checked)
{
treeNode.Checked = true;
}
}
}
}
#endregion
}
}
}
else if (selectedNode.Tag.GetType() == typeof(Azure.MigrationTarget.VirtualNetwork))
{
Azure.MigrationTarget.VirtualNetwork targetVirtualNetwork = (Azure.MigrationTarget.VirtualNetwork)selectedNode.Tag;
foreach (Azure.MigrationTarget.Subnet targetSubnet in targetVirtualNetwork.TargetSubnets)
{
if (targetSubnet.NetworkSecurityGroup != null)
{
if (targetSubnet.NetworkSecurityGroup.SourceNetworkSecurityGroup != null)
{
if (targetSubnet.NetworkSecurityGroup.SourceNetworkSecurityGroup.GetType() == typeof(Azure.Arm.NetworkSecurityGroup))
{
foreach (TreeNode treeNode in selectedNode.TreeView.Nodes.Find(targetSubnet.NetworkSecurityGroup.SourceName, true))
{
if ((treeNode.Tag != null) && (treeNode.Tag.GetType() == typeof(Azure.MigrationTarget.NetworkSecurityGroup)))
{
if (!treeNode.Checked)
{
treeNode.Checked = true;
}
}
}
}
}
}
}
}
else if (selectedNode.Tag.GetType() == typeof(Azure.MigrationTarget.LoadBalancer))
{
Azure.MigrationTarget.LoadBalancer targetLoadBalancer = (Azure.MigrationTarget.LoadBalancer)selectedNode.Tag;
if (targetLoadBalancer.Source != null)
{
if (targetLoadBalancer.Source.GetType() == typeof(Azure.Arm.LoadBalancer))
{
Azure.Arm.LoadBalancer armLoadBalaner = (Azure.Arm.LoadBalancer)targetLoadBalancer.Source;
foreach (Azure.Arm.FrontEndIpConfiguration frontEndIpConfiguration in armLoadBalaner.FrontEndIpConfigurations)
{
if (frontEndIpConfiguration.PublicIP != null)
{
foreach (TreeNode treeNode in selectedNode.TreeView.Nodes.Find(frontEndIpConfiguration.PublicIP.Name, true))
{
if ((treeNode.Tag != null) && (treeNode.Tag.GetType() == typeof(Azure.MigrationTarget.PublicIp)))
{
if (!treeNode.Checked)
{
treeNode.Checked = true;
}
}
}
}
}
}
}
}
_StatusProvider.UpdateStatus("Ready");
}
}
