public async void Bind(TreeNode armVirtualMachineNode, AsmToArmForm asmToArmForm)
{
_VirtualMachineNode = armVirtualMachineNode;
_AsmToArmForm = asmToArmForm;
TreeNode asmTreeNode = (TreeNode)_VirtualMachineNode.Tag;
AsmVirtualMachine asmVirtualMachine = (AsmVirtualMachine)asmTreeNode.Tag;
lblRoleSize.Text = asmVirtualMachine.RoleSize;
lblOS.Text = asmVirtualMachine.OSVirtualHardDiskOS;
lblVirtualNetworkName.Text = asmVirtualMachine.VirtualNetworkName;
lblSubnetName.Text = asmVirtualMachine.SubnetName;
lblStaticIpAddress.Text = asmVirtualMachine.StaticVirtualNetworkIPAddress;
txtARMVMName.Text = asmVirtualMachine.TargetName;
this.diskProperties1.Bind(asmToArmForm, asmVirtualMachine.OSVirtualHardDisk);
if ((asmVirtualMachine.TargetSubnet == null) ||
(asmVirtualMachine.TargetSubnet.GetType() == typeof(AsmSubnet)))
{
rbVNetInMigration.Checked = true;
}
else
{
rbExistingARMVNet.Checked = true;
}
}
private void cmbExistingArmSubnet_SelectedIndexChanged(object sender, EventArgs e)
{
TreeNode asmTreeNode = (TreeNode)_VirtualMachineNode.Tag;
AsmVirtualMachine asmVirtualMachine = (AsmVirtualMachine)asmTreeNode.Tag;
ComboBox cmbSender = (ComboBox)sender;
if (cmbSender.SelectedItem == null)
{
asmVirtualMachine.TargetVirtualNetwork = null;
asmVirtualMachine.TargetSubnet = null;
}
else
{
if (cmbSender.SelectedItem.GetType() == typeof(AsmSubnet))
{
AsmSubnet asmSubnet = (AsmSubnet)cmbSender.SelectedItem;
asmVirtualMachine.TargetVirtualNetwork = asmSubnet.Parent;
asmVirtualMachine.TargetSubnet = asmSubnet;
}
else if (cmbSender.SelectedItem.GetType() == typeof(ArmSubnet))
{
ArmSubnet armSubnet = (ArmSubnet)cmbSender.SelectedItem;
asmVirtualMachine.TargetVirtualNetwork = armSubnet.Parent;
asmVirtualMachine.TargetSubnet = armSubnet;
}
}
}
private void txtARMVMName_TextChanged(object sender, EventArgs e)
{
TreeNode asmTreeNode = (TreeNode)_VirtualMachineNode.Tag;
AsmVirtualMachine asmVirtualMachine = (AsmVirtualMachine)asmTreeNode.Tag;
asmVirtualMachine.TargetName = txtARMVMName.Text;
_VirtualMachineNode.Text = asmVirtualMachine.TargetName;
}
internal async Task <AsmVirtualMachine> GetAzureAsmVirtualMachine(AsmCloudService asmCloudService, string virtualMachineName)
{
Hashtable vmDetails = await this.GetVMDetails(asmCloudService.ServiceName, virtualMachineName);
XmlDocument virtualMachineXml = await this.GetAzureAsmResources("VirtualMachine", vmDetails);
AsmVirtualMachine asmVirtualMachine = new AsmVirtualMachine(this._AzureContext, asmCloudService, this._AzureContext.SettingsProvider, virtualMachineXml, vmDetails);
await asmVirtualMachine.InitializeChildren();
return(asmVirtualMachine);
}
private async void cmbExistingArmVNets_SelectedIndexChanged(object sender, EventArgs e)
{
TreeNode asmTreeNode = (TreeNode)_VirtualMachineNode.Tag;
AsmVirtualMachine asmVirtualMachine = (AsmVirtualMachine)asmTreeNode.Tag;
cmbExistingArmSubnet.Items.Clear();
if (rbVNetInMigration.Checked)
{
AsmVirtualNetwork selectedAsmVirtualNetwork = (AsmVirtualNetwork)cmbExistingArmVNets.SelectedItem;
foreach (AsmSubnet asmSubnet in selectedAsmVirtualNetwork.Subnets)
{
if (asmSubnet.Name != ArmConst.GatewaySubnetName)
{
cmbExistingArmSubnet.Items.Add(asmSubnet);
}
}
if (asmVirtualMachine.TargetSubnet != null)
{
foreach (AsmSubnet listSubnet in cmbExistingArmSubnet.Items)
{
if (listSubnet.Id == asmVirtualMachine.TargetSubnet.Id)
{
cmbExistingArmSubnet.SelectedItem = listSubnet;
}
}
}
}
else
{
ArmVirtualNetwork selectedArmVirtualNetwork = (ArmVirtualNetwork)cmbExistingArmVNets.SelectedItem;
foreach (ArmSubnet armSubnet in selectedArmVirtualNetwork.Subnets)
{
if (armSubnet.Name != ArmConst.GatewaySubnetName)
{
cmbExistingArmSubnet.Items.Add(armSubnet);
}
}
if (asmVirtualMachine.TargetSubnet != null)
{
foreach (ArmSubnet listSubnet in cmbExistingArmSubnet.Items)
{
if (listSubnet.Id == asmVirtualMachine.TargetSubnet.Id)
{
cmbExistingArmSubnet.SelectedItem = listSubnet;
}
}
}
}
}
public ArmAvailabilitySet(AzureContext azureContext, AsmVirtualMachine asmVirtualMachine) : base(Guid.Empty)
{
_AzureContext = azureContext;
if (asmVirtualMachine.AvailabilitySetName != String.Empty)
{
TargetName = asmVirtualMachine.AvailabilitySetName;
}
else
{
TargetName = asmVirtualMachine.CloudServiceName;
}
}
private void UpdateParentNode()
{
if (_ARMDataDiskNode != null)
{
TreeNode parentNode = (TreeNode)_ARMDataDiskNode.Parent.Tag;
AsmVirtualMachine parentVirtualMachine = (AsmVirtualMachine)parentNode.Tag;
foreach (AsmDisk parentDisk in parentVirtualMachine.DataDisks)
{
if (parentDisk.DiskName == _AsmDataDisk.DiskName)
{
parentDisk.TargetStorageAccount = _AsmDataDisk.TargetStorageAccount;
parentDisk.TargetName = _AsmDataDisk.TargetName;
}
}
}
}
internal ArmAvailabilitySet GetAzureARMAvailabilitySet(AsmVirtualMachine asmVirtualMachine)
{
if (_ArmAvailabilitySets == null)
{
_ArmAvailabilitySets = new List <ArmAvailabilitySet>();
}
foreach (ArmAvailabilitySet armAvailabilitySet in _ArmAvailabilitySets)
{
if (armAvailabilitySet.name == asmVirtualMachine.GetDefaultAvailabilitySetName())
{
return(armAvailabilitySet);
}
}
ArmAvailabilitySet newArmAvailabilitySet = new ArmAvailabilitySet(this._AzureContext, asmVirtualMachine);
_ArmAvailabilitySets.Add(newArmAvailabilitySet);
return(newArmAvailabilitySet);
}
private async void rbExistingARMVNet_CheckedChanged(object sender, EventArgs e)
{
TreeNode asmTreeNode = (TreeNode)_VirtualMachineNode.Tag;
AsmVirtualMachine asmVirtualMachine = (AsmVirtualMachine)asmTreeNode.Tag;
RadioButton rb = (RadioButton)sender;
if (rb.Checked)
{
cmbExistingArmVNets.Items.Clear();
cmbExistingArmSubnet.Items.Clear();
foreach (ArmVirtualNetwork armVirtualNetwork in await _AsmToArmForm.AzureContextTargetARM.AzureRetriever.GetAzureARMVirtualNetworks())
{
if (armVirtualNetwork.HasNonGatewaySubnet)
{
cmbExistingArmVNets.Items.Add(armVirtualNetwork);
}
}
if (asmVirtualMachine.TargetVirtualNetwork != null)
{
// Attempt to match target to list items
foreach (ArmVirtualNetwork listVirtualNetwork in cmbExistingArmVNets.Items)
{
if (listVirtualNetwork.Id == asmVirtualMachine.TargetVirtualNetwork.Id)
{
cmbExistingArmVNets.SelectedItem = listVirtualNetwork;
}
}
}
if ((cmbExistingArmVNets.SelectedItem == null) && (cmbExistingArmVNets.Items.Count > 0))
{
cmbExistingArmVNets.SelectedIndex = 0;
}
}
}
public async void LoadDocuments(string path)
{
string[] files = Directory.GetFiles(path, "*.xml");
Array.Sort(files);
foreach (var filename in files)
{
var doc = new XmlDocument();
doc.Load(filename);
var title = Path.GetFileNameWithoutExtension(filename);
var parts = title.Split('-');
string resourceType;
var info = new Hashtable();
switch (parts[1].ToLower())
{
case "azurelocations":
resourceType = "azurelocations";
foreach (XmlNode azureLocationXml in doc.SelectNodes("/Locations/Location"))
{
_AzureASMLocations.Add(new AsmLocation(_AzureContext, azureLocationXml));
}
break;
case "cloudservice":
resourceType = "CloudService";
info.Add("name", parts[2]);
_CloudServices.Add(new AsmCloudService(_AzureContext, doc));
break;
case "virtualmachine":
resourceType = "VirtualMachine";
info.Add("cloudservicename", parts[2]);
info.Add("virtualmachinename", parts[3]);
info.Add("deploymentname", parts[4]);
info.Add("loadbalancername", String.Empty);
info.Add("virtualnetworkname", String.Empty);
AsmCloudService parentCloudService = this.GetAzureAsmCloudService(parts[2]).Result;
AsmVirtualMachine asmVirtualMachine = new AsmVirtualMachine(_AzureContext, parentCloudService, this._AzureContext.SettingsProvider, doc, info);
await asmVirtualMachine.InitializeChildren();
asmVirtualMachine.OSVirtualHardDisk.TargetStorageAccount = asmVirtualMachine.OSVirtualHardDisk.SourceStorageAccount;
asmVirtualMachine.TargetVirtualNetwork = asmVirtualMachine.SourceVirtualNetwork;
asmVirtualMachine.TargetSubnet = asmVirtualMachine.SourceSubnet;
foreach (AsmDisk dataDisk in asmVirtualMachine.DataDisks)
{
dataDisk.TargetStorageAccount = dataDisk.SourceStorageAccount;
}
parentCloudService.VirtualMachines.Add(asmVirtualMachine);
break;
case "storageaccountkeys":
resourceType = "StorageAccountKeys";
info.Add("name", parts[2]);
this.GetAzureAsmStorageAccount(parts[2]).Result.Keys = new AsmStorageAccountKeys(_AzureContext, doc);
break;
case "storageaccount":
resourceType = "StorageAccount";
info.Add("name", parts[2]);
_StorageAccounts.Add(new AsmStorageAccount(_AzureContext, doc));
break;
case "virtualnetworks":
resourceType = "VirtualNetworks";
foreach (XmlNode virtualnetworksite in doc.SelectNodes("//VirtualNetworkSite"))
{
AsmVirtualNetwork asmVirtualNetwork = new AsmVirtualNetwork(_AzureContext, virtualnetworksite);
await asmVirtualNetwork.InitializeChildrenAsync();
_VirtualNetworks.Add(asmVirtualNetwork);
}
break;
case "clientrootcertificates":
resourceType = "ClientRootCertificates";
info.Add("virtualnetworkname", parts[2]);
foreach (XmlNode clientRootCertificateXml in doc.SelectNodes("//ClientRootCertificate"))
{
_ClientRootCertificates.Add(new AsmClientRootCertificate(_AzureContext, _VirtualNetworks[0], clientRootCertificateXml));
}
break;
case "clientrootcertificate":
resourceType = "ClientRootCertificate";
info.Add("virtualnetworkname", parts[2]);
info.Add("thumbprint", parts[3]);
break;
case "virtualnetworkgateway":
resourceType = "VirtualNetworkGateway";
info.Add("virtualnetworkname", parts[2]);
_VirtualNetworkGateway = new AsmVirtualNetworkGateway(_AzureContext, _VirtualNetworks[0], doc);
_VirtualNetworks[0].Gateway = _VirtualNetworkGateway;
break;
case "virtualnetworkgatewaysharedkey":
resourceType = "VirtualNetworkGatewaySharedKey";
info.Add("virtualnetworkname", parts[2]);
info.Add("localnetworksitename", parts[3]);
break;
case "networksecuritygroup":
resourceType = "NetworkSecurityGroup";
info.Add("name", parts[2]);
_NetworkSecurityGroup = new AsmNetworkSecurityGroup(_AzureContext, doc.SelectSingleNode("NetworkSecurityGroup"));
break;
case "routetable":
resourceType = "RouteTable";
info.Add("name", parts[2]);
_AsmRouteTable = new AsmRouteTable(_AzureContext, doc);
break;
case "reservedips":
resourceType = "ReservedIPs";
break;
default:
throw new Exception();
}
SetResponse(resourceType, info, doc);
}
}
private bool RecursiveHealthCheckNode(TreeNode treeNode)
{
if (treeNode.Tag != null)
{
if (treeNode.Tag.GetType() == typeof(ArmResourceGroup))
{
ArmResourceGroup armResourceGroup = (ArmResourceGroup)treeNode.Tag;
if (armResourceGroup.Location == null)
{
treeARM.SelectedNode = treeNode;
this.Refresh();
MessageBox.Show("Target Location must be selected before exporting.");
return(false);
}
}
else if (treeNode.Tag.GetType() == typeof(TreeNode)) // Tag is the sourced ASM TreeNode
{
TreeNode asmTreeNode = (TreeNode)treeNode.Tag;
if (asmTreeNode.Tag != null)
{
if (asmTreeNode.Tag.GetType() == typeof(AsmNetworkSecurityGroup))
{
AsmNetworkSecurityGroup asmNetworkSecurityGroup = (AsmNetworkSecurityGroup)asmTreeNode.Tag;
// Validate the Target Name is not blank
if (asmNetworkSecurityGroup.TargetName == String.Empty)
{
treeARM.SelectedNode = treeNode;
this.Refresh();
MessageBox.Show("Target Name must be selected before exporting.");
return(false);
}
}
else if (asmTreeNode.Tag.GetType() == typeof(AsmVirtualNetwork))
{
AsmVirtualNetwork asmVirtualNetwork = (AsmVirtualNetwork)asmTreeNode.Tag;
// Validate the Target Name is not blank
if (asmVirtualNetwork.TargetName == String.Empty)
{
treeARM.SelectedNode = treeNode;
this.Refresh();
MessageBox.Show("Target Name must be selected before exporting.");
return(false);
}
foreach (TreeNode virtualNetworkNode in treeNode.Parent.Nodes)
{
TreeNode asmVirtualNetworkNode = (TreeNode)virtualNetworkNode.Tag;
AsmVirtualNetwork asmVirtualNetworkCompare = (AsmVirtualNetwork)asmVirtualNetworkNode.Tag;
if (asmVirtualNetworkCompare.Name != asmVirtualNetwork.Name && asmVirtualNetworkCompare.TargetName == asmVirtualNetwork.TargetName)
{
treeARM.SelectedNode = treeNode;
this.Refresh();
MessageBox.Show("Target Names must be unique to migrate Virtual Networks.");
return(false);
}
}
}
else if (asmTreeNode.Tag.GetType() == typeof(AsmVirtualMachine))
{
AsmVirtualMachine asmVirtualMachine = (AsmVirtualMachine)asmTreeNode.Tag;
if (asmVirtualMachine.TargetName == String.Empty)
{
treeARM.SelectedNode = treeNode;
this.Refresh();
MessageBox.Show("Target Name for Virtual Machine must be specified.");
return(false);
}
if (asmVirtualMachine.TargetAvailabilitySet == null)
{
treeARM.SelectedNode = treeNode;
this.Refresh();
MessageBox.Show("Target Availability Set for Virtual Machine must be specified.");
return(false);
}
if (asmVirtualMachine.TargetVirtualNetwork == null)
{
treeARM.SelectedNode = treeNode;
this.Refresh();
MessageBox.Show("Target Virtual Network for Virtual Machine must be specified.");
return(false);
}
if (asmVirtualMachine.TargetSubnet == null)
{
treeARM.SelectedNode = treeNode;
this.Refresh();
MessageBox.Show("Target Subnet for Virtual Machine must be specified.");
return(false);
}
if (asmVirtualMachine.OSVirtualHardDisk.TargetStorageAccount == null)
{
treeARM.SelectedNode = treeNode;
this.Refresh();
MessageBox.Show("Target VM OS Disk Storage Account must be specified.");
return(false);
}
}
else if (asmTreeNode.Tag.GetType() == typeof(AsmStorageAccount))
{
AsmStorageAccount asmStorageAccount = (AsmStorageAccount)asmTreeNode.Tag;
if (asmStorageAccount.TargetName == String.Empty)
{
treeARM.SelectedNode = treeNode;
this.Refresh();
MessageBox.Show("Target Storage Account Name must be specified.");
return(false);
}
}
}
}
else if (treeNode.Tag.GetType() == typeof(AsmSubnet))
{
AsmSubnet asmSubnet = (AsmSubnet)treeNode.Tag;
if (asmSubnet.TargetName == String.Empty)
{
treeARM.SelectedNode = treeNode;
this.Refresh();
MessageBox.Show("Target Subnet Name must be specified.");
return(false);
}
}
else if (treeNode.Tag.GetType() == typeof(ArmAvailabilitySet))
{
ArmAvailabilitySet armAvailabilitySet = (ArmAvailabilitySet)treeNode.Tag;
if (armAvailabilitySet.TargetName == String.Empty)
{
treeARM.SelectedNode = treeNode;
this.Refresh();
MessageBox.Show("Target Availability Set Name must be specified.");
return(false);
}
}
else if (treeNode.Tag.GetType() == typeof(AsmDisk))
{
AsmDisk asmDisk = (AsmDisk)treeNode.Tag;
if (asmDisk.TargetStorageAccount == null)
{
treeARM.SelectedNode = treeNode;
this.Refresh();
MessageBox.Show("Target VM Data Disk Storage Account must be specified.");
return(false);
}
}
}
foreach (TreeNode childNode in treeNode.Nodes)
{
bool nodeResult = RecursiveHealthCheckNode(childNode);
if (nodeResult == false)
{
return(false);
}
}
return(true);
}
private async Task AddASMNodeToARMTree(TreeNode asmTreeNode)
{
TreeNode targetResourceGroupNode = SeekARMChildTreeNode(treeARM.Nodes, _TargetResourceGroup.Name, _TargetResourceGroup.Name, _TargetResourceGroup, true);
Type tagType = asmTreeNode.Tag.GetType();
if (tagType == typeof(AsmVirtualNetwork))
{
AsmVirtualNetwork asmVirtualNetwork = (AsmVirtualNetwork)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 (AsmSubnet 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);
}
}
virtualNetworkNode.ExpandAll();
treeARM.SelectedNode = virtualNetworkNode;
treeARM.Focus();
}
else if (tagType == typeof(AsmStorageAccount))
{
AsmStorageAccount asmStorageAccount = (AsmStorageAccount)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);
treeARM.SelectedNode = storageAccountNode;
treeARM.Focus();
}
else if (tagType == typeof(AsmVirtualMachine))
{
AsmVirtualMachine asmVirtualMachine = (AsmVirtualMachine)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 (AsmDisk asmDataDisk in asmVirtualMachine.DataDisks)
{
TreeNode dataDiskNode = SeekARMChildTreeNode(virtualMachineNode.Nodes, asmDataDisk.DiskName, asmDataDisk.DiskName, asmDataDisk, true);
}
foreach (AsmNetworkInterface asmNetworkInterface in asmVirtualMachine.NetworkInterfaces)
{
TreeNode dataDiskNode = SeekARMChildTreeNode(virtualMachineNode.Nodes, asmNetworkInterface.Name, asmNetworkInterface.Name, asmNetworkInterface, true);
}
treeARM.SelectedNode = virtualMachineNode;
treeARM.Focus();
}
else if (tagType == typeof(AsmNetworkSecurityGroup))
{
AsmNetworkSecurityGroup asmNetworkSecurityGroup = (AsmNetworkSecurityGroup)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);
treeARM.SelectedNode = networkSecurityGroupNode;
treeARM.Focus();
}
else
{
throw new Exception("Unhandled Node Type: " + tagType);
}
}
private async Task AutoSelectDependencies(TreeNode selectedNode)
{
if ((app.Default.AutoSelectDependencies) && (selectedNode.Checked) && (selectedNode.Tag != null))
{
if (selectedNode.Tag.GetType() == typeof(AsmVirtualMachine))
{
AsmVirtualMachine asmVirtualMachine = (AsmVirtualMachine)selectedNode.Tag;
#region process virtual network
if (asmVirtualMachine.VirtualNetworkName != String.Empty)
{
foreach (TreeNode treeNode in treeASM.Nodes.Find(asmVirtualMachine.VirtualNetworkName, true))
{
if ((treeNode.Tag != null) && (treeNode.Tag.GetType() == typeof(AsmVirtualNetwork)))
{
if (!treeNode.Checked)
{
treeNode.Checked = true;
}
}
}
}
#endregion
#region OS Disk Storage Account
foreach (TreeNode treeNode in treeASM.Nodes.Find(asmVirtualMachine.OSVirtualHardDisk.StorageAccountName, true))
{
if ((treeNode.Tag != null) && (treeNode.Tag.GetType() == typeof(AsmStorageAccount)))
{
if (!treeNode.Checked)
{
treeNode.Checked = true;
}
}
}
#endregion
#region Data Disk(s) Storage Account(s)
foreach (AsmDisk dataDisk in asmVirtualMachine.DataDisks)
{
foreach (TreeNode treeNode in treeASM.Nodes.Find(dataDisk.StorageAccountName, true))
{
if ((treeNode.Tag != null) && (treeNode.Tag.GetType() == typeof(AsmStorageAccount)))
{
if (!treeNode.Checked)
{
treeNode.Checked = true;
}
}
}
}
#endregion
#region Network Security Group
if (asmVirtualMachine.NetworkSecurityGroup != null)
{
foreach (TreeNode treeNode in treeASM.Nodes.Find(asmVirtualMachine.NetworkSecurityGroup.Name, true))
{
if ((treeNode.Tag != null) && (treeNode.Tag.GetType() == typeof(AsmNetworkSecurityGroup)))
{
if (!treeNode.Checked)
{
treeNode.Checked = true;
}
}
}
}
#endregion
}
else if (selectedNode.Tag.GetType() == typeof(AsmVirtualNetwork))
{
AsmVirtualNetwork asmVirtualNetwork = (AsmVirtualNetwork)selectedNode.Tag;
foreach (AsmSubnet asmSubnet in asmVirtualNetwork.Subnets)
{
if (asmSubnet.NetworkSecurityGroup != null)
{
foreach (TreeNode treeNode in treeASM.Nodes.Find(asmSubnet.NetworkSecurityGroup.Name, true))
{
if ((treeNode.Tag != null) && (treeNode.Tag.GetType() == typeof(AsmNetworkSecurityGroup)))
{
if (!treeNode.Checked)
{
treeNode.Checked = true;
}
}
}
}
}
}
lblStatus.Text = "Ready";
}
}
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(AsmVirtualNetwork))
{
AsmVirtualNetwork asmVirtualNetwork = (AsmVirtualNetwork)treeNode.Tag;
SaveSelectionVirtualNetwork saveSelectionVirtualNetwork = new SaveSelectionVirtualNetwork();
saveSelectionVirtualNetwork.VirtualNetworkName = asmVirtualNetwork.Name;
saveSelection.VirtualNetworks.Add(saveSelectionVirtualNetwork);
}
else if (tagType == typeof(AsmStorageAccount))
{
AsmStorageAccount asmStorageAccount = (AsmStorageAccount)treeNode.Tag;
SaveSelectioStorageAccount saveSelectionStorageAccount = new SaveSelectioStorageAccount();
saveSelectionStorageAccount.StorageAccountName = asmStorageAccount.Name;
saveSelectionStorageAccount.TargetStorageAccountName = asmStorageAccount.TargetName;
saveSelection.StorageAccounts.Add(saveSelectionStorageAccount);
}
else if (tagType == typeof(AsmVirtualMachine))
{
AsmVirtualMachine asmVirtualMachine = (AsmVirtualMachine)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 (AsmDisk 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(AsmVirtualNetwork))
{
AsmVirtualNetwork asmVirtualNetwork = (AsmVirtualNetwork)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(AsmStorageAccount))
{
AsmStorageAccount asmStorageAccount = (AsmStorageAccount)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(AsmVirtualMachine))
{
AsmVirtualMachine asmVirtualMachine = (AsmVirtualMachine)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 (AsmDisk 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 void rbVNetInMigration_CheckedChanged(object sender, EventArgs e)
{
TreeNode asmTreeNode = (TreeNode)_VirtualMachineNode.Tag;
AsmVirtualMachine asmVirtualMachine = (AsmVirtualMachine)asmTreeNode.Tag;
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 (((AsmVirtualNetwork)asmVirtualNetworkAsmParentNode.Tag).HasNonGatewaySubnet)
{
cmbExistingArmVNets.Items.Add(asmVirtualNetworkAsmParentNode.Tag);
}
}
}
if (asmVirtualMachine.TargetVirtualNetwork != null)
{
// Attempt to match target to list items
foreach (AsmVirtualNetwork listVirtualNetwork in cmbExistingArmVNets.Items)
{
if (listVirtualNetwork.Id == asmVirtualMachine.TargetVirtualNetwork.Id)
{
cmbExistingArmVNets.SelectedItem = listVirtualNetwork;
}
}
if (cmbExistingArmVNets.SelectedItem != null && asmVirtualMachine.TargetSubnet != null)
{
foreach (AsmSubnet listSubnet in cmbExistingArmSubnet.Items)
{
if (listSubnet.Id == asmVirtualMachine.TargetSubnet.Id)
{
cmbExistingArmSubnet.SelectedItem = listSubnet;
}
}
}
}
if ((cmbExistingArmVNets.SelectedItem == null) && (cmbExistingArmVNets.Items.Count > 0))
{
foreach (AsmVirtualNetwork listVirtualNetwork in cmbExistingArmVNets.Items)
{
if (listVirtualNetwork.Name == asmVirtualMachine.VirtualNetworkName)
{
cmbExistingArmVNets.SelectedItem = listVirtualNetwork;
}
}
if (cmbExistingArmVNets.SelectedItem == null)
{
cmbExistingArmVNets.SelectedIndex = 0;
}
}
if ((cmbExistingArmSubnet.SelectedItem == null) && (cmbExistingArmSubnet.Items.Count > 0))
{
foreach (AsmSubnet listSubnet in cmbExistingArmSubnet.Items)
{
if (listSubnet.Name == asmVirtualMachine.SubnetName)
{
cmbExistingArmSubnet.SelectedItem = listSubnet;
}
}
if (cmbExistingArmSubnet.SelectedItem == null)
{
cmbExistingArmSubnet.SelectedIndex = 0;
}
}
}
}
