internal void TransitionToClassicDisk(TreeNode targetTreeNode)
{
if (targetTreeNode.Tag == null || targetTreeNode.Tag.GetType() != typeof(Azure.MigrationTarget.Disk))
{
throw new ArgumentException("Invalid Treenode. Treenode Tag must contain a Migration Disk object.");
}
Azure.MigrationTarget.Disk targetDisk = (Azure.MigrationTarget.Disk)targetTreeNode.Tag;
if (targetDisk.SourceDisk != null)
{
TreeNode diskParentNode = targetTreeNode.Parent;
// Move the disk treenode to be a child under the resource group, not under the VM, as we are making it a Managed Disk
if (targetTreeNode.Parent.Tag != null && targetTreeNode.Parent.Tag.GetType() == typeof(Azure.MigrationTarget.ResourceGroup))
{
// Seek the Virtual Machine Tree Node
TreeNode virtualMachineNode = SeekARMChildTreeNode(targetTreeNode.Parent.Nodes, targetDisk.ParentVirtualMachine.ToString(), targetDisk.ParentVirtualMachine.ToString(), targetDisk.ParentVirtualMachine, false);
if (virtualMachineNode != null)
{
treeTargetARM.Nodes.Remove(targetTreeNode);
virtualMachineNode.Nodes.Add(targetTreeNode);
treeTargetARM.SelectedNode = targetTreeNode;
}
}
}
}
internal void TransitionToManagedDisk(TreeNode targetTreeNode)
{
if (targetTreeNode.Tag == null || targetTreeNode.Tag.GetType() != typeof(Azure.MigrationTarget.Disk))
{
throw new ArgumentException("Invalid Treenode. Treenode Tag must contain a Migration Disk object.");
}
Azure.MigrationTarget.Disk targetDisk = (Azure.MigrationTarget.Disk)targetTreeNode.Tag;
if (targetDisk.SourceDisk != null)
{
TreeNode diskParentNode = targetTreeNode.Parent;
while (diskParentNode != null && diskParentNode.Tag != null && diskParentNode.Tag.GetType() != typeof(Azure.MigrationTarget.ResourceGroup))
{
diskParentNode = diskParentNode.Parent;
}
// Move the disk treenode to be a child under the resource group, not under the VM, as we are making it a Managed Disk
if (diskParentNode != null)
{
treeTargetARM.Nodes.Remove(targetTreeNode);
diskParentNode.Nodes.Add(targetTreeNode);
treeTargetARM.SelectedNode = targetTreeNode;
}
}
}
private void GetExportArtifactsRecursive(TreeNode parentTreeNode, ref ExportArtifacts exportArtifacts)
{
foreach (TreeNode selectedNode in parentTreeNode.Nodes)
{
Type tagType = selectedNode.Tag.GetType();
if (tagType == typeof(Azure.MigrationTarget.VirtualNetwork))
{
exportArtifacts.VirtualNetworks.Add((Azure.MigrationTarget.VirtualNetwork)selectedNode.Tag);
}
//else if (tagType == typeof(Azure.MigrationTarget.StorageAccount))
//{
// exportArtifacts.StorageAccounts.Add((Azure.MigrationTarget.StorageAccount)selectedNode.Tag);
//}
else if (tagType == typeof(Azure.MigrationTarget.NetworkSecurityGroup))
{
exportArtifacts.NetworkSecurityGroups.Add((Azure.MigrationTarget.NetworkSecurityGroup)selectedNode.Tag);
}
else if (tagType == typeof(Azure.MigrationTarget.AvailabilitySet))
{
exportArtifacts.AvailablitySets.Add((Azure.MigrationTarget.AvailabilitySet)selectedNode.Tag);
}
else if (tagType == typeof(Azure.MigrationTarget.VirtualMachine))
{
exportArtifacts.VirtualMachines.Add((Azure.MigrationTarget.VirtualMachine)selectedNode.Tag);
}
else if (tagType == typeof(Azure.MigrationTarget.LoadBalancer))
{
exportArtifacts.LoadBalancers.Add((Azure.MigrationTarget.LoadBalancer)selectedNode.Tag);
}
else if (tagType == typeof(Azure.MigrationTarget.PublicIp))
{
exportArtifacts.PublicIPs.Add((Azure.MigrationTarget.PublicIp)selectedNode.Tag);
}
else if (tagType == typeof(Azure.MigrationTarget.Disk))
{
Azure.MigrationTarget.Disk targetDisk = (Azure.MigrationTarget.Disk)selectedNode.Tag;
if (targetDisk.TargetStorage != null && targetDisk.TargetStorage.GetType() == typeof(Azure.MigrationTarget.ManagedDiskStorage))
{
// We are only adding the Target Disk into the Export Artifacts as a Disk object if the Target Disk is targeted as a Managed Disk.
// Otherwise, it is a Classic Disk and will be generated as part of the Virtual Machine JSON (does not have a stand alone Disk object).
exportArtifacts.Disks.Add((Azure.MigrationTarget.Disk)selectedNode.Tag);
}
}
else if (tagType == typeof(Azure.MigrationTarget.NetworkInterface))
{
exportArtifacts.NetworkInterfaces.Add((Azure.MigrationTarget.NetworkInterface)selectedNode.Tag);
}
else if (tagType == typeof(Azure.MigrationTarget.RouteTable))
{
exportArtifacts.RouteTables.Add((Azure.MigrationTarget.RouteTable)selectedNode.Tag);
}
}
foreach (TreeNode treeNode in parentTreeNode.Nodes)
{
GetExportArtifactsRecursive(treeNode, ref exportArtifacts);
}
}
internal void Bind(AzureContext azureContext, TargetTreeView targetTreeView, Azure.MigrationTarget.Disk targetDisk)
{
_AzureContext = azureContext;
_TargetTreeView = targetTreeView;
_TargetDisk = targetDisk;
BindCommon();
}
public async Task Bind(TreeNode migrationTargetNode)
{
this.Clear();
this._BoundTreeNode = migrationTargetNode;
if (this.AzureContext == null)
{
throw new ArgumentException("AzureContext Property must be set on Property Panel before Binding.");
}
if (this.LogProvider == null)
{
throw new ArgumentException("LogProvider Property must be set on Property Panel before Binding.");
}
if (migrationTargetNode != null && migrationTargetNode.Tag != null)
{
this.ResourceText = migrationTargetNode.Tag.ToString();
if (migrationTargetNode.Tag.GetType() == typeof(Azure.MigrationTarget.VirtualMachine))
{
this.ResourceImage = imageList1.Images["VirtualMachine"];
VirtualMachineProperties properties = new VirtualMachineProperties();
properties.AllowManangedDisk = false;
properties.PropertyChanged += Properties_PropertyChanged;
await properties.Bind(this.AzureContext, _TargetTreeView, (Azure.MigrationTarget.VirtualMachine) migrationTargetNode.Tag);
this.PropertyDetailControl = properties;
}
else if (migrationTargetNode.Tag.GetType() == typeof(Azure.MigrationTarget.NetworkSecurityGroup))
{
this.ResourceImage = imageList1.Images["NetworkSecurityGroup"];
NetworkSecurityGroupProperties properties = new NetworkSecurityGroupProperties();
properties.PropertyChanged += Properties_PropertyChanged;
properties.Bind((Azure.MigrationTarget.NetworkSecurityGroup)migrationTargetNode.Tag);
this.PropertyDetailControl = properties;
}
if (migrationTargetNode.Tag.GetType() == typeof(Azure.MigrationTarget.VirtualNetwork))
{
this.ResourceImage = imageList1.Images["VirtualNetwork"];
VirtualNetworkProperties properties = new VirtualNetworkProperties();
properties.PropertyChanged += Properties_PropertyChanged;
properties.Bind((Azure.MigrationTarget.VirtualNetwork)migrationTargetNode.Tag);
this.PropertyDetailControl = properties;
}
else if (migrationTargetNode.Tag.GetType() == typeof(Azure.MigrationTarget.Subnet))
{
this.ResourceImage = imageList1.Images["VirtualNetwork"];
SubnetProperties properties = new SubnetProperties();
properties.PropertyChanged += Properties_PropertyChanged;
properties.Bind((Azure.MigrationTarget.Subnet)migrationTargetNode.Tag);
this.PropertyDetailControl = properties;
}
else if (migrationTargetNode.Tag.GetType() == typeof(Azure.MigrationTarget.StorageAccount))
{
this.ResourceImage = imageList1.Images["StorageAccount"];
StorageAccountProperties properties = new StorageAccountProperties();
properties.PropertyChanged += Properties_PropertyChanged;
properties.Bind(this.AzureContext, (Azure.MigrationTarget.StorageAccount)migrationTargetNode.Tag);
this.PropertyDetailControl = properties;
}
else if (migrationTargetNode.Tag.GetType() == typeof(Azure.MigrationTarget.Disk))
{
Azure.MigrationTarget.Disk migrationDisk = (Azure.MigrationTarget.Disk)migrationTargetNode.Tag;
this.ResourceImage = imageList1.Images["Disk"];
DiskProperties properties = new DiskProperties();
properties.AllowManangedDisk = false;
properties.PropertyChanged += Properties_PropertyChanged;
properties.Bind(this.AzureContext, _TargetTreeView, (Azure.MigrationTarget.Disk)migrationTargetNode.Tag);
this.PropertyDetailControl = properties;
}
else if (migrationTargetNode.Tag.GetType() == typeof(Azure.MigrationTarget.AvailabilitySet))
{
this.ResourceImage = imageList1.Images["AvailabilitySet"];
AvailabilitySetProperties properties = new AvailabilitySetProperties();
properties.PropertyChanged += Properties_PropertyChanged;
properties.Bind(migrationTargetNode);
this.PropertyDetailControl = properties;
}
else if (migrationTargetNode.Tag.GetType() == typeof(Azure.MigrationTarget.NetworkInterface))
{
this.ResourceImage = imageList1.Images["NetworkInterface"];
NetworkInterfaceProperties properties = new NetworkInterfaceProperties();
properties.PropertyChanged += Properties_PropertyChanged;
await properties.Bind(this.AzureContext, _TargetTreeView, (Azure.MigrationTarget.NetworkInterface) migrationTargetNode.Tag);
this.PropertyDetailControl = properties;
}
else if (migrationTargetNode.Tag.GetType() == typeof(Azure.MigrationTarget.ResourceGroup))
{
this.ResourceImage = imageList1.Images["ResourceGroup"];
ResourceGroupProperties properties = new ResourceGroupProperties();
properties.PropertyChanged += Properties_PropertyChanged;
await properties.Bind(AzureContext, (Azure.MigrationTarget.ResourceGroup) migrationTargetNode.Tag);
this.PropertyDetailControl = properties;
}
else if (migrationTargetNode.Tag.GetType() == typeof(Azure.MigrationTarget.LoadBalancer))
{
this.ResourceImage = imageList1.Images["LoadBalancer"];
LoadBalancerProperties properties = new LoadBalancerProperties();
properties.PropertyChanged += Properties_PropertyChanged;
await properties.Bind((Azure.MigrationTarget.LoadBalancer) migrationTargetNode.Tag);
this.PropertyDetailControl = properties;
}
else if (migrationTargetNode.Tag.GetType() == typeof(Azure.MigrationTarget.PublicIp))
{
this.ResourceImage = imageList1.Images["PublicIp"];
PublicIpProperties properties = new PublicIpProperties();
properties.PropertyChanged += Properties_PropertyChanged;
properties.Bind((Azure.MigrationTarget.PublicIp)migrationTargetNode.Tag);
this.PropertyDetailControl = properties;
}
}
}
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());
}
}
