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();
}
public async Task ValidateDiskNamescapeChangeAcrossAzureEnvironments()
{
AzureContext azureContextUSCommercial = TestHelper.SetupAzureContext();
AzureContext azureContextUSGovernment = TestHelper.SetupAzureContext(AzureEnvironment.AzureUSGovernment);
FakeAzureRetriever azureContextUSCommercialRetriever = (FakeAzureRetriever)azureContextUSCommercial.AzureRetriever;
azureContextUSCommercialRetriever.LoadDocuments(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "TestDocs\\VM3"));
FakeAzureRetriever azureContextUSGovernmentRetriever = (FakeAzureRetriever)azureContextUSGovernment.AzureRetriever;
azureContextUSGovernmentRetriever.LoadDocuments(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "TestDocs\\i"));
AzureGenerator templateGenerator = await TestHelper.SetupTemplateGenerator(azureContextUSCommercial);
var artifacts = new ExportArtifacts();
Azure.Asm.VirtualMachine asmVirtualMachine = (Azure.Asm.VirtualMachine)(await azureContextUSCommercialRetriever.GetAzureAsmCloudServices())[0].VirtualMachines[0];
// todo asmVirtualMachine.OSVirtualHardDisk.TargetStorageAccount = await azureContextUSGovernmentRetriever.GetAzureAsmStorageAccount("targetstorage");
//artifacts.VirtualMachines.Add(asmVirtualMachine);
Assert.AreEqual(asmVirtualMachine.OSVirtualHardDisk.MediaLink, "https://mystorage.blob.core.windows.net/vhds/mydisk.vhd");
//Assert.AreEqual(asmVirtualMachine.OSVirtualHardDisk.TargetMediaLink, "https://targetstoragev2.blob.core.usgovcloudapi.net/vhds/mydisk.vhd");
}
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();
}
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 void treeASM_AfterCheck(object sender, TreeViewEventArgs e)
{
if (_SourceAsmNode == null)
{
_SourceAsmNode = e.Node;
}
if (e.Node.Checked)
{
await AutoSelectDependencies(e.Node);
}
if (e.Node.Tag != null)
{
if (e.Node.Tag.GetType() == typeof(Azure.Asm.VirtualMachine))
{
Azure.Asm.VirtualMachine asmVirtualMachine = (Azure.Asm.VirtualMachine)e.Node.Tag;
if (asmVirtualMachine.TargetVirtualNetwork == null)
{
asmVirtualMachine.TargetVirtualNetwork = await AzureContextSourceASM.AzureRetriever.GetAzureAsmVirtualNetwork(asmVirtualMachine.VirtualNetworkName);
if (asmVirtualMachine.TargetVirtualNetwork != null)
{
foreach (Azure.Asm.Subnet asmSubnect in asmVirtualMachine.TargetVirtualNetwork.Subnets)
{
if (asmSubnect.Name == asmVirtualMachine.SubnetName)
{
asmVirtualMachine.TargetSubnet = asmSubnect;
}
}
}
}
if (asmVirtualMachine.OSVirtualHardDisk.TargetStorageAccount == null)
{
asmVirtualMachine.OSVirtualHardDisk.TargetStorageAccount = await AzureContextSourceASM.AzureRetriever.GetAzureAsmStorageAccount(asmVirtualMachine.OSVirtualHardDisk.StorageAccountName);
}
foreach (Azure.Asm.Disk asmDisk in asmVirtualMachine.DataDisks)
{
if (asmDisk.TargetStorageAccount == null)
{
asmDisk.TargetStorageAccount = await AzureContextSourceASM.AzureRetriever.GetAzureAsmStorageAccount(asmDisk.StorageAccountName);
}
}
}
}
TreeNode resultUpdateARMTree = await UpdateARMTree(e.Node);
if (_SourceAsmNode != null && _SourceAsmNode == e.Node)
{
if (e.Node.Checked)
{
await MigAzTreeView.RecursiveCheckToggleDown(e.Node, e.Node.Checked);
MigAzTreeView.FillUpIfFullDown(e.Node);
treeSourceASM.SelectedNode = e.Node;
}
else
{
await MigAzTreeView.RecursiveCheckToggleUp(e.Node, e.Node.Checked);
await MigAzTreeView.RecursiveCheckToggleDown(e.Node, e.Node.Checked);
}
_SelectedNodes = this.GetSelectedNodes(treeSourceASM);
UpdateExportItemsCount();
await this.TemplateGenerator.UpdateArtifacts(GetAsmArtifacts());
_SourceAsmNode = null;
if (resultUpdateARMTree != null)
{
treeTargetARM.SelectedNode = resultUpdateARMTree;
}
}
}
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 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 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");
}
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();
}
