public async Task RemoveASMNodeFromARMTree(IMigrationTarget migrationTarget)
{
TreeNode targetResourceGroupNode = SeekResourceGroupTreeNode();
if (targetResourceGroupNode != null)
{
TreeNode[] matchingNodes = targetResourceGroupNode.Nodes.Find(migrationTarget.SourceName, true);
foreach (TreeNode matchingNode in matchingNodes)
{
if (matchingNode.Tag.GetType() == typeof(Azure.MigrationTarget.VirtualMachine))
{
await RemoveTreeNodeCascadeUp(matchingNode);
Azure.MigrationTarget.VirtualMachine targetVirtualMachine = (Azure.MigrationTarget.VirtualMachine)matchingNode.Tag;
// if there are VMs that have originating Classic Disks, we may need to clean them up from the Resource Group if they were being moved to a Managed Disk (not under the VM in the Treeview)
await RemoveAsmDiskTurnedManagedDiskFromARMTree(targetVirtualMachine.OSVirtualHardDisk);
foreach (MigrationTarget.Disk disk in targetVirtualMachine.DataDisks)
{
await RemoveAsmDiskTurnedManagedDiskFromARMTree(disk);
}
foreach (MigrationTarget.NetworkInterface networkInterface in targetVirtualMachine.NetworkInterfaces)
{
await RemoveAsmNetworkTurnedArmNetworkFromARMTree(networkInterface);
}
await RemoveCloudServiceTurnedAvailabilitySetFromARMTree(targetVirtualMachine.TargetAvailabilitySet);
}
else if (matchingNode.Tag.GetType() == migrationTarget.GetType())
{
await RemoveTreeNodeCascadeUp(matchingNode);
}
else if (matchingNode.Tag.GetType() == typeof(TreeNode))
{
TreeNode childTreeNode = (TreeNode)matchingNode.Tag;
if (migrationTarget.GetType() == childTreeNode.Tag.GetType())
{
await RemoveTreeNodeCascadeUp(matchingNode);
}
}
}
}
if (treeTargetARM.SelectedNode == null)
{
PropertyPanel.Clear();
}
}
public async Task Save(Guid subscriptionId, List <TreeNode> selectedNodes)
{
string jsontext = String.Empty;
try
{
StreamReader saveSelectionReader = new StreamReader(filePath);
jsontext = saveSelectionReader.ReadToEnd();
saveSelectionReader.Close();
saveSelections = JsonConvert.DeserializeObject <List <SaveSelection> >(jsontext);
// If save selection for this subscription alredy exists, remove it
if (saveSelections.Exists(x => x.SubscriptionId == subscriptionId))
{
saveSelections.Remove(saveSelections.Find(x => x.SubscriptionId == subscriptionId));
}
}
catch
{
// If file does not exist, or invalid, starts a new object
saveSelections = new List <SaveSelection>();
}
SaveSelection saveSelection = new SaveSelection();
saveSelection.SubscriptionId = subscriptionId;
saveSelection.VirtualNetworks = new List <SaveSelectionVirtualNetwork>();
saveSelection.StorageAccounts = new List <SaveSelectioStorageAccount>();
saveSelection.VirtualMachines = new List <SaveSelectionVirtualMachine>();
if (selectedNodes != null)
{
foreach (TreeNode treeNode in selectedNodes)
{
if (treeNode.Tag != null)
{
Type tagType = treeNode.Tag.GetType();
if (tagType == typeof(Azure.Asm.VirtualNetwork))
{
Azure.Asm.VirtualNetwork asmVirtualNetwork = (Azure.Asm.VirtualNetwork)treeNode.Tag;
SaveSelectionVirtualNetwork saveSelectionVirtualNetwork = new SaveSelectionVirtualNetwork();
saveSelectionVirtualNetwork.VirtualNetworkName = asmVirtualNetwork.Name;
saveSelection.VirtualNetworks.Add(saveSelectionVirtualNetwork);
}
else if (tagType == typeof(Azure.MigrationTarget.StorageAccount))
{
Azure.MigrationTarget.StorageAccount storageAccount = (Azure.MigrationTarget.StorageAccount)treeNode.Tag;
SaveSelectioStorageAccount saveSelectionStorageAccount = new SaveSelectioStorageAccount();
saveSelectionStorageAccount.StorageAccountName = storageAccount.SourceAccount.Name;
saveSelectionStorageAccount.TargetStorageAccountName = storageAccount.TargetName;
saveSelection.StorageAccounts.Add(saveSelectionStorageAccount);
}
else if (tagType == typeof(Azure.MigrationTarget.VirtualMachine))
{
Azure.MigrationTarget.VirtualMachine virtualMachine = (Azure.MigrationTarget.VirtualMachine)treeNode.Tag;
if (virtualMachine.Source.GetType() == typeof(Azure.Asm.VirtualMachine))
{
Azure.Asm.VirtualMachine asmVirtualMachine = (Azure.Asm.VirtualMachine)virtualMachine.Source;
SaveSelectionVirtualMachine saveSelectionVirtualMachine = new SaveSelectionVirtualMachine();
saveSelectionVirtualMachine.CloudService = asmVirtualMachine.CloudServiceName;
saveSelectionVirtualMachine.VirtualMachine = asmVirtualMachine.RoleName;
// todo now asap
//if (virtualMachine.TargetVirtualNetwork != null)
// saveSelectionVirtualMachine.TargetVirtualNetwork = virtualMachine.TargetVirtualNetwork.Id;
//if (virtualMachine.TargetSubnet != null)
// saveSelectionVirtualMachine.TargetSubnet = virtualMachine.TargetSubnet.Id;
////Add OS Disk Target Storage Account
//if (asmVirtualMachine.OSVirtualHardDisk.TargetStorageAccount != null)
// saveSelectionVirtualMachine.TargetDiskStorageAccounts.Add(asmVirtualMachine.OSVirtualHardDisk.DiskName, asmVirtualMachine.OSVirtualHardDisk.TargetStorageAccount.ToString());
//// Add OS Disk Target Storage Account
//foreach (Azure.Asm.Disk asmDataDisk in asmVirtualMachine.DataDisks)
//{
// if (asmDataDisk.TargetStorageAccount != null)
// saveSelectionVirtualMachine.TargetDiskStorageAccounts.Add(asmDataDisk.DiskName, asmDataDisk.TargetStorageAccount.ToString());
//}
saveSelection.VirtualMachines.Add(saveSelectionVirtualMachine);
}
}
}
}
}
saveSelections.Add(saveSelection);
// save blob copy details file
jsontext = JsonConvert.SerializeObject(saveSelections, Newtonsoft.Json.Formatting.Indented, new JsonSerializerSettings {
NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore
});
StreamWriter saveSelectionWriter = new StreamWriter(filePath);
saveSelectionWriter.Write(jsontext);
saveSelectionWriter.Close();
}
private async Task SelectDependencies(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.Asm.VirtualMachine))
{
Azure.Asm.VirtualMachine asmVirtualMachine = (Azure.Asm.VirtualMachine)targetVirtualMachine.Source;
#region process virtual network
foreach (Azure.MigrationTarget.NetworkInterface networkInterface in targetVirtualMachine.NetworkInterfaces)
{
#region Auto Select Virtual Network from each IpConfiguration
// 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.MigrationTarget.NetworkInterfaceIpConfiguration ipConfiguration in networkInterface.TargetNetworkInterfaceIpConfigurations)
//{
// if (ipConfiguration.TargetVirtualNetwork != null && ipConfiguration.TargetVirtualNetwork.GetType() == typeof(Azure.MigrationTarget.VirtualNetwork))
// {
// Azure.MigrationTarget.VirtualNetwork targetVirtualNetwork = (Azure.MigrationTarget.VirtualNetwork)ipConfiguration.TargetVirtualNetwork;
// foreach (TreeNode treeNode in selectedNode.TreeView.Nodes.Find(targetVirtualNetwork.SourceName, true))
// {
// if ((treeNode.Tag != null) && (treeNode.Tag.GetType() == typeof(Azure.MigrationTarget.VirtualNetwork)))
// {
// if (!treeNode.Checked)
// treeNode.Checked = true;
// }
// }
// }
//}
#endregion
#region Auto Select Network Security Group
if (asmVirtualMachine.NetworkSecurityGroup != null)
{
foreach (TreeNode treeNode in selectedNode.TreeView.Nodes.Find(asmVirtualMachine.NetworkSecurityGroup.Name, true))
{
if ((treeNode.Tag != null) && (treeNode.Tag.GetType() == typeof(Azure.MigrationTarget.NetworkSecurityGroup)))
{
if (!treeNode.Checked)
{
treeNode.Checked = true;
}
}
}
}
#endregion
}
#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.Asm.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;
}
}
}
}
}
}
}
}
_AzureContextSource.StatusProvider.UpdateStatus("Ready");
}
}
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");
}
}
public async Task <TreeNode> AddMigrationTargetToTargetTree(IMigrationTarget parentNode)
{
if (parentNode == null)
{
throw new ArgumentNullException("Migration Target cannot be null.");
}
TreeNode targetResourceGroupNode = SeekResourceGroupTreeNode();
if (parentNode.GetType() == typeof(Azure.MigrationTarget.VirtualNetwork))
{
Azure.MigrationTarget.VirtualNetwork targetVirtualNetwork = (Azure.MigrationTarget.VirtualNetwork)parentNode;
TreeNode virtualNetworkNode = SeekARMChildTreeNode(targetResourceGroupNode.Nodes, targetVirtualNetwork.SourceName, targetVirtualNetwork.ToString(), targetVirtualNetwork, true);
foreach (Azure.MigrationTarget.Subnet targetSubnet in targetVirtualNetwork.TargetSubnets)
{
TreeNode subnetNode = SeekARMChildTreeNode(virtualNetworkNode.Nodes, targetVirtualNetwork.ToString(), targetSubnet.ToString(), targetSubnet, true);
}
targetResourceGroupNode.ExpandAll();
return(virtualNetworkNode);
}
else if (parentNode.GetType() == typeof(Azure.MigrationTarget.StorageAccount))
{
Azure.MigrationTarget.StorageAccount targetStorageAccount = (Azure.MigrationTarget.StorageAccount)parentNode;
TreeNode storageAccountNode = SeekARMChildTreeNode(targetResourceGroupNode.Nodes, targetStorageAccount.SourceName, targetStorageAccount.ToString(), targetStorageAccount, true);
targetResourceGroupNode.ExpandAll();
return(storageAccountNode);
}
else if (parentNode.GetType() == typeof(Azure.MigrationTarget.NetworkSecurityGroup))
{
Azure.MigrationTarget.NetworkSecurityGroup targetNetworkSecurityGroup = (Azure.MigrationTarget.NetworkSecurityGroup)parentNode;
TreeNode networkSecurityGroupNode = SeekARMChildTreeNode(targetResourceGroupNode.Nodes, targetNetworkSecurityGroup.SourceName, targetNetworkSecurityGroup.ToString(), targetNetworkSecurityGroup, true);
targetResourceGroupNode.ExpandAll();
return(networkSecurityGroupNode);
}
else if (parentNode.GetType() == typeof(Azure.MigrationTarget.LoadBalancer))
{
Azure.MigrationTarget.LoadBalancer targetLoadBalancer = (Azure.MigrationTarget.LoadBalancer)parentNode;
TreeNode targetLoadBalancerNode = SeekARMChildTreeNode(targetResourceGroupNode.Nodes, targetLoadBalancer.SourceName, targetLoadBalancer.ToString(), targetLoadBalancer, true);
targetResourceGroupNode.ExpandAll();
return(targetLoadBalancerNode);
}
else if (parentNode.GetType() == typeof(Azure.MigrationTarget.PublicIp))
{
Azure.MigrationTarget.PublicIp targetPublicIp = (Azure.MigrationTarget.PublicIp)parentNode;
TreeNode targetPublicIpNode = SeekARMChildTreeNode(targetResourceGroupNode.Nodes, targetPublicIp.SourceName, targetPublicIp.ToString(), targetPublicIp, true);
targetResourceGroupNode.ExpandAll();
return(targetPublicIpNode);
}
else if (parentNode.GetType() == typeof(Azure.MigrationTarget.VirtualMachine))
{
Azure.MigrationTarget.VirtualMachine targetVirtualMachine = (Azure.MigrationTarget.VirtualMachine)parentNode;
TreeNode virtualMachineParentNode = targetResourceGroupNode;
TreeNode targetAvailabilitySetNode = null;
// https://docs.microsoft.com/en-us/azure/virtual-machines/windows/manage-availability
if (targetVirtualMachine.TargetAvailabilitySet != null)
{
targetAvailabilitySetNode = GetTargetAvailabilitySetNode(targetResourceGroupNode, targetVirtualMachine.TargetAvailabilitySet);
virtualMachineParentNode = targetAvailabilitySetNode;
}
TreeNode virtualMachineNode = SeekARMChildTreeNode(virtualMachineParentNode.Nodes, targetVirtualMachine.SourceName, targetVirtualMachine.ToString(), targetVirtualMachine, true);
foreach (Azure.MigrationTarget.Disk targetDisk in targetVirtualMachine.DataDisks)
{
TreeNode dataDiskNode = SeekARMChildTreeNode(virtualMachineNode.Nodes, targetDisk.ToString(), targetDisk.ToString(), targetDisk, true);
}
foreach (Azure.MigrationTarget.NetworkInterface targetNetworkInterface in targetVirtualMachine.NetworkInterfaces)
{
TreeNode networkInterfaceNode = SeekARMChildTreeNode(virtualMachineNode.Nodes, targetNetworkInterface.ToString(), targetNetworkInterface.ToString(), targetNetworkInterface, true);
}
targetResourceGroupNode.ExpandAll();
return(virtualMachineNode);
}
else
{
throw new Exception("Unhandled Node Type in AddMigrationTargetToTargetTree: " + parentNode.GetType());
}
}
public async Task <TreeNode> AddMigrationTargetToTargetTree(IMigrationTarget parentNode)
{
if (parentNode == null)
{
throw new ArgumentNullException("Migration Target cannot be null.");
}
TreeNode targetResourceGroupNode = SeekResourceGroupTreeNode();
if (parentNode.GetType() == typeof(Azure.MigrationTarget.VirtualNetwork))
{
Azure.MigrationTarget.VirtualNetwork targetVirtualNetwork = (Azure.MigrationTarget.VirtualNetwork)parentNode;
TreeNode virtualNetworkNode = SeekARMChildTreeNode(targetResourceGroupNode.Nodes, targetVirtualNetwork.SourceName, targetVirtualNetwork.ToString(), targetVirtualNetwork, true);
foreach (Azure.MigrationTarget.Subnet targetSubnet in targetVirtualNetwork.TargetSubnets)
{
TreeNode subnetNode = SeekARMChildTreeNode(virtualNetworkNode.Nodes, targetVirtualNetwork.ToString(), targetSubnet.ToString(), targetSubnet, true);
}
targetResourceGroupNode.ExpandAll();
return(virtualNetworkNode);
}
else if (parentNode.GetType() == typeof(Azure.MigrationTarget.StorageAccount))
{
Azure.MigrationTarget.StorageAccount targetStorageAccount = (Azure.MigrationTarget.StorageAccount)parentNode;
TreeNode storageAccountNode = SeekARMChildTreeNode(targetResourceGroupNode.Nodes, targetStorageAccount.SourceName, targetStorageAccount.ToString(), targetStorageAccount, true);
targetResourceGroupNode.ExpandAll();
return(storageAccountNode);
}
else if (parentNode.GetType() == typeof(Azure.MigrationTarget.NetworkSecurityGroup))
{
Azure.MigrationTarget.NetworkSecurityGroup targetNetworkSecurityGroup = (Azure.MigrationTarget.NetworkSecurityGroup)parentNode;
TreeNode networkSecurityGroupNode = SeekARMChildTreeNode(targetResourceGroupNode.Nodes, targetNetworkSecurityGroup.SourceName, targetNetworkSecurityGroup.ToString(), targetNetworkSecurityGroup, true);
targetResourceGroupNode.ExpandAll();
return(networkSecurityGroupNode);
}
else if (parentNode.GetType() == typeof(Azure.MigrationTarget.LoadBalancer))
{
Azure.MigrationTarget.LoadBalancer targetLoadBalancer = (Azure.MigrationTarget.LoadBalancer)parentNode;
TreeNode targetLoadBalancerNode = SeekARMChildTreeNode(targetResourceGroupNode.Nodes, targetLoadBalancer.SourceName, targetLoadBalancer.ToString(), targetLoadBalancer, true);
targetResourceGroupNode.ExpandAll();
return(targetLoadBalancerNode);
}
else if (parentNode.GetType() == typeof(Azure.MigrationTarget.PublicIp))
{
Azure.MigrationTarget.PublicIp targetPublicIp = (Azure.MigrationTarget.PublicIp)parentNode;
TreeNode targetPublicIpNode = SeekARMChildTreeNode(targetResourceGroupNode.Nodes, targetPublicIp.SourceName, targetPublicIp.ToString(), targetPublicIp, true);
targetResourceGroupNode.ExpandAll();
return(targetPublicIpNode);
}
else if (parentNode.GetType() == typeof(Azure.MigrationTarget.NetworkInterface))
{
Azure.MigrationTarget.NetworkInterface targetNetworkInterface = (Azure.MigrationTarget.NetworkInterface)parentNode;
TreeNode targetNetworkInterfaceNode = SeekARMChildTreeNode(targetResourceGroupNode.Nodes, targetNetworkInterface.ToString(), targetNetworkInterface.ToString(), targetNetworkInterface, true);
targetResourceGroupNode.ExpandAll();
return(targetNetworkInterfaceNode);
}
else if (parentNode.GetType() == typeof(Azure.MigrationTarget.AvailabilitySet))
{
Azure.MigrationTarget.AvailabilitySet targetAvailabilitySet = (Azure.MigrationTarget.AvailabilitySet)parentNode;
TreeNode targetAvailabilitySetNode = SeekARMChildTreeNode(targetResourceGroupNode.Nodes, targetAvailabilitySet.ToString(), targetAvailabilitySet.ToString(), targetAvailabilitySet, true);
targetResourceGroupNode.ExpandAll();
return(targetAvailabilitySetNode);
}
else if (parentNode.GetType() == typeof(Azure.MigrationTarget.VirtualMachine))
{
Azure.MigrationTarget.VirtualMachine targetVirtualMachine = (Azure.MigrationTarget.VirtualMachine)parentNode;
TreeNode virtualMachineParentNode = targetResourceGroupNode;
TreeNode virtualMachineNode = SeekARMChildTreeNode(virtualMachineParentNode.Nodes, targetVirtualMachine.SourceName, targetVirtualMachine.ToString(), targetVirtualMachine, true);
if (targetVirtualMachine.TargetAvailabilitySet != null)
{
if (targetVirtualMachine.TargetAvailabilitySet.SourceAvailabilitySet != null && targetVirtualMachine.TargetAvailabilitySet.SourceAvailabilitySet.GetType() == typeof(Asm.CloudService))
{
// Adding under Virtual Machine, as it is not a managed disk
TreeNode dataDiskNode = SeekARMChildTreeNode(targetResourceGroupNode.Nodes, targetVirtualMachine.TargetAvailabilitySet.ToString(), targetVirtualMachine.TargetAvailabilitySet.ToString(), targetVirtualMachine.TargetAvailabilitySet, true);
}
}
if (targetVirtualMachine.OSVirtualHardDisk.IsUnmanagedDisk)
{
// Adding under Virtual Machine, as it is not a managed disk
TreeNode dataDiskNode = SeekARMChildTreeNode(virtualMachineNode.Nodes, targetVirtualMachine.OSVirtualHardDisk.ToString(), targetVirtualMachine.OSVirtualHardDisk.ToString(), targetVirtualMachine.OSVirtualHardDisk, true);
}
else
{
// Under Resource Group, as it is a managed Disk
TreeNode dataDiskNode = SeekARMChildTreeNode(virtualMachineParentNode.Nodes, targetVirtualMachine.OSVirtualHardDisk.ToString(), targetVirtualMachine.OSVirtualHardDisk.ToString(), targetVirtualMachine.OSVirtualHardDisk, true);
}
foreach (Azure.MigrationTarget.Disk targetDisk in targetVirtualMachine.DataDisks)
{
if (targetDisk.IsUnmanagedDisk)
{
// Adding under Virtual Machine, as it is not a managed disk
TreeNode dataDiskNode = SeekARMChildTreeNode(virtualMachineNode.Nodes, targetDisk.ToString(), targetDisk.ToString(), targetDisk, true);
}
else
{
// Under Resource Group, as it is a managed Disk
TreeNode dataDiskNode = SeekARMChildTreeNode(virtualMachineParentNode.Nodes, targetDisk.ToString(), targetDisk.ToString(), targetDisk, true);
}
}
foreach (Azure.MigrationTarget.NetworkInterface targetNetworkInterface in targetVirtualMachine.NetworkInterfaces)
{
if (targetNetworkInterface.SourceNetworkInterface != null && targetNetworkInterface.SourceNetworkInterface.GetType() == typeof(Azure.Asm.NetworkInterface))
{
// We are only adding as a child node if it is an ASM Network Interface, otherwise we expect this to follow ARM convention in which NIC is a first class object in the resource group (not embededded under the VM).
TreeNode networkInterfaceNode = SeekARMChildTreeNode(targetResourceGroupNode.Nodes, targetNetworkInterface.ToString(), targetNetworkInterface.ToString(), targetNetworkInterface, true);
}
}
targetResourceGroupNode.ExpandAll();
return(virtualMachineNode);
}
else if (parentNode.GetType() == typeof(Azure.MigrationTarget.Disk))
{
Azure.MigrationTarget.Disk targetDisk = (Azure.MigrationTarget.Disk)parentNode;
TreeNode targetDiskNode = SeekARMChildTreeNode(targetResourceGroupNode.Nodes, targetDisk.SourceName, targetDisk.ToString(), targetDisk, true);
targetResourceGroupNode.ExpandAll();
return(targetDiskNode);
}
else if (parentNode.GetType() == typeof(Azure.MigrationTarget.VirtualMachineImage))
{
Azure.MigrationTarget.VirtualMachineImage targetVirtualMachineImage = (Azure.MigrationTarget.VirtualMachineImage)parentNode;
TreeNode targetVirtualMachineImageNode = SeekARMChildTreeNode(targetResourceGroupNode.Nodes, targetVirtualMachineImage.SourceName, targetVirtualMachineImage.ToString(), targetVirtualMachineImage, true);
targetResourceGroupNode.ExpandAll();
return(targetVirtualMachineImageNode);
}
else if (parentNode.GetType() == typeof(Azure.MigrationTarget.NetworkInterface))
{
Azure.MigrationTarget.NetworkInterface targetNetworkInterface = (Azure.MigrationTarget.NetworkInterface)parentNode;
TreeNode targetNetworkInterfaceNode = SeekARMChildTreeNode(targetResourceGroupNode.Nodes, targetNetworkInterface.SourceName, targetNetworkInterface.ToString(), targetNetworkInterface, true);
targetResourceGroupNode.ExpandAll();
return(targetNetworkInterfaceNode);
}
else if (parentNode.GetType() == typeof(Azure.MigrationTarget.RouteTable))
{
Azure.MigrationTarget.RouteTable targetRouteTable = (Azure.MigrationTarget.RouteTable)parentNode;
TreeNode targetRouteTableNode = SeekARMChildTreeNode(targetResourceGroupNode.Nodes, targetRouteTable.SourceName, targetRouteTable.ToString(), targetRouteTable, true);
targetRouteTableNode.ExpandAll();
return(targetRouteTableNode);
}
else
{
throw new Exception("Unhandled Node Type in AddMigrationTargetToTargetTree: " + parentNode.GetType());
}
}
