public void Bind(VirtualNetwork targetVirtualNetwork, TargetTreeView targetTreeView) { try { this.IsBinding = true; _VirtualNetwork = targetVirtualNetwork; _TargetTreeView = targetTreeView; if (targetVirtualNetwork.SourceVirtualNetwork != null) { if (targetVirtualNetwork.SourceVirtualNetwork.GetType() == typeof(Azure.Asm.VirtualNetwork)) { Azure.Asm.VirtualNetwork asmVirtualNetwork = (Azure.Asm.VirtualNetwork)targetVirtualNetwork.SourceVirtualNetwork; lblVNetName.Text = asmVirtualNetwork.Name; } else if (targetVirtualNetwork.SourceVirtualNetwork.GetType() == typeof(Azure.Arm.VirtualNetwork)) { Azure.Arm.VirtualNetwork armVirtualNetwork = (Azure.Arm.VirtualNetwork)targetVirtualNetwork.SourceVirtualNetwork; lblVNetName.Text = armVirtualNetwork.Name; } } else { lblVNetName.Text = "(None)"; } txtVirtualNetworkName.Text = targetVirtualNetwork.TargetName; dgvAddressSpaces.DataSource = targetVirtualNetwork.AddressPrefixes.Select(x => new { AddressPrefix = x }).ToList(); } finally { this.IsBinding = false; } }
public void Bind(MigrationTarget.VirtualNetwork targetVirtualNetwork) { _VirtualNetwork = targetVirtualNetwork; if (targetVirtualNetwork.SourceVirtualNetwork != null) { if (targetVirtualNetwork.SourceVirtualNetwork.GetType() == typeof(Azure.Asm.VirtualNetwork)) { Azure.Asm.VirtualNetwork asmVirtualNetwork = (Azure.Asm.VirtualNetwork)targetVirtualNetwork.SourceVirtualNetwork; lblVNetName.Text = asmVirtualNetwork.Name; } else if (targetVirtualNetwork.SourceVirtualNetwork.GetType() == typeof(Azure.Arm.VirtualNetwork)) { Azure.Arm.VirtualNetwork armVirtualNetwork = (Azure.Arm.VirtualNetwork)targetVirtualNetwork.SourceVirtualNetwork; lblVNetName.Text = armVirtualNetwork.Name; } } else { lblVNetName.Text = "(None)"; } txtVirtualNetworkName.Text = targetVirtualNetwork.TargetName; dgvAddressSpaces.DataSource = targetVirtualNetwork.AddressPrefixes.Select(x => new { AddressPrefix = x }).ToList(); }
private async void cmbExistingArmVNets_SelectedIndexChanged(object sender, EventArgs e) { TreeNode asmTreeNode = (TreeNode)_VirtualMachineNode.Tag; 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; } } } } await PropertyChanged(); }
private void txtVirtualNetworkName_TextChanged(object sender, EventArgs e) { TextBox txtSender = (TextBox)sender; TreeNode asmVirtualNetworkNode = (TreeNode)_ARMVirtualNetowrkNode.Tag; if (asmVirtualNetworkNode.Tag.GetType() == typeof(Azure.Asm.VirtualNetwork)) { Azure.Asm.VirtualNetwork asmVirtualNetwork = (Azure.Asm.VirtualNetwork)asmVirtualNetworkNode.Tag; asmVirtualNetwork.TargetName = txtSender.Text.Trim(); _ARMVirtualNetowrkNode.Text = asmVirtualNetwork.GetFinalTargetName(); } else if (asmVirtualNetworkNode.Tag.GetType() == typeof(Azure.Arm.VirtualNetwork)) { Azure.Arm.VirtualNetwork armVirtualNetwork = (Azure.Arm.VirtualNetwork)asmVirtualNetworkNode.Tag; armVirtualNetwork.TargetName = txtSender.Text.Trim(); _ARMVirtualNetowrkNode.Text = armVirtualNetwork.GetFinalTargetName(); } PropertyChanged(); }
public void Bind(TreeNode armVirtualNetworkNode) { _ARMVirtualNetowrkNode = armVirtualNetworkNode; TreeNode asmVirtualNetworkNode = (TreeNode)_ARMVirtualNetowrkNode.Tag; if (asmVirtualNetworkNode.Tag.GetType() == typeof(Azure.Asm.VirtualNetwork)) { Azure.Asm.VirtualNetwork asmVirtualNetwork = (Azure.Asm.VirtualNetwork)asmVirtualNetworkNode.Tag; lblVNetName.Text = asmVirtualNetwork.Name.ToString(); txtVirtualNetworkName.Text = asmVirtualNetwork.TargetName; dgvAddressSpaces.DataSource = asmVirtualNetwork.AddressPrefixes.Select(x => new { AddressPrefix = x }).ToList(); } else if (asmVirtualNetworkNode.Tag.GetType() == typeof(Azure.Arm.VirtualNetwork)) { Azure.Arm.VirtualNetwork asmVirtualNetwork = (Azure.Arm.VirtualNetwork)asmVirtualNetworkNode.Tag; lblVNetName.Text = asmVirtualNetwork.Name.ToString(); txtVirtualNetworkName.Text = asmVirtualNetwork.TargetName; dgvAddressSpaces.DataSource = asmVirtualNetwork.AddressPrefixes.Select(x => new { AddressPrefix = x }).ToList(); } }
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.Asm.StorageAccount)) { Azure.Asm.StorageAccount asmStorageAccount = (Azure.Asm.StorageAccount)treeNode.Tag; SaveSelectioStorageAccount saveSelectionStorageAccount = new SaveSelectioStorageAccount(); saveSelectionStorageAccount.StorageAccountName = asmStorageAccount.Name; saveSelectionStorageAccount.TargetStorageAccountName = asmStorageAccount.TargetName; saveSelection.StorageAccounts.Add(saveSelectionStorageAccount); } else if (tagType == typeof(Azure.Asm.VirtualMachine)) { Azure.Asm.VirtualMachine asmVirtualMachine = (Azure.Asm.VirtualMachine)treeNode.Tag; SaveSelectionVirtualMachine saveSelectionVirtualMachine = new SaveSelectionVirtualMachine(); saveSelectionVirtualMachine.CloudService = asmVirtualMachine.CloudServiceName; saveSelectionVirtualMachine.VirtualMachine = asmVirtualMachine.RoleName; if (asmVirtualMachine.TargetVirtualNetwork != null) { saveSelectionVirtualMachine.TargetVirtualNetwork = asmVirtualMachine.TargetVirtualNetwork.Id; } if (asmVirtualMachine.TargetSubnet != null) { saveSelectionVirtualMachine.TargetSubnet = asmVirtualMachine.TargetSubnet.Id; } // Add OS Disk Target Storage Account if (asmVirtualMachine.OSVirtualHardDisk.TargetStorageAccount != null) { saveSelectionVirtualMachine.TargetDiskStorageAccounts.Add(asmVirtualMachine.OSVirtualHardDisk.DiskName, asmVirtualMachine.OSVirtualHardDisk.TargetStorageAccount.Id); } // 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.Id); } } 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(); }
public async Task Read(Guid subscriptionId, AzureRetriever sourceAzureRetreiver, AzureRetriever targetAzureRetreiver, TreeView treeView) { try { StreamReader saveSelectionReader = new StreamReader(filePath); string jsontext = saveSelectionReader.ReadToEnd(); saveSelectionReader.Close(); saveSelections = JsonConvert.DeserializeObject <List <SaveSelection> >(jsontext); } catch { // If file does not exist, or invalid, starts a new object saveSelections = new List <SaveSelection>(); } if (saveSelections.Exists(x => x.SubscriptionId == subscriptionId)) { SaveSelection saveSelection = saveSelections.Find(x => x.SubscriptionId == subscriptionId); foreach (SaveSelectionVirtualNetwork saveSelectionVirtualNetwork in saveSelection.VirtualNetworks) { foreach (TreeNode treeNode in treeView.Nodes.Find(saveSelectionVirtualNetwork.VirtualNetworkName, true)) { if (treeNode.Tag.GetType() == typeof(Azure.Asm.VirtualNetwork)) { Azure.Asm.VirtualNetwork asmVirtualNetwork = (Azure.Asm.VirtualNetwork)treeNode.Tag; treeNode.Checked = true; } } } foreach (SaveSelectioStorageAccount saveSelectionStorageAccount in saveSelection.StorageAccounts) { foreach (TreeNode treeNode in treeView.Nodes.Find(saveSelectionStorageAccount.StorageAccountName, true)) { if (treeNode.Tag.GetType() == typeof(Azure.Asm.StorageAccount)) { Azure.Asm.StorageAccount asmStorageAccount = (Azure.Asm.StorageAccount)treeNode.Tag; if (saveSelectionStorageAccount.TargetStorageAccountName.Length > 0) // We aren't going to reload a blank name, should it occur, as a name is required { asmStorageAccount.TargetName = saveSelectionStorageAccount.TargetStorageAccountName; } treeNode.Checked = true; } } } foreach (SaveSelectionVirtualMachine saveSelectionVirtualMachine in saveSelection.VirtualMachines) { foreach (TreeNode virtualMachineNode in treeView.Nodes.Find(saveSelectionVirtualMachine.VirtualMachine, true)) { if (virtualMachineNode.Tag != null) { if (virtualMachineNode.Tag.GetType() == typeof(Azure.Asm.VirtualMachine)) { Azure.Asm.VirtualMachine asmVirtualMachine = (Azure.Asm.VirtualMachine)virtualMachineNode.Tag; if (asmVirtualMachine.CloudServiceName == saveSelectionVirtualMachine.CloudService && asmVirtualMachine.RoleName == saveSelectionVirtualMachine.VirtualMachine) { asmVirtualMachine.TargetVirtualNetwork = SeekVirtualNetwork(saveSelectionVirtualMachine.TargetVirtualNetwork, await sourceAzureRetreiver.GetAzureAsmVirtualNetworks(), await targetAzureRetreiver.GetAzureARMVirtualNetworks()); asmVirtualMachine.TargetSubnet = SeekSubnet(saveSelectionVirtualMachine.TargetSubnet, asmVirtualMachine.TargetVirtualNetwork); if (saveSelectionVirtualMachine.TargetDiskStorageAccounts.ContainsKey(asmVirtualMachine.OSVirtualHardDisk.DiskName)) { asmVirtualMachine.OSVirtualHardDisk.TargetStorageAccount = SeekStorageAccount(saveSelectionVirtualMachine.TargetDiskStorageAccounts[asmVirtualMachine.OSVirtualHardDisk.DiskName].ToString(), await sourceAzureRetreiver.GetAzureAsmStorageAccounts(), await targetAzureRetreiver.GetAzureARMStorageAccounts()); } foreach (Azure.Asm.Disk asmDataDisk in asmVirtualMachine.DataDisks) { if (saveSelectionVirtualMachine.TargetDiskStorageAccounts.ContainsKey(asmDataDisk.DiskName)) { asmDataDisk.TargetStorageAccount = SeekStorageAccount(saveSelectionVirtualMachine.TargetDiskStorageAccounts[asmDataDisk.DiskName].ToString(), await sourceAzureRetreiver.GetAzureAsmStorageAccounts(), await targetAzureRetreiver.GetAzureARMStorageAccounts()); } } virtualMachineNode.Checked = true; } } } } } } }
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); } }
private async Task AutoSelectDependencies(TreeNode selectedNode) { if ((app.Default.AutoSelectDependencies) && (selectedNode.Checked) && (selectedNode.Tag != null)) { if (selectedNode.Tag.GetType() == typeof(Azure.Asm.VirtualMachine)) { Azure.Asm.VirtualMachine asmVirtualMachine = (Azure.Asm.VirtualMachine)selectedNode.Tag; #region process virtual network if (asmVirtualMachine.VirtualNetworkName != string.Empty) { foreach (TreeNode treeNode in treeSourceASM.Nodes.Find(asmVirtualMachine.VirtualNetworkName, true)) { if ((treeNode.Tag != null) && (treeNode.Tag.GetType() == typeof(Azure.Asm.VirtualNetwork))) { if (!treeNode.Checked) { treeNode.Checked = true; } } } } #endregion #region OS Disk Storage Account foreach (TreeNode treeNode in treeSourceASM.Nodes.Find(asmVirtualMachine.OSVirtualHardDisk.StorageAccountName, true)) { if ((treeNode.Tag != null) && (treeNode.Tag.GetType() == typeof(Azure.Asm.StorageAccount))) { if (!treeNode.Checked) { treeNode.Checked = true; } } } #endregion #region Data Disk(s) Storage Account(s) foreach (Azure.Asm.Disk dataDisk in asmVirtualMachine.DataDisks) { foreach (TreeNode treeNode in treeSourceASM.Nodes.Find(dataDisk.StorageAccountName, true)) { if ((treeNode.Tag != null) && (treeNode.Tag.GetType() == typeof(Azure.Asm.StorageAccount))) { if (!treeNode.Checked) { treeNode.Checked = true; } } } } #endregion #region Network Security Group if (asmVirtualMachine.NetworkSecurityGroup != null) { foreach (TreeNode treeNode in treeSourceASM.Nodes.Find(asmVirtualMachine.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.Asm.VirtualNetwork)) { Azure.Asm.VirtualNetwork asmVirtualNetwork = (Azure.Asm.VirtualNetwork)selectedNode.Tag; foreach (Azure.Asm.Subnet asmSubnet in asmVirtualNetwork.Subnets) { if (asmSubnet.NetworkSecurityGroup != null) { foreach (TreeNode treeNode in treeSourceASM.Nodes.Find(asmSubnet.NetworkSecurityGroup.Name, true)) { if ((treeNode.Tag != null) && (treeNode.Tag.GetType() == typeof(Azure.Asm.NetworkSecurityGroup))) { if (!treeNode.Checked) { treeNode.Checked = true; } } } } } } StatusProvider.UpdateStatus("Ready"); } }
private async Task BindAsmResources(AzureContext azureContext, TargetSettings targetSettings) { treeAzureASM.Nodes.Clear(); try { if (_AzureContextSource != null && _AzureContextSource.AzureSubscription != null) { await _AzureContextSource.AzureSubscription.BindAsmResources(targetSettings); if (_AzureContextSource != null && _AzureContextSource.AzureSubscription != null) { TreeNode subscriptionNodeASM = new TreeNode(_AzureContextSource.AzureSubscription.Name); treeAzureASM.Nodes.Add(subscriptionNodeASM); subscriptionNodeASM.Expand(); foreach (Azure.MigrationTarget.NetworkSecurityGroup targetNetworkSecurityGroup in _AzureContextSource.AzureSubscription.AsmTargetNetworkSecurityGroups) { Azure.Asm.NetworkSecurityGroup asmNetworkSecurityGroup = (Azure.Asm.NetworkSecurityGroup)targetNetworkSecurityGroup.SourceNetworkSecurityGroup; TreeNode parentNode = GetDataCenterTreeViewNode(subscriptionNodeASM, asmNetworkSecurityGroup.Location, "Network Security Groups"); TreeNode tnNetworkSecurityGroup = new TreeNode(targetNetworkSecurityGroup.SourceName); tnNetworkSecurityGroup.Name = targetNetworkSecurityGroup.SourceName; tnNetworkSecurityGroup.Tag = targetNetworkSecurityGroup; parentNode.Nodes.Add(tnNetworkSecurityGroup); parentNode.Expand(); } foreach (Azure.MigrationTarget.VirtualNetwork targetVirtualNetwork in _AzureContextSource.AzureSubscription.AsmTargetVirtualNetworks) { Azure.Asm.VirtualNetwork asmVirtualNetwork = (Azure.Asm.VirtualNetwork)targetVirtualNetwork.SourceVirtualNetwork; TreeNode parentNode = GetDataCenterTreeViewNode(subscriptionNodeASM, asmVirtualNetwork.Location, "Virtual Networks"); TreeNode tnVirtualNetwork = new TreeNode(targetVirtualNetwork.SourceName); tnVirtualNetwork.Name = targetVirtualNetwork.SourceName; tnVirtualNetwork.Text = targetVirtualNetwork.SourceName; tnVirtualNetwork.Tag = targetVirtualNetwork; parentNode.Nodes.Add(tnVirtualNetwork); parentNode.Expand(); } foreach (Azure.MigrationTarget.StorageAccount targetStorageAccount in _AzureContextSource.AzureSubscription.AsmTargetStorageAccounts) { TreeNode parentNode = GetDataCenterTreeViewNode(subscriptionNodeASM, targetStorageAccount.SourceAccount.PrimaryLocation, "Storage Accounts"); TreeNode tnStorageAccount = new TreeNode(targetStorageAccount.SourceName); tnStorageAccount.Name = targetStorageAccount.SourceName; tnStorageAccount.Tag = targetStorageAccount; parentNode.Nodes.Add(tnStorageAccount); parentNode.Expand(); } foreach (Azure.MigrationTarget.VirtualMachine targetVirtualMachine in _AzureContextSource.AzureSubscription.AsmTargetVirtualMachines) { Azure.Asm.VirtualMachine asmVirtualMachine = (Azure.Asm.VirtualMachine)targetVirtualMachine.Source; TreeNode parentNode = GetDataCenterTreeViewNode(subscriptionNodeASM, asmVirtualMachine.Location, "Cloud Services"); TreeNode[] cloudServiceNodeSearch = parentNode.Nodes.Find(targetVirtualMachine.TargetAvailabilitySet.TargetName, false); TreeNode cloudServiceNode = null; if (cloudServiceNodeSearch.Count() == 1) { cloudServiceNode = cloudServiceNodeSearch[0]; } cloudServiceNode = new TreeNode(targetVirtualMachine.TargetAvailabilitySet.TargetName); cloudServiceNode.Name = targetVirtualMachine.TargetAvailabilitySet.TargetName; cloudServiceNode.Tag = targetVirtualMachine.TargetAvailabilitySet; parentNode.Nodes.Add(cloudServiceNode); parentNode.Expand(); TreeNode virtualMachineNode = new TreeNode(targetVirtualMachine.SourceName); virtualMachineNode.Name = targetVirtualMachine.SourceName; virtualMachineNode.Tag = targetVirtualMachine; cloudServiceNode.Nodes.Add(virtualMachineNode); cloudServiceNode.Expand(); foreach (Azure.MigrationTarget.NetworkInterface targetNetworkInterface in targetVirtualMachine.NetworkInterfaces) { if (targetNetworkInterface.BackEndAddressPool != null && targetNetworkInterface.BackEndAddressPool.LoadBalancer != null) { TreeNode loadBalancerNode = new TreeNode(targetNetworkInterface.BackEndAddressPool.LoadBalancer.SourceName); loadBalancerNode.Name = targetNetworkInterface.BackEndAddressPool.LoadBalancer.SourceName; loadBalancerNode.Tag = targetNetworkInterface.BackEndAddressPool.LoadBalancer; cloudServiceNode.Nodes.Add(loadBalancerNode); cloudServiceNode.Expand(); foreach (Azure.MigrationTarget.FrontEndIpConfiguration frontEnd in targetNetworkInterface.BackEndAddressPool.LoadBalancer.FrontEndIpConfigurations) { if (frontEnd.PublicIp != null) // if external load balancer { TreeNode publicIPAddressNode = new TreeNode(frontEnd.PublicIp.SourceName); publicIPAddressNode.Name = frontEnd.PublicIp.SourceName; publicIPAddressNode.Tag = frontEnd.PublicIp; cloudServiceNode.Nodes.Add(publicIPAddressNode); cloudServiceNode.Expand(); } } } } } subscriptionNodeASM.Expand(); treeAzureASM.Enabled = true; } } } catch (Exception exc) { if (exc.GetType() == typeof(System.Net.WebException)) { System.Net.WebException webException = (System.Net.WebException)exc; if (webException.Response != null) { HttpWebResponse exceptionResponse = (HttpWebResponse)webException.Response; if (exceptionResponse.StatusCode == HttpStatusCode.Forbidden) { ASM403ForbiddenExceptionDialog forbiddenDialog = new ASM403ForbiddenExceptionDialog(_AzureContextSource.LogProvider, exc); return; } } } UnhandledExceptionDialog exceptionDialog = new UnhandledExceptionDialog(_AzureContextSource.LogProvider, exc); exceptionDialog.ShowDialog(); } _AzureContextSource.StatusProvider.UpdateStatus("Ready"); }