public async Task Bind(AzureContext azureContext, TargetTreeView targetTreeView, MigrationTarget.VirtualMachine virtualMachine)
{
_AzureContext = azureContext;
_TargetTreeView = targetTreeView;
_VirtualMachine = virtualMachine;
txtTargetName.Text = _VirtualMachine.TargetName;
if (_VirtualMachine.Source != null)
{
if (_VirtualMachine.Source.GetType() == typeof(Azure.Asm.VirtualMachine))
{
Azure.Asm.VirtualMachine asmVirtualMachine = (Azure.Asm.VirtualMachine)_VirtualMachine.Source;
lblRoleSize.Text = asmVirtualMachine.RoleSize;
lblOS.Text = asmVirtualMachine.OSVirtualHardDiskOS;
}
else if (_VirtualMachine.Source.GetType() == typeof(Azure.Arm.VirtualMachine))
{
Azure.Arm.VirtualMachine armVirtualMachine = (Azure.Arm.VirtualMachine)_VirtualMachine.Source;
lblRoleSize.Text = armVirtualMachine.VmSize;
lblOS.Text = armVirtualMachine.OSVirtualHardDiskOS;
}
}
if (_VirtualMachine.OSVirtualHardDisk != null)
{
this.diskProperties1.Bind(azureContext, _TargetTreeView, _VirtualMachine.OSVirtualHardDisk);
}
else
{
this.diskProperties1.Visible = false;
}
}
public async Task Bind(TreeNode armVirtualMachineNode, AsmToArm asmToArmForm)
{
_VirtualMachineNode = armVirtualMachineNode;
_AsmToArmForm = asmToArmForm;
TreeNode asmTreeNode = (TreeNode)_VirtualMachineNode.Tag;
if (asmTreeNode.Tag.GetType() == typeof(Azure.Asm.VirtualMachine))
{
Azure.Asm.VirtualMachine asmVirtualMachine = (Azure.Asm.VirtualMachine)asmTreeNode.Tag;
lblRoleSize.Text = asmVirtualMachine.RoleSize;
lblOS.Text = asmVirtualMachine.OSVirtualHardDiskOS;
lblVirtualNetworkName.Text = asmVirtualMachine.VirtualNetworkName;
lblSubnetName.Text = asmVirtualMachine.SubnetName;
lblStaticIpAddress.Text = asmVirtualMachine.StaticVirtualNetworkIPAddress;
txtARMVMName.Text = asmVirtualMachine.TargetName;
this.diskProperties1.Bind(asmToArmForm, asmVirtualMachine.OSVirtualHardDisk);
try
{
List <Azure.Arm.VirtualNetwork> a = await _AsmToArmForm.AzureContextTargetARM.AzureRetriever.GetAzureARMVirtualNetworks();
rbExistingARMVNet.Enabled = a.Count() > 0;
}
catch (Exception exc)
{
_AsmToArmForm.LogProvider.WriteLog("VirtualMachineProperties.Bind", exc.Message);
rbExistingARMVNet.Enabled = false;
}
if ((asmVirtualMachine.TargetSubnet == null) ||
(asmVirtualMachine.TargetSubnet.GetType() == typeof(Azure.Asm.Subnet)) ||
(rbExistingARMVNet.Enabled == false))
{
rbVNetInMigration.Checked = true;
}
else
{
rbExistingARMVNet.Checked = true;
}
}
else if (asmTreeNode.Tag.GetType() == typeof(Azure.Arm.VirtualMachine))
{
Azure.Arm.VirtualMachine armVirtualMachine = (Azure.Arm.VirtualMachine)asmTreeNode.Tag;
lblRoleSize.Text = armVirtualMachine.VmSize;
//lblOS.Text = armVirtualMachine.OSVirtualHardDiskOS;
if (armVirtualMachine.VirtualNetwork != null)
{
lblVirtualNetworkName.Text = armVirtualMachine.VirtualNetwork.Name;
}
//lblSubnetName.Text = armVirtualMachine.SubnetName;
//lblStaticIpAddress.Text = armVirtualMachine.StaticVirtualNetworkIPAddress;
txtARMVMName.Text = armVirtualMachine.TargetName;
}
}
private void treeSource_BeforeCheck(object sender, TreeViewCancelEventArgs e)
{
if (e.Node.Tag != null)
{
if (e.Node.Tag.GetType() == typeof(Azure.Arm.VirtualMachine))
{
Azure.Arm.VirtualMachine armVirtualMachine = (Azure.Arm.VirtualMachine)e.Node.Tag;
if (armVirtualMachine.OSVirtualHardDisk.VhdUri == String.Empty)
{
LogProvider.WriteLog("treeSource_BeforeCheck", "VM '" + armVirtualMachine.Name + "' contains one or more mananged disks which is not yet supported.");
e.Cancel = true;
}
}
}
}
private async void rbExistingARMVNet_CheckedChanged(object sender, EventArgs e)
{
TreeNode asmTreeNode = (TreeNode)_VirtualMachineNode.Tag;
if (asmTreeNode.Tag.GetType() == typeof(Azure.Asm.VirtualMachine))
{
Azure.Asm.VirtualMachine asmVirtualMachine = (Azure.Asm.VirtualMachine)asmTreeNode.Tag;
RadioButton rb = (RadioButton)sender;
if (rb.Checked)
{
cmbExistingArmVNets.Items.Clear();
cmbExistingArmSubnet.Items.Clear();
foreach (Azure.Arm.VirtualNetwork armVirtualNetwork in await _AsmToArmForm.AzureContextTargetARM.AzureRetriever.GetAzureARMVirtualNetworks())
{
if (armVirtualNetwork.HasNonGatewaySubnet)
{
cmbExistingArmVNets.Items.Add(armVirtualNetwork);
}
}
if (asmVirtualMachine.TargetVirtualNetwork != null)
{
// Attempt to match target to list items
foreach (Azure.Arm.VirtualNetwork listVirtualNetwork in cmbExistingArmVNets.Items)
{
if (listVirtualNetwork.Id == asmVirtualMachine.TargetVirtualNetwork.Id)
{
cmbExistingArmVNets.SelectedItem = listVirtualNetwork;
}
}
}
}
}
else if (asmTreeNode.Tag.GetType() == typeof(Azure.Arm.VirtualMachine))
{
Azure.Arm.VirtualMachine asmVirtualMachine = (Azure.Arm.VirtualMachine)asmTreeNode.Tag;
}
await PropertyChanged();
}
private void txtARMVMName_TextChanged(object sender, EventArgs e)
{
TreeNode asmTreeNode = (TreeNode)_VirtualMachineNode.Tag;
if (asmTreeNode.Tag.GetType() == typeof(Azure.Asm.VirtualMachine))
{
Azure.Asm.VirtualMachine asmVirtualMachine = (Azure.Asm.VirtualMachine)asmTreeNode.Tag;
asmVirtualMachine.TargetName = txtARMVMName.Text;
_VirtualMachineNode.Text = asmVirtualMachine.TargetName;
}
else if (asmTreeNode.Tag.GetType() == typeof(Azure.Arm.VirtualMachine))
{
Azure.Arm.VirtualMachine asmVirtualMachine = (Azure.Arm.VirtualMachine)asmTreeNode.Tag;
asmVirtualMachine.TargetName = txtARMVMName.Text;
_VirtualMachineNode.Text = asmVirtualMachine.TargetName;
}
PropertyChanged();
}
private void cmbExistingArmSubnet_SelectedIndexChanged(object sender, EventArgs e)
{
TreeNode asmTreeNode = (TreeNode)_VirtualMachineNode.Tag;
if (asmTreeNode.Tag.GetType() == typeof(Azure.Asm.VirtualMachine))
{
Azure.Asm.VirtualMachine asmVirtualMachine = (Azure.Asm.VirtualMachine)asmTreeNode.Tag;
ComboBox cmbSender = (ComboBox)sender;
if (cmbSender.SelectedItem == null)
{
asmVirtualMachine.TargetVirtualNetwork = null;
asmVirtualMachine.TargetSubnet = null;
}
else
{
if (cmbSender.SelectedItem.GetType() == typeof(Azure.Asm.Subnet))
{
Azure.Asm.Subnet asmSubnet = (Azure.Asm.Subnet)cmbSender.SelectedItem;
asmVirtualMachine.TargetVirtualNetwork = asmSubnet.Parent;
asmVirtualMachine.TargetSubnet = asmSubnet;
}
else if (cmbSender.SelectedItem.GetType() == typeof(Azure.Arm.Subnet))
{
Azure.Arm.Subnet armSubnet = (Azure.Arm.Subnet)cmbSender.SelectedItem;
asmVirtualMachine.TargetVirtualNetwork = armSubnet.Parent;
asmVirtualMachine.TargetSubnet = armSubnet;
}
}
}
else if (asmTreeNode.Tag.GetType() == typeof(Azure.Arm.VirtualMachine))
{
Azure.Arm.VirtualMachine asmVirtualMachine = (Azure.Arm.VirtualMachine)asmTreeNode.Tag;
}
PropertyChanged();
}
private async Task <TreeNode> AddASMNodeToARMTree(TreeNode asmTreeNode)
{
TreeNode targetResourceGroupNode = SeekARMChildTreeNode(treeTargetARM.Nodes, _TargetResourceGroup.Name, _TargetResourceGroup.Name, _TargetResourceGroup, true);
Type tagType = asmTreeNode.Tag.GetType();
if (tagType == typeof(Azure.Asm.VirtualNetwork))
{
Azure.Asm.VirtualNetwork asmVirtualNetwork = (Azure.Asm.VirtualNetwork)asmTreeNode.Tag;
TreeNode virtualNetworksNode = SeekARMChildTreeNode(targetResourceGroupNode.Nodes, "Virtual Networks", "Virtual Networks", "Virtual Networks", true);
TreeNode virtualNetworkNode = SeekARMChildTreeNode(virtualNetworksNode.Nodes, asmTreeNode.Name, asmVirtualNetwork.GetFinalTargetName(), asmTreeNode, true);
foreach (Azure.Asm.Subnet asmSubnet in asmVirtualNetwork.Subnets)
{
// Property dialog not made available for Gateway Subnet
if (!asmSubnet.IsGatewaySubnet)
{
TreeNode subnetNode = SeekARMChildTreeNode(virtualNetworkNode.Nodes, asmSubnet.Name, asmSubnet.Name, asmSubnet, true);
}
}
targetResourceGroupNode.ExpandAll();
return(virtualNetworkNode);
}
else if (tagType == typeof(Azure.Asm.StorageAccount))
{
Azure.Asm.StorageAccount asmStorageAccount = (Azure.Asm.StorageAccount)asmTreeNode.Tag;
TreeNode storageAccountsNode = SeekARMChildTreeNode(targetResourceGroupNode.Nodes, "Storage Accounts", "Storage Accounts", "Storage Accounts", true);
TreeNode storageAccountNode = SeekARMChildTreeNode(storageAccountsNode.Nodes, asmTreeNode.Name, asmStorageAccount.GetFinalTargetName(), asmTreeNode, true);
targetResourceGroupNode.ExpandAll();
return(storageAccountNode);
}
else if (tagType == typeof(Azure.Asm.VirtualMachine))
{
Azure.Asm.VirtualMachine asmVirtualMachine = (Azure.Asm.VirtualMachine)asmTreeNode.Tag;
TreeNode availabilitySets = SeekARMChildTreeNode(targetResourceGroupNode.Nodes, "Availability Sets", "Availability Sets", "Availability Sets", true);
TreeNode availabilitySet = SeekARMChildTreeNode(availabilitySets.Nodes, asmVirtualMachine.TargetAvailabilitySet.TargetName, asmVirtualMachine.TargetAvailabilitySet.GetFinalTargetName(), asmVirtualMachine.TargetAvailabilitySet, true);
TreeNode virtualMachineNode = SeekARMChildTreeNode(availabilitySet.Nodes, asmVirtualMachine.RoleName, asmVirtualMachine.RoleName, asmTreeNode, true);
foreach (Azure.Asm.Disk asmDataDisk in asmVirtualMachine.DataDisks)
{
TreeNode dataDiskNode = SeekARMChildTreeNode(virtualMachineNode.Nodes, asmDataDisk.DiskName, asmDataDisk.DiskName, asmDataDisk, true);
}
foreach (Azure.Asm.NetworkInterface asmNetworkInterface in asmVirtualMachine.NetworkInterfaces)
{
TreeNode dataDiskNode = SeekARMChildTreeNode(virtualMachineNode.Nodes, asmNetworkInterface.Name, asmNetworkInterface.Name, asmNetworkInterface, true);
}
targetResourceGroupNode.ExpandAll();
return(virtualMachineNode);
}
else if (tagType == typeof(Azure.Asm.NetworkSecurityGroup))
{
Azure.Asm.NetworkSecurityGroup asmNetworkSecurityGroup = (Azure.Asm.NetworkSecurityGroup)asmTreeNode.Tag;
TreeNode networkSecurityGroups = SeekARMChildTreeNode(targetResourceGroupNode.Nodes, "Network Security Groups", "Network Security Groups", "Network Security Groups", true);
TreeNode networkSecurityGroupNode = SeekARMChildTreeNode(networkSecurityGroups.Nodes, asmNetworkSecurityGroup.Name, asmNetworkSecurityGroup.Name, asmTreeNode, true);
targetResourceGroupNode.ExpandAll();
return(networkSecurityGroupNode);
}
else if (tagType == typeof(Azure.Arm.VirtualNetwork))
{
Azure.Arm.VirtualNetwork armVirtualNetwork = (Azure.Arm.VirtualNetwork)asmTreeNode.Tag;
TreeNode virtualNetworksNode = SeekARMChildTreeNode(targetResourceGroupNode.Nodes, "Virtual Networks", "Virtual Networks", "Virtual Networks", true);
TreeNode virtualNetworkNode = SeekARMChildTreeNode(virtualNetworksNode.Nodes, asmTreeNode.Name, armVirtualNetwork.GetFinalTargetName(), asmTreeNode, true);
foreach (Azure.Arm.Subnet armSubnet in armVirtualNetwork.Subnets)
{
// Property dialog not made available for Gateway Subnet
if (!armSubnet.IsGatewaySubnet)
{
TreeNode subnetNode = SeekARMChildTreeNode(virtualNetworkNode.Nodes, armSubnet.Name, armSubnet.Name, armSubnet, true);
}
}
targetResourceGroupNode.ExpandAll();
return(virtualNetworkNode);
}
else if (tagType == typeof(Azure.Arm.StorageAccount))
{
Azure.Arm.StorageAccount armStorageAccount = (Azure.Arm.StorageAccount)asmTreeNode.Tag;
TreeNode storageAccountsNode = SeekARMChildTreeNode(targetResourceGroupNode.Nodes, "Storage Accounts", "Storage Accounts", "Storage Accounts", true);
TreeNode storageAccountNode = SeekARMChildTreeNode(storageAccountsNode.Nodes, asmTreeNode.Name, armStorageAccount.GetFinalTargetName(), asmTreeNode, true);
targetResourceGroupNode.ExpandAll();
return(storageAccountNode);
}
else if (tagType == typeof(Azure.Arm.VirtualMachine))
{
Azure.Arm.VirtualMachine armVirtualMachine = (Azure.Arm.VirtualMachine)asmTreeNode.Tag;
TreeNode virtualMachineNode = null;
if (armVirtualMachine.TargetAvailabilitySet != null)
{
TreeNode availabilitySets = SeekARMChildTreeNode(targetResourceGroupNode.Nodes, "Availability Sets", "Availability Sets", "Availability Sets", true);
TreeNode availabilitySet = SeekARMChildTreeNode(availabilitySets.Nodes, armVirtualMachine.TargetAvailabilitySet.TargetName, armVirtualMachine.TargetAvailabilitySet.GetFinalTargetName(), armVirtualMachine.TargetAvailabilitySet, true);
virtualMachineNode = SeekARMChildTreeNode(availabilitySet.Nodes, armVirtualMachine.Name, armVirtualMachine.Name, asmTreeNode, true);
}
else
{
virtualMachineNode = SeekARMChildTreeNode(targetResourceGroupNode.Nodes, armVirtualMachine.Name, armVirtualMachine.Name, asmTreeNode, true);
}
foreach (Azure.Arm.Disk armDataDisk in armVirtualMachine.DataDisks)
{
TreeNode dataDiskNode = SeekARMChildTreeNode(virtualMachineNode.Nodes, armDataDisk.Name, armDataDisk.Name, armDataDisk, true);
}
foreach (Azure.Arm.NetworkInterfaceCard asmNetworkInterface in armVirtualMachine.NetworkInterfaces)
{
TreeNode dataDiskNode = SeekARMChildTreeNode(virtualMachineNode.Nodes, asmNetworkInterface.Name, asmNetworkInterface.Name, asmNetworkInterface, true);
}
targetResourceGroupNode.ExpandAll();
return(virtualMachineNode);
}
else if (tagType == typeof(Azure.Arm.NetworkSecurityGroup))
{
Azure.Arm.NetworkSecurityGroup armNetworkSecurityGroup = (Azure.Arm.NetworkSecurityGroup)asmTreeNode.Tag;
TreeNode networkSecurityGroups = SeekARMChildTreeNode(targetResourceGroupNode.Nodes, "Network Security Groups", "Network Security Groups", "Network Security Groups", true);
TreeNode networkSecurityGroupNode = SeekARMChildTreeNode(networkSecurityGroups.Nodes, armNetworkSecurityGroup.Name, armNetworkSecurityGroup.Name, asmTreeNode, true);
targetResourceGroupNode.ExpandAll();
return(networkSecurityGroupNode);
}
else
{
throw new Exception("Unhandled Node Type in AddASMNodeToARMTree: " + tagType);
}
}
public async Task Bind(AzureContext azureContext, TargetTreeView targetTreeView, MigrationTarget.VirtualMachine virtualMachine)
{
_AzureContext = azureContext;
_TargetTreeView = targetTreeView;
_VirtualMachine = virtualMachine;
txtTargetName.Text = _VirtualMachine.TargetName;
if (_VirtualMachine.Source != null)
{
if (_VirtualMachine.Source.GetType() == typeof(Azure.Asm.VirtualMachine))
{
Azure.Asm.VirtualMachine asmVirtualMachine = (Azure.Asm.VirtualMachine)_VirtualMachine.Source;
if (asmVirtualMachine.RoleSize != null)
{
lblRoleSize.Text = asmVirtualMachine.RoleSize.Name;
lblSourceCPUCores.Text = asmVirtualMachine.RoleSize.Cores.ToString();
lblSourceMemoryInGb.Text = ((double)asmVirtualMachine.RoleSize.MemoryInMb / 1024).ToString();
lblSourceMaxDataDisks.Text = asmVirtualMachine.RoleSize.MaxDataDiskCount.ToString();
}
lblOS.Text = asmVirtualMachine.OSVirtualHardDiskOS;
}
else if (_VirtualMachine.Source.GetType() == typeof(Azure.Arm.VirtualMachine))
{
Azure.Arm.VirtualMachine armVirtualMachine = (Azure.Arm.VirtualMachine)_VirtualMachine.Source;
if (armVirtualMachine.VmSize != null)
{
lblRoleSize.Text = armVirtualMachine.VmSize.ToString();
lblSourceCPUCores.Text = armVirtualMachine.VmSize.NumberOfCores.ToString();
lblSourceMemoryInGb.Text = ((double)armVirtualMachine.VmSize.memoryInMB / 1024).ToString();
lblSourceMaxDataDisks.Text = armVirtualMachine.VmSize.maxDataDiskCount.ToString();
}
lblOS.Text = armVirtualMachine.OSVirtualHardDiskOS;
}
}
if (_VirtualMachine.OSVirtualHardDisk != null)
{
this.diskProperties1.Bind(azureContext, _TargetTreeView, _VirtualMachine.OSVirtualHardDisk);
}
else
{
this.diskProperties1.Visible = false;
}
cbRoleSizes.Items.Clear();
if (targetTreeView.TargetResourceGroup != null && targetTreeView.TargetResourceGroup.TargetLocation != null)
{
cbRoleSizes.Enabled = true;
cbRoleSizes.Visible = true;
lblTargetLocationRequired.Enabled = false;
lblTargetLocationRequired.Visible = false;
if (targetTreeView.TargetResourceGroup.TargetLocation.VMSizes != null)
{
foreach (Arm.VMSize vmSize in targetTreeView.TargetResourceGroup.TargetLocation.VMSizes)
{
cbRoleSizes.Items.Add(vmSize);
}
}
if (_VirtualMachine.TargetSize != null)
{
int sizeIndex = cbRoleSizes.FindStringExact(_VirtualMachine.TargetSize.ToString());
cbRoleSizes.SelectedIndex = sizeIndex;
}
}
else
{
cbRoleSizes.Enabled = false;
cbRoleSizes.Visible = false;
lblTargetLocationRequired.Enabled = true;
lblTargetLocationRequired.Visible = true;
}
}
public async Task Bind(AzureContext azureContext, TargetTreeView targetTreeView, MigrationTarget.VirtualMachine virtualMachine)
{
_AzureContext = azureContext;
_TargetTreeView = targetTreeView;
_VirtualMachine = virtualMachine;
txtTargetName.Text = _VirtualMachine.TargetName;
if (_VirtualMachine.Source != null)
{
if (_VirtualMachine.Source.GetType() == typeof(Azure.Asm.VirtualMachine))
{
Azure.Asm.VirtualMachine asmVirtualMachine = (Azure.Asm.VirtualMachine)_VirtualMachine.Source;
if (asmVirtualMachine.RoleSize != null)
{
lblRoleSize.Text = asmVirtualMachine.RoleSize.Name;
lblSourceCPUCores.Text = asmVirtualMachine.RoleSize.Cores.ToString();
lblSourceMemoryInGb.Text = ((double)asmVirtualMachine.RoleSize.MemoryInMb / 1024).ToString();
lblSourceMaxDataDisks.Text = asmVirtualMachine.RoleSize.MaxDataDiskCount.ToString();
}
lblOS.Text = asmVirtualMachine.OSVirtualHardDiskOS;
}
else if (_VirtualMachine.Source.GetType() == typeof(Azure.Arm.VirtualMachine))
{
Azure.Arm.VirtualMachine armVirtualMachine = (Azure.Arm.VirtualMachine)_VirtualMachine.Source;
if (armVirtualMachine.VmSize != null)
{
lblRoleSize.Text = armVirtualMachine.VmSize.ToString();
lblSourceCPUCores.Text = armVirtualMachine.VmSize.NumberOfCores.ToString();
lblSourceMemoryInGb.Text = ((double)armVirtualMachine.VmSize.memoryInMB / 1024).ToString();
lblSourceMaxDataDisks.Text = armVirtualMachine.VmSize.maxDataDiskCount.ToString();
}
lblOS.Text = armVirtualMachine.OSVirtualHardDiskOS;
}
}
cbRoleSizes.Items.Clear();
if (targetTreeView.TargetResourceGroup != null && targetTreeView.TargetResourceGroup.TargetLocation != null)
{
cbRoleSizes.Enabled = true;
cbRoleSizes.Visible = true;
lblTargetLocationRequired.Enabled = false;
lblTargetLocationRequired.Visible = false;
if (targetTreeView.TargetResourceGroup.TargetLocation.VMSizes != null)
{
foreach (Arm.VMSize vmSize in targetTreeView.TargetResourceGroup.TargetLocation.VMSizes)
{
if (vmSize.IsStorageTypeSupported(_VirtualMachine.OSVirtualHardDisk.StorageAccountType))
{
cbRoleSizes.Items.Add(vmSize);
}
}
}
if (_VirtualMachine.TargetSize != null)
{
int sizeIndex = cbRoleSizes.FindStringExact(_VirtualMachine.TargetSize.ToString());
cbRoleSizes.SelectedIndex = sizeIndex;
}
}
else
{
cbRoleSizes.Enabled = false;
cbRoleSizes.Visible = false;
lblTargetLocationRequired.Enabled = true;
lblTargetLocationRequired.Visible = true;
}
availabilitySetSummary.Bind(virtualMachine.TargetAvailabilitySet, _TargetTreeView);
osDiskSummary.Bind(virtualMachine.OSVirtualHardDisk, _TargetTreeView);
primaryNICSummary.Bind(virtualMachine.PrimaryNetworkInterface, _TargetTreeView);
foreach (Azure.MigrationTarget.Disk targetDisk in virtualMachine.DataDisks)
{
AddResourceSummary(new ResourceSummary(targetDisk, targetTreeView));
}
foreach (Azure.MigrationTarget.NetworkInterface targetNIC in virtualMachine.NetworkInterfaces)
{
if (!targetNIC.IsPrimary)
{
AddResourceSummary(new ResourceSummary(targetNIC, targetTreeView));
}
}
label15.Visible = pictureBox1.Controls.Count > 0;
}
private async void rbVNetInMigration_CheckedChanged(object sender, EventArgs e)
{
TreeNode asmTreeNode = (TreeNode)_VirtualMachineNode.Tag;
if (asmTreeNode.Tag.GetType() == typeof(Azure.Asm.VirtualMachine) || asmTreeNode.Tag.GetType() == typeof(Azure.Arm.VirtualMachine))
{
RadioButton rb = (RadioButton)sender;
if (rb.Checked)
{
cmbExistingArmVNets.Items.Clear();
cmbExistingArmSubnet.Items.Clear();
TreeNode targetResourceGroupNode = _AsmToArmForm.SeekARMChildTreeNode(_AsmToArmForm.TargetResourceGroup.Name, _AsmToArmForm.TargetResourceGroup.GetFinalTargetName(), _AsmToArmForm.TargetResourceGroup, false);
TreeNode virtualNetworksNode = _AsmToArmForm.SeekARMChildTreeNode(targetResourceGroupNode.Nodes, "Virtual Networks", "Virtual Networks", "Virtual Networks", false);
if (virtualNetworksNode != null)
{
foreach (TreeNode asmVirtualNetworkNode in virtualNetworksNode.Nodes)
{
TreeNode asmVirtualNetworkAsmParentNode = (TreeNode)asmVirtualNetworkNode.Tag;
if (asmVirtualNetworkAsmParentNode.Tag.GetType() == typeof(Azure.Asm.VirtualNetwork))
{
if (((Azure.Asm.VirtualNetwork)asmVirtualNetworkAsmParentNode.Tag).HasNonGatewaySubnet)
{
cmbExistingArmVNets.Items.Add(asmVirtualNetworkAsmParentNode.Tag);
}
}
else if (asmVirtualNetworkAsmParentNode.Tag.GetType() == typeof(Azure.Arm.VirtualNetwork))
{
if (((Azure.Arm.VirtualNetwork)asmVirtualNetworkAsmParentNode.Tag).HasNonGatewaySubnet)
{
cmbExistingArmVNets.Items.Add(asmVirtualNetworkAsmParentNode.Tag);
}
}
}
}
if (asmTreeNode.Tag.GetType() == typeof(Azure.Asm.VirtualMachine))
{
Azure.Asm.VirtualMachine asmVirtualMachine = (Azure.Asm.VirtualMachine)asmTreeNode.Tag;
if (asmVirtualMachine.TargetVirtualNetwork != null)
{
// Attempt to match target to list items
foreach (Azure.Asm.VirtualNetwork listVirtualNetwork in cmbExistingArmVNets.Items)
{
if (listVirtualNetwork.Id == asmVirtualMachine.TargetVirtualNetwork.Id)
{
cmbExistingArmVNets.SelectedItem = listVirtualNetwork;
}
}
if (cmbExistingArmVNets.SelectedItem != null && asmVirtualMachine.TargetSubnet != null)
{
foreach (Azure.Asm.Subnet listSubnet in cmbExistingArmSubnet.Items)
{
if (listSubnet.Id == asmVirtualMachine.TargetSubnet.Id)
{
cmbExistingArmSubnet.SelectedItem = listSubnet;
}
}
}
}
}
}
}
else if (asmTreeNode.Tag.GetType() == typeof(Azure.Arm.VirtualMachine))
{
Azure.Arm.VirtualMachine asmVirtualMachine = (Azure.Arm.VirtualMachine)asmTreeNode.Tag;
}
await PropertyChanged();
}
private async void cmbExistingArmVNets_SelectedIndexChanged(object sender, EventArgs e)
{
TreeNode asmTreeNode = (TreeNode)_VirtualMachineNode.Tag;
if (asmTreeNode.Tag.GetType() == typeof(Azure.Asm.VirtualMachine))
{
Azure.Asm.VirtualMachine asmVirtualMachine = (Azure.Asm.VirtualMachine)asmTreeNode.Tag;
cmbExistingArmSubnet.Items.Clear();
if (rbVNetInMigration.Checked)
{
Azure.Asm.VirtualNetwork selectedAsmVirtualNetwork = (Azure.Asm.VirtualNetwork)cmbExistingArmVNets.SelectedItem;
foreach (Azure.Asm.Subnet asmSubnet in selectedAsmVirtualNetwork.Subnets)
{
if (asmSubnet.Name != ArmConst.GatewaySubnetName)
{
cmbExistingArmSubnet.Items.Add(asmSubnet);
}
}
if (asmVirtualMachine.TargetSubnet != null)
{
foreach (Azure.Asm.Subnet listSubnet in cmbExistingArmSubnet.Items)
{
if (listSubnet.Id == asmVirtualMachine.TargetSubnet.Id)
{
cmbExistingArmSubnet.SelectedItem = listSubnet;
}
}
}
}
else
{
Azure.Arm.VirtualNetwork selectedArmVirtualNetwork = (Azure.Arm.VirtualNetwork)cmbExistingArmVNets.SelectedItem;
foreach (Azure.Arm.Subnet armSubnet in selectedArmVirtualNetwork.Subnets)
{
if (armSubnet.Name != ArmConst.GatewaySubnetName)
{
cmbExistingArmSubnet.Items.Add(armSubnet);
}
}
if (asmVirtualMachine.TargetSubnet != null)
{
foreach (Azure.Arm.Subnet listSubnet in cmbExistingArmSubnet.Items)
{
if (listSubnet.Id == asmVirtualMachine.TargetSubnet.Id)
{
cmbExistingArmSubnet.SelectedItem = listSubnet;
}
}
}
}
}
else if (asmTreeNode.Tag.GetType() == typeof(Azure.Arm.VirtualMachine))
{
Azure.Arm.VirtualMachine armVirtualMachine = (Azure.Arm.VirtualMachine)asmTreeNode.Tag;
cmbExistingArmSubnet.Items.Clear();
if (rbVNetInMigration.Checked)
{
Azure.Arm.VirtualNetwork selectedArmVirtualNetwork = (Azure.Arm.VirtualNetwork)cmbExistingArmVNets.SelectedItem;
foreach (Azure.Arm.Subnet armSubnet in selectedArmVirtualNetwork.Subnets)
{
if (armSubnet.Name != ArmConst.GatewaySubnetName)
{
cmbExistingArmSubnet.Items.Add(armSubnet);
}
}
if (armVirtualMachine.TargetSubnet != null)
{
foreach (Azure.Arm.Subnet listSubnet in cmbExistingArmSubnet.Items)
{
if (listSubnet.Id == armVirtualMachine.TargetSubnet.Id)
{
cmbExistingArmSubnet.SelectedItem = listSubnet;
}
}
}
}
}
await PropertyChanged();
}
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");
}
}
private async Task AutoSelectDependencies(TreeNode selectedNode)
{
if ((app.Default.AutoSelectDependencies) && (selectedNode.Checked) && (selectedNode.Tag != null))
{
if (selectedNode.Tag.GetType() == typeof(Azure.Arm.VirtualMachine))
{
Azure.Arm.VirtualMachine armVirtualMachine = (Azure.Arm.VirtualMachine)selectedNode.Tag;
#region process virtual network
if (armVirtualMachine.VirtualNetwork != null)
{
foreach (TreeNode treeNode in treeSource.Nodes.Find(armVirtualMachine.VirtualNetwork.Name, true))
{
if ((treeNode.Tag != null) && (treeNode.Tag.GetType() == typeof(Azure.Arm.VirtualNetwork)))
{
if (!treeNode.Checked)
{
treeNode.Checked = true;
}
}
}
}
#endregion
#region OS Disk Storage Account
foreach (TreeNode treeNode in treeSource.Nodes.Find(armVirtualMachine.OSVirtualHardDisk.StorageAccountName, true))
{
if ((treeNode.Tag != null) && (treeNode.Tag.GetType() == typeof(Azure.Arm.StorageAccount)))
{
if (!treeNode.Checked)
{
treeNode.Checked = true;
}
}
}
#endregion
#region Data Disk(s) Storage Account(s)
foreach (Disk dataDisk in armVirtualMachine.DataDisks)
{
foreach (TreeNode treeNode in treeSource.Nodes.Find(dataDisk.StorageAccountName, true))
{
if ((treeNode.Tag != null) && (treeNode.Tag.GetType() == typeof(Azure.Arm.StorageAccount)))
{
if (!treeNode.Checked)
{
treeNode.Checked = true;
}
}
}
}
#endregion
#region Network Security Group
if (armVirtualMachine.NetworkSecurityGroup != null)
{
foreach (TreeNode treeNode in treeSource.Nodes.Find(armVirtualMachine.NetworkSecurityGroup.Name, true))
{
if ((treeNode.Tag != null) && (treeNode.Tag.GetType() == typeof(Azure.Asm.NetworkSecurityGroup)))
{
if (!treeNode.Checked)
{
treeNode.Checked = true;
}
}
}
}
#endregion
}
else if (selectedNode.Tag.GetType() == typeof(Azure.Arm.VirtualNetwork))
{
Azure.Arm.VirtualNetwork armVirtualNetwork = (Azure.Arm.VirtualNetwork)selectedNode.Tag;
foreach (Azure.Arm.Subnet armSubnet in armVirtualNetwork.Subnets)
{
if (armSubnet.NetworkSecurityGroup != null)
{
foreach (TreeNode treeNode in treeSource.Nodes.Find(armSubnet.NetworkSecurityGroup.Name, true))
{
if ((treeNode.Tag != null) && (treeNode.Tag.GetType() == typeof(Azure.Arm.NetworkSecurityGroup)))
{
if (!treeNode.Checked)
{
treeNode.Checked = true;
}
}
}
}
}
}
}
StatusProvider.UpdateStatus("Ready");
}
