private void cmbTargetStorage_SelectedIndexChanged(object sender, EventArgs e)
{
ComboBox cmbSender = (ComboBox)sender;
if (cmbSender.SelectedItem == null)
{
_AsmDataDisk.TargetStorageAccount = null;
}
else
{
if (cmbSender.SelectedItem.GetType() == typeof(Azure.Asm.StorageAccount))
{
Azure.Asm.StorageAccount asmStorageAccount = (Azure.Asm.StorageAccount)cmbSender.SelectedItem;
_AsmDataDisk.TargetStorageAccount = asmStorageAccount;
}
else if (cmbSender.SelectedItem.GetType() == typeof(Azure.Arm.StorageAccount))
{
Azure.Arm.StorageAccount armStorageAccount = (Azure.Arm.StorageAccount)cmbSender.SelectedItem;
_AsmDataDisk.TargetStorageAccount = armStorageAccount;
}
else
{
_AsmDataDisk.TargetStorageAccount = null;
}
}
UpdateParentNode();
PropertyChanged();
}
private async void rbExistingARMStorageAccount_CheckedChanged(object sender, EventArgs e)
{
RadioButton rbSender = (RadioButton)sender;
if (rbSender.Checked)
{
cmbTargetStorage.Items.Clear();
cmbTargetStorage.Enabled = true;
txtBlobName.Enabled = true;
txtBlobName.Text = _TargetDisk.TargetStorageAccountBlob;
foreach (Azure.Arm.StorageAccount armStorageAccount in await _AzureContext.AzureRetriever.GetAzureARMStorageAccounts())
{
cmbTargetStorage.Items.Add(armStorageAccount);
}
if (_TargetDisk != null)
{
if (_TargetDisk.TargetStorageAccount != null)
{
if (_TargetDisk.TargetStorageAccount.GetType() == typeof(Azure.MigrationTarget.ManagedDisk))
{
_TargetDisk.TargetStorageAccount = null;
PropertyChanged?.Invoke();
}
else if (_TargetDisk.TargetStorageAccount.GetType() == typeof(Azure.Arm.StorageAccount))
{
for (int i = 0; i < cmbTargetStorage.Items.Count; i++)
{
if (cmbTargetStorage.Items[i].GetType() == typeof(Azure.Arm.StorageAccount))
{
Azure.Arm.StorageAccount cmbStorageAccount = (Azure.Arm.StorageAccount)cmbTargetStorage.Items[i];
if (cmbStorageAccount.ToString() == _TargetDisk.TargetStorageAccount.ToString())
{
cmbTargetStorage.SelectedIndex = i;
break;
}
}
}
// Using a for loop above, because this was always selecting Index 0, even when matched on a higher ( > 0) indexed item
//foreach (Azure.Arm.StorageAccount armStorageAccount in cmbTargetStorage.Items)
//{
// if (armStorageAccount.Id == _AsmDataDisk.TargetStorageAccount.Id)
// cmbTargetStorage.SelectedIndex = cmbTargetStorage.Items.IndexOf(armStorageAccount);
//}
}
}
}
}
_AzureContext.StatusProvider.UpdateStatus("Ready");
}
private async void rbExistingARMStorageAccount_CheckedChanged(object sender, EventArgs e)
{
RadioButton rbSender = (RadioButton)sender;
if (rbSender.Checked)
{
if (_TargetDisk.TargetStorage != null && _TargetDisk.TargetStorage.GetType() != typeof(Arm.StorageAccount))
{
_TargetDisk.TargetStorage = null;
}
cmbTargetStorage.Items.Clear();
cmbTargetStorage.Enabled = true;
txtBlobName.Enabled = true;
txtBlobName.Text = _TargetDisk.TargetStorageAccountBlob;
foreach (Arm.StorageAccount armStorageAccount in _TargetTreeView.GetExistingArmStorageAccounts())
{
cmbTargetStorage.Items.Add(armStorageAccount);
}
if (_IsBinding)
{
if (_TargetDisk.TargetStorage != null)
{
if (_TargetDisk.TargetStorage.GetType() == typeof(Azure.Arm.StorageAccount))
{
for (int i = 0; i < cmbTargetStorage.Items.Count; i++)
{
if (cmbTargetStorage.Items[i].GetType() == typeof(Azure.Arm.StorageAccount))
{
Azure.Arm.StorageAccount cmbStorageAccount = (Azure.Arm.StorageAccount)cmbTargetStorage.Items[i];
if (cmbStorageAccount.ToString() == _TargetDisk.TargetStorage.ToString())
{
cmbTargetStorage.SelectedIndex = i;
break;
}
}
}
}
}
}
_TargetTreeView.TransitionToClassicDisk(_TargetDisk);
if (!_IsBinding)
{
PropertyChanged?.Invoke();
}
}
}
public void Bind(AzureContext azureContext, TreeNode sourceStorageAccountNode)
{
_AzureContext = azureContext;
txtTargetName.MaxLength = 24 - azureContext.SettingsProvider.StorageAccountSuffix.Length;
_ArmStorageAccountNode = sourceStorageAccountNode;
TreeNode storageAccountNode = (TreeNode)_ArmStorageAccountNode.Tag;
if (storageAccountNode.Tag.GetType() == typeof(Azure.Asm.StorageAccount))
{
StorageAccount asmStorageAccount = (StorageAccount)storageAccountNode.Tag;
lblAccountType.Text = asmStorageAccount.AccountType;
lblSourceASMName.Text = asmStorageAccount.Name;
if (asmStorageAccount.TargetName != null)
{
if (asmStorageAccount.TargetName.Length > txtTargetName.MaxLength)
{
txtTargetName.Text = asmStorageAccount.TargetName.Substring(0, txtTargetName.MaxLength);
}
else
{
txtTargetName.Text = asmStorageAccount.TargetName;
}
}
}
else if (storageAccountNode.Tag.GetType() == typeof(Azure.Arm.StorageAccount))
{
Azure.Arm.StorageAccount armStorageAccount = (Azure.Arm.StorageAccount)storageAccountNode.Tag;
lblAccountType.Text = armStorageAccount.AccountType;
lblSourceASMName.Text = armStorageAccount.Name;
if (armStorageAccount.TargetName != null)
{
if (armStorageAccount.TargetName.Length > txtTargetName.MaxLength)
{
txtTargetName.Text = armStorageAccount.TargetName.Substring(0, txtTargetName.MaxLength);
}
else
{
txtTargetName.Text = armStorageAccount.TargetName;
}
}
}
}
private async void rbExistingARMStorageAccount_CheckedChanged(object sender, EventArgs e)
{
RadioButton rbSender = (RadioButton)sender;
if (rbSender.Checked)
{
cmbTargetStorage.Items.Clear();
cmbTargetStorage.Enabled = true;
foreach (Azure.Arm.StorageAccount armStorageAccount in await _AsmToArmForm.AzureContextTargetARM.AzureRetriever.GetAzureARMStorageAccounts())
{
cmbTargetStorage.Items.Add(armStorageAccount);
}
if ((_AsmDataDisk.TargetStorageAccount == null) || (_AsmDataDisk.TargetStorageAccount.GetType() == typeof(Azure.Asm.StorageAccount)))
{
}
else
{
for (int i = 0; i < cmbTargetStorage.Items.Count; i++)
{
Azure.Arm.StorageAccount cmbStorageAccount = (Azure.Arm.StorageAccount)cmbTargetStorage.Items[i];
if (cmbStorageAccount.Id == _AsmDataDisk.TargetStorageAccount.Id)
{
cmbTargetStorage.SelectedIndex = i;
break;
}
}
// Using a for loop above, because this was always selecting Index 0, even when matched on a higher ( > 0) indexed item
//foreach (Azure.Arm.StorageAccount armStorageAccount in cmbTargetStorage.Items)
//{
// if (armStorageAccount.Id == _AsmDataDisk.TargetStorageAccount.Id)
// cmbTargetStorage.SelectedIndex = cmbTargetStorage.Items.IndexOf(armStorageAccount);
//}
}
}
_AsmToArmForm.AzureContextTargetARM.StatusProvider.UpdateStatus("Ready");
}
private void txtTargetName_TextChanged(object sender, EventArgs e)
{
TextBox txtSender = (TextBox)sender;
TreeNode asmStorageAccountNode = (TreeNode)_ArmStorageAccountNode.Tag;
if (asmStorageAccountNode.Tag.GetType() == typeof(Azure.Asm.StorageAccount))
{
Azure.Asm.StorageAccount asmStorageAccount = (Azure.Asm.StorageAccount)asmStorageAccountNode.Tag;
asmStorageAccount.TargetName = txtSender.Text;
_ArmStorageAccountNode.Text = asmStorageAccount.GetFinalTargetName();
}
else if (asmStorageAccountNode.Tag.GetType() == typeof(Azure.Arm.StorageAccount))
{
Azure.Arm.StorageAccount armStorageAccount = (Azure.Arm.StorageAccount)asmStorageAccountNode.Tag;
armStorageAccount.TargetName = txtSender.Text;
_ArmStorageAccountNode.Text = armStorageAccount.GetFinalTargetName();
}
PropertyChanged();
}
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);
}
}
