public void Error(Exception ex) { messages_.Add(new ErrorInfo { ErrorMessage = ex.Message, ErrorDetails = ex.StackTrace, Source = ex.Source }); // Does the user want to see a message? if (!CoreSettings.Value.DontShowErrors) { DialogResult res = DialogResult.None; try { var dlg = new UnhandledExceptionDialog(); // Call ToString() to get the call stack. The Message property may not include that. dlg.ExceptionTextBox.Text = ex.ToString(); res = dlg.ShowDialog(); } finally { if (res == DialogResult.No) { MainWindow.inst().Terminate(); // Terminating from the main window gives termination a chance to do its work } } } }
private void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e) { Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback) delegate { UnhandledExceptionDialog.ShowModalDialog((Exception)e.ExceptionObject, AssemblyHelper.Version, AssemblyHelper.InstallationType.ToString(), AssemblyHelper.BuildType.ToString(), AssemblyHelper.ProductName); }, null); }
/// <summary> /// Shows the exception dialog that allows the user to choose whether or not to continue. /// If the user chooses not to continue, Environment.Exit(1) is called.</summary> /// <param name="exception">Exception raised</param> protected override void ShowExceptionDialog(Exception exception) { bool?result = null; try { var dlg = new UnhandledExceptionDialog(); // Call ToString() to get the call stack. The Message property may not include that. dlg.DataContext = new UnhandledExceptionViewModel(exception.ToString()); dlg.Owner = Application.Current.MainWindow; result = dlg.ShowDialog(); if (UserFeedbackService != null) { UserFeedbackService.ShowFeedbackForm(); } } finally { if (result.HasValue && !result.Value) { Environment.Exit(1); } } }
public MainClass(string [] args) { isFirstRun = false; CheckDataFolders(); BuildNlogConfig(); logger.Info("Starting MonoTorrent"); SetProcessName("monotorrent"); userEngineSettings = new UserEngineSettings(); portController = new ListenPortController(userEngineSettings); Application.Init (); Console.Out.WriteLine("IS FIRST RUN?!?! " + isFirstRun); mainWindow = new MainWindow (userEngineSettings, portController, isFirstRun); // This is so we can use IconEntry button // Use Gnome.Program instead of Gtk.Application? //Gnome.Program program = new Gnome.Program("monotorrent", "0.1", Gnome.Modules.UI, args); try{ Application.Run(); } catch(Exception e){ Console.Out.WriteLine(e.ToString()); Application.Init(); UnhandledExceptionDialog exDialog = new UnhandledExceptionDialog(e); exDialog.Run(); mainWindow.Stop(); exDialog.Destroy(); } portController.Stop(); }
static void applicationThreadException(object sender, System.Threading.ThreadExceptionEventArgs e) { if (PlvsUtils.isConnectorException(e.Exception)) { UnhandledExceptionDialog dlg = new UnhandledExceptionDialog(e.Exception); dlg.ShowDialog(); } }
static void HandleUnhandledException(Exception e, string source) { Log.Fatal("Unhandled exception", e); File.WriteAllText("error.log", $"Sentry GUID: {GlobalSettings.Instance.Guid}\nSource: {source}\nMessage: {e.Message}\n\nStack:\n{e.StackTrace}"); var dlg = new UnhandledExceptionDialog(e); dlg.ShowDialog(); Application.Exit(); }
private static void unhandledExceptionHandler(object sender, UnhandledExceptionEventArgs e) { Exception ex = (Exception)e.ExceptionObject; if (PlvsUtils.isConnectorException(ex)) { UnhandledExceptionDialog dlg = new UnhandledExceptionDialog(ex); dlg.ShowDialog(); } }
protected virtual bool?ShowExceptionDialog(Exception exception) { var dlg = new UnhandledExceptionDialog(); dlg.DataContext = new UnhandledExceptionViewModel(exception.Message); if (Application.Current.MainWindow.IsVisible) { dlg.Owner = Application.Current.MainWindow; } return(dlg.ShowDialog()); }
public async Task ShowPrintUIAsync() { // Catch and print out any errors reported try { await PrintManager.ShowPrintUIAsync(); } catch (Exception e) { UnhandledExceptionDialog.Show(e); } }
public App() { #if !DEBUG AppDomain.CurrentDomain.UnhandledException += (sender, args) => { UnhandledExceptionDialog dialog = new UnhandledExceptionDialog(args); dialog.ShowDialog(); }; #endif SetupJitCache(); StartBackgroundInitialization(); }
private async Task _AzureContext_AfterAzureSubscriptionChange(AzureContext sender) { try { ResetForm(); if (sender.AzureSubscription != null) { switch (cmbAzureResourceTypeSource.SelectedItem.ToString()) { case "Azure Service Management (ASM / Classic)": await BindAsmResources(sender, _TargetSettings); break; case "Azure Resource Manager (ARM)": treeViewSourceResourceManager1.Enabled = true; treeViewSourceResourceManager1.Visible = true; await sender.AzureSubscription.InitializeChildrenAsync(); await sender.AzureSubscription.BindArmResources(_TargetSettings); await treeViewSourceResourceManager1.BindArmResources(sender, sender.AzureSubscription, _TargetSettings); break; default: throw new ArgumentException("Unexpected Source Resource Tab: " + cmbAzureResourceTypeSource.SelectedValue); } _AzureContextSource.AzureRetriever.SaveRestCache(); } } catch (Exception exc) { UnhandledExceptionDialog unhandledException = new UnhandledExceptionDialog(_AzureContextSource.LogProvider, exc); unhandledException.ShowDialog(); } _AzureContextSource.StatusProvider.UpdateStatus("Ready"); AfterAzureSubscriptionChange?.Invoke(sender); }
public App() { #if !DEBUG AppDomain.CurrentDomain.UnhandledException += (sender, args) => { UnhandledExceptionDialog dialog = new UnhandledExceptionDialog(args); dialog.ShowDialog(); }; #endif SetupJitCache(); StartBackgroundInitialization(); SetupAggregateCatalogs(); // initialize preferences if (Preferences.Instance != null) { Logging.Logger.Log(LogLevel.Error, "Failed to load preferences"); } }
public static System.Threading.Thread createThread(ThreadStart threadStart) { ThreadStart ts = delegate { try { threadStart.Invoke(); } catch (Exception e) { if (isConnectorException(e)) { UnhandledExceptionDialog dlg = new UnhandledExceptionDialog(e); dlg.ShowDialog(); } else { throw; } } }; System.Threading.Thread t = new System.Threading.Thread(ts); return(t); }
private void OnUnhandledException(object sender, ApplicationUnhandledExceptionEventArgs e) { if (e.ExceptionObject is NodeNotFoundException) { ((MainPage)RootVisual).Loader.Visibility = Visibility.Collapsed; SuperMessageBoxService.Show( "Load Map Failed", "Sorry, unfortunately we can’t find the map you’re looking for", "Select a new map", "Cancel", MessageBoxType.Error, () => ((MainPage)RootVisual).HomeScreen() ); } else if (e.ExceptionObject.InnerException != null) { if (e.ExceptionObject.InnerException is TimeoutException) { ((MainPage)RootVisual).Loader.Visibility = Visibility.Collapsed; SuperMessageBoxService.Show( "Communication Failed", "Unfortunately it seems your internet connection is not working", "Refresh", "Cancel", MessageBoxType.Error, () => HtmlPage.Document.Submit() ); } } else { var unhandledExceptionDialog = new UnhandledExceptionDialog(); unhandledExceptionDialog.UnhandledException = e.ExceptionObject; unhandledExceptionDialog.Show(); } }
private void SynchronizationContext_UnhandledException(object sender, UnhandledExceptionEventArgs e) { e.Handled = true; UnhandledExceptionDialog.Show(e.Exception); }
private void Application_ThreadException(object sender, ThreadExceptionEventArgs e) { UnhandledExceptionDialog.ShowModalDialog(e.Exception, AssemblyHelper.Version, AssemblyHelper.InstallationType.ToString(), AssemblyHelper.BuildType.ToString(), AssemblyHelper.ProductName); }
private void OnUnhandledException(object sender, Windows.UI.Xaml.UnhandledExceptionEventArgs e) { e.Handled = true; UnhandledExceptionDialog.Show(e.Exception); }
private async Task _AzureContextSourceASM_AfterAzureSubscriptionChange(AzureContext sender) { ResetForm(); try { if (sender.AzureSubscription != null) { if (_AzureContextTargetARM.AzureSubscription == null) { await _AzureContextTargetARM.SetSubscriptionContext(_AzureContextSourceASM.AzureSubscription); } azureLoginContextViewerARM.Enabled = true; this.TemplateGenerator.SourceSubscription = _AzureContextSourceASM.AzureSubscription; this.TemplateGenerator.TargetSubscription = _AzureContextTargetARM.AzureSubscription; #region Bind Source ASM Objects TreeNode subscriptionNodeASM = new TreeNode(sender.AzureSubscription.Name); treeSourceASM.Nodes.Add(subscriptionNodeASM); subscriptionNodeASM.Expand(); List <Azure.Asm.VirtualNetwork> asmVirtualNetworks = await _AzureContextSourceASM.AzureRetriever.GetAzureAsmVirtualNetworks(); foreach (Azure.Asm.VirtualNetwork asmVirtualNetwork in asmVirtualNetworks) { if (asmVirtualNetwork.HasNonGatewaySubnet) { TreeNode parentNode = MigAzTreeView.GetDataCenterTreeViewNode(subscriptionNodeASM, asmVirtualNetwork.Location, "Virtual Networks"); TreeNode tnVirtualNetwork = new TreeNode(asmVirtualNetwork.Name); tnVirtualNetwork.Name = asmVirtualNetwork.Name; tnVirtualNetwork.Tag = asmVirtualNetwork; parentNode.Nodes.Add(tnVirtualNetwork); parentNode.Expand(); } } foreach (Azure.Asm.StorageAccount asmStorageAccount in await _AzureContextSourceASM.AzureRetriever.GetAzureAsmStorageAccounts()) { TreeNode parentNode = MigAzTreeView.GetDataCenterTreeViewNode(subscriptionNodeASM, asmStorageAccount.GeoPrimaryRegion, "Storage Accounts"); TreeNode tnStorageAccount = new TreeNode(asmStorageAccount.Name); tnStorageAccount.Name = tnStorageAccount.Text; tnStorageAccount.Tag = asmStorageAccount; parentNode.Nodes.Add(tnStorageAccount); parentNode.Expand(); } List <CloudService> asmCloudServices = await _AzureContextSourceASM.AzureRetriever.GetAzureAsmCloudServices(); foreach (CloudService asmCloudService in asmCloudServices) { foreach (Azure.Asm.VirtualMachine asmVirtualMachine in asmCloudService.VirtualMachines) { TreeNode parentNode = MigAzTreeView.GetDataCenterTreeViewNode(subscriptionNodeASM, asmCloudService.Location, "Cloud Services"); TreeNode[] cloudServiceNodeSearch = parentNode.Nodes.Find(asmCloudService.ServiceName, false); TreeNode cloudServiceNode = null; if (cloudServiceNodeSearch.Count() == 1) { cloudServiceNode = cloudServiceNodeSearch[0]; } if (cloudServiceNode == null) { cloudServiceNode = new TreeNode(asmCloudService.ServiceName); cloudServiceNode.Name = asmCloudService.ServiceName; cloudServiceNode.Tag = asmCloudService; parentNode.Nodes.Add(cloudServiceNode); parentNode.Expand(); } TreeNode virtualMachineNode = new TreeNode(asmVirtualMachine.RoleName); virtualMachineNode.Name = asmVirtualMachine.RoleName; virtualMachineNode.Tag = asmVirtualMachine; cloudServiceNode.Nodes.Add(virtualMachineNode); cloudServiceNode.Expand(); } } foreach (Azure.Asm.NetworkSecurityGroup asmNetworkSecurityGroup in await _AzureContextSourceASM.AzureRetriever.GetAzureAsmNetworkSecurityGroups()) { TreeNode parentNode = MigAzTreeView.GetDataCenterTreeViewNode(subscriptionNodeASM, asmNetworkSecurityGroup.Location, "Network Security Groups"); TreeNode tnStorageAccount = new TreeNode(asmNetworkSecurityGroup.Name); tnStorageAccount.Name = tnStorageAccount.Text; tnStorageAccount.Tag = asmNetworkSecurityGroup; parentNode.Nodes.Add(tnStorageAccount); parentNode.Expand(); } subscriptionNodeASM.ExpandAll(); #endregion #region Bind Source ARM Objects TreeNode subscriptionNodeARM = new TreeNode("ARM Resources Coming Soon!!"); // TreeNode subscriptionNodeARM = new TreeNode(sender.AzureSubscription.Name); treeSourceARM.Nodes.Add(subscriptionNodeARM); subscriptionNodeARM.Expand(); //foreach (ResourceGroup armResourceGroup in await _AzureContextSourceASM.AzureRetriever.GetAzureARMResourceGroups()) //{ //} //foreach (Azure.Arm.AvailabilitySet armAvailabilitySet in await _AzureContextSourceASM.AzureRetriever.GetAzureARMAvailabilitySets()) //{ //} //List<Azure.Arm.VirtualNetwork> armVirtualNetworks = await _AzureContextSourceASM.AzureRetriever.GetAzureARMVirtualNetworks(); //foreach (Azure.Arm.VirtualNetwork armVirtualNetwork in armVirtualNetworks) //{ // if (armVirtualNetwork.HasNonGatewaySubnet) // { // TreeNode parentNode = MigAzTreeView.GetDataCenterTreeViewNode(subscriptionNodeARM, armVirtualNetwork.Location, "Virtual Networks"); // TreeNode tnVirtualNetwork = new TreeNode(armVirtualNetwork.Name); // tnVirtualNetwork.Name = armVirtualNetwork.Name; // tnVirtualNetwork.Tag = armVirtualNetwork; // parentNode.Nodes.Add(tnVirtualNetwork); // parentNode.Expand(); // } //} //foreach (Azure.Arm.StorageAccount armStorageAccount in await _AzureContextSourceASM.AzureRetriever.GetAzureARMStorageAccounts()) //{ // TreeNode parentNode = MigAzTreeView.GetDataCenterTreeViewNode(subscriptionNodeARM, armStorageAccount.PrimaryLocation, "Storage Accounts"); // TreeNode tnStorageAccount = new TreeNode(armStorageAccount.Name); // tnStorageAccount.Name = tnStorageAccount.Text; // tnStorageAccount.Tag = armStorageAccount; // parentNode.Nodes.Add(tnStorageAccount); // parentNode.Expand(); //} //foreach (Azure.Arm.VirtualMachine armVirtualMachine in await _AzureContextSourceASM.AzureRetriever.GetAzureArmVirtualMachines()) //{ // TreeNode parentNode = MigAzTreeView.GetDataCenterTreeViewNode(subscriptionNodeARM, armVirtualMachine.Location, "Virtual Machines"); // TreeNode tnVirtualMachine = new TreeNode(armVirtualMachine.Name); // tnVirtualMachine.Name = tnVirtualMachine.Text; // tnVirtualMachine.Tag = armVirtualMachine; // parentNode.Nodes.Add(tnVirtualMachine); // parentNode.Expand(); //} subscriptionNodeARM.ExpandAll(); #endregion await ReadSubscriptionSettings(sender.AzureSubscription); treeSourceASM.Enabled = true; //treeSourceARM.Enabled = true; treeTargetARM.Enabled = true; } } catch (Exception exc) { UnhandledExceptionDialog unhandledException = new UnhandledExceptionDialog(LogProvider, exc); unhandledException.ShowDialog(); } StatusProvider.UpdateStatus("Ready"); }
public async Task BindArmResources(AzureContext azureContext, AzureSubscription azureSubscription, TargetSettings targetSettings) { treeAzureARM.Nodes.Clear(); try { if (azureSubscription != null) { await azureSubscription.BindArmResources(targetSettings); if (azureSubscription != null) { TreeNode subscriptionNodeARM = new TreeNode(azureSubscription.Name); subscriptionNodeARM.ImageKey = "Subscription"; subscriptionNodeARM.SelectedImageKey = "Subscription"; treeAzureARM.Nodes.Add(subscriptionNodeARM); subscriptionNodeARM.Expand(); foreach (MigrationTarget.NetworkSecurityGroup targetNetworkSecurityGroup in azureSubscription.ArmTargetNetworkSecurityGroups) { TreeNode networkSecurityGroupParentNode = GetResourceGroupTreeNode(subscriptionNodeARM, ((Azure.Arm.NetworkSecurityGroup)targetNetworkSecurityGroup.SourceNetworkSecurityGroup).ResourceGroup); TreeNode tnNetworkSecurityGroup = new TreeNode(targetNetworkSecurityGroup.SourceName); tnNetworkSecurityGroup.Name = targetNetworkSecurityGroup.SourceName; tnNetworkSecurityGroup.Tag = targetNetworkSecurityGroup; tnNetworkSecurityGroup.ImageKey = targetNetworkSecurityGroup.ImageKey; tnNetworkSecurityGroup.SelectedImageKey = targetNetworkSecurityGroup.ImageKey; networkSecurityGroupParentNode.Nodes.Add(tnNetworkSecurityGroup); } foreach (MigrationTarget.PublicIp targetPublicIP in azureSubscription.ArmTargetPublicIPs) { TreeNode publicIpParentNode = GetResourceGroupTreeNode(subscriptionNodeARM, ((Azure.Arm.PublicIP)targetPublicIP.Source).ResourceGroup);; TreeNode tnPublicIP = new TreeNode(targetPublicIP.SourceName); tnPublicIP.Name = targetPublicIP.SourceName; tnPublicIP.Tag = targetPublicIP; tnPublicIP.ImageKey = targetPublicIP.ImageKey; tnPublicIP.SelectedImageKey = targetPublicIP.ImageKey; publicIpParentNode.Nodes.Add(tnPublicIP); } foreach (MigrationTarget.RouteTable targetRouteTable in azureSubscription.ArmTargetRouteTables) { TreeNode routeTableParentNode = GetResourceGroupTreeNode(subscriptionNodeARM, ((Azure.Arm.RouteTable)targetRouteTable.Source).ResourceGroup); TreeNode tnRouteTable = new TreeNode(targetRouteTable.SourceName); tnRouteTable.Name = targetRouteTable.SourceName; tnRouteTable.Tag = targetRouteTable; tnRouteTable.ImageKey = targetRouteTable.ImageKey; tnRouteTable.SelectedImageKey = targetRouteTable.ImageKey; routeTableParentNode.Nodes.Add(tnRouteTable); } foreach (MigrationTarget.VirtualNetwork targetVirtualNetwork in azureSubscription.ArmTargetVirtualNetworks) { TreeNode virtualNetworkParentNode = GetResourceGroupTreeNode(subscriptionNodeARM, ((Azure.Arm.VirtualNetwork)targetVirtualNetwork.SourceVirtualNetwork).ResourceGroup); TreeNode tnVirtualNetwork = new TreeNode(targetVirtualNetwork.SourceName); tnVirtualNetwork.Name = targetVirtualNetwork.SourceName; tnVirtualNetwork.Tag = targetVirtualNetwork; tnVirtualNetwork.ImageKey = targetVirtualNetwork.ImageKey; tnVirtualNetwork.SelectedImageKey = targetVirtualNetwork.ImageKey; virtualNetworkParentNode.Nodes.Add(tnVirtualNetwork); } foreach (MigrationTarget.VirtualNetworkGateway targetVirtualNetworkGateway in azureSubscription.ArmTargetVirtualNetworkGateways) { TreeNode virtualNetworkGatewayParentNode = GetResourceGroupTreeNode(subscriptionNodeARM, ((Azure.Arm.VirtualNetworkGateway)targetVirtualNetworkGateway.SourceVirtualNetworkGateway).ResourceGroup); TreeNode tnVirtualNetworkGateway = new TreeNode(targetVirtualNetworkGateway.SourceName); tnVirtualNetworkGateway.Name = targetVirtualNetworkGateway.SourceName; tnVirtualNetworkGateway.Tag = targetVirtualNetworkGateway; tnVirtualNetworkGateway.ImageKey = targetVirtualNetworkGateway.ImageKey; tnVirtualNetworkGateway.SelectedImageKey = targetVirtualNetworkGateway.ImageKey; virtualNetworkGatewayParentNode.Nodes.Add(tnVirtualNetworkGateway); } foreach (MigrationTarget.LocalNetworkGateway targetLocalNetworkGateway in azureSubscription.ArmTargetLocalNetworkGateways) { TreeNode localNetworkGatewayParentNode = GetResourceGroupTreeNode(subscriptionNodeARM, ((Azure.Arm.LocalNetworkGateway)targetLocalNetworkGateway.SourceLocalNetworkGateway).ResourceGroup); TreeNode tnLocalNetworkGateway = new TreeNode(targetLocalNetworkGateway.SourceName); tnLocalNetworkGateway.Name = targetLocalNetworkGateway.SourceName; tnLocalNetworkGateway.Tag = targetLocalNetworkGateway; tnLocalNetworkGateway.ImageKey = targetLocalNetworkGateway.ImageKey; tnLocalNetworkGateway.SelectedImageKey = targetLocalNetworkGateway.ImageKey; localNetworkGatewayParentNode.Nodes.Add(tnLocalNetworkGateway); } foreach (MigrationTarget.VirtualNetworkGatewayConnection targetConnection in azureSubscription.ArmTargetConnections) { TreeNode connectionParentNode = GetResourceGroupTreeNode(subscriptionNodeARM, ((Azure.Arm.VirtualNetworkGatewayConnection)targetConnection.SourceConnection).ResourceGroup); TreeNode tnConnection = new TreeNode(targetConnection.SourceName); tnConnection.Name = targetConnection.SourceName; tnConnection.Tag = targetConnection; tnConnection.ImageKey = targetConnection.ImageKey; tnConnection.SelectedImageKey = targetConnection.ImageKey; connectionParentNode.Nodes.Add(tnConnection); } foreach (MigrationTarget.StorageAccount targetStorageAccount in azureSubscription.ArmTargetStorageAccounts) { TreeNode storageAccountParentNode = GetResourceGroupTreeNode(subscriptionNodeARM, ((Azure.Arm.StorageAccount)targetStorageAccount.SourceAccount).ResourceGroup); TreeNode tnStorageAccount = new TreeNode(targetStorageAccount.SourceName); tnStorageAccount.Name = targetStorageAccount.SourceName; tnStorageAccount.Tag = targetStorageAccount; tnStorageAccount.ImageKey = targetStorageAccount.ImageKey; tnStorageAccount.SelectedImageKey = targetStorageAccount.ImageKey; storageAccountParentNode.Nodes.Add(tnStorageAccount); } foreach (MigrationTarget.Disk targetManagedDisk in azureSubscription.ArmTargetManagedDisks) { Azure.Arm.ManagedDisk armManagedDisk = (Azure.Arm.ManagedDisk)targetManagedDisk.SourceDisk; TreeNode managedDiskParentNode = GetResourceGroupTreeNode(subscriptionNodeARM, armManagedDisk.ResourceGroup); TreeNode tnDisk = new TreeNode(targetManagedDisk.SourceName); tnDisk.Name = targetManagedDisk.SourceName; tnDisk.Tag = targetManagedDisk; tnDisk.ImageKey = targetManagedDisk.ImageKey; tnDisk.SelectedImageKey = targetManagedDisk.ImageKey; managedDiskParentNode.Nodes.Add(tnDisk); } foreach (MigrationTarget.AvailabilitySet targetAvailabilitySet in azureSubscription.ArmTargetAvailabilitySets) { TreeNode availabilitySetParentNode = GetResourceGroupTreeNode(subscriptionNodeARM, ((Azure.Arm.AvailabilitySet)targetAvailabilitySet.SourceAvailabilitySet).ResourceGroup); TreeNode tnAvailabilitySet = new TreeNode(targetAvailabilitySet.SourceName); tnAvailabilitySet.Name = targetAvailabilitySet.SourceName; tnAvailabilitySet.Tag = targetAvailabilitySet; tnAvailabilitySet.ImageKey = targetAvailabilitySet.ImageKey; tnAvailabilitySet.SelectedImageKey = targetAvailabilitySet.ImageKey; availabilitySetParentNode.Nodes.Add(tnAvailabilitySet); } foreach (MigrationTarget.NetworkInterface targetNetworkInterface in azureSubscription.ArmTargetNetworkInterfaces) { TreeNode tnResourceGroup = GetResourceGroupTreeNode(subscriptionNodeARM, ((Azure.Arm.NetworkInterface)targetNetworkInterface.SourceNetworkInterface).ResourceGroup); TreeNode txNetworkInterface = new TreeNode(targetNetworkInterface.SourceName); txNetworkInterface.Name = targetNetworkInterface.SourceName; txNetworkInterface.Tag = targetNetworkInterface; txNetworkInterface.ImageKey = targetNetworkInterface.ImageKey; txNetworkInterface.SelectedImageKey = targetNetworkInterface.ImageKey; tnResourceGroup.Nodes.Add(txNetworkInterface); } foreach (MigrationTarget.VirtualMachine targetVirtualMachine in azureSubscription.ArmTargetVirtualMachines) { TreeNode tnResourceGroup = GetResourceGroupTreeNode(subscriptionNodeARM, ((Azure.Arm.VirtualMachine)targetVirtualMachine.Source).ResourceGroup); TreeNode tnVirtualMachine = new TreeNode(targetVirtualMachine.SourceName); tnVirtualMachine.Name = targetVirtualMachine.SourceName; tnVirtualMachine.Tag = targetVirtualMachine; tnVirtualMachine.ImageKey = targetVirtualMachine.ImageKey; tnVirtualMachine.SelectedImageKey = targetVirtualMachine.ImageKey; tnResourceGroup.Nodes.Add(tnVirtualMachine); } foreach (MigrationTarget.LoadBalancer targetLoadBalancer in azureSubscription.ArmTargetLoadBalancers) { TreeNode networkSecurityGroupParentNode = GetResourceGroupTreeNode(subscriptionNodeARM, ((Azure.Arm.LoadBalancer)targetLoadBalancer.Source).ResourceGroup); TreeNode tnNetworkSecurityGroup = new TreeNode(targetLoadBalancer.SourceName); tnNetworkSecurityGroup.Name = targetLoadBalancer.SourceName; tnNetworkSecurityGroup.Tag = targetLoadBalancer; tnNetworkSecurityGroup.ImageKey = targetLoadBalancer.ImageKey; tnNetworkSecurityGroup.SelectedImageKey = targetLoadBalancer.ImageKey; networkSecurityGroupParentNode.Nodes.Add(tnNetworkSecurityGroup); } //foreach (MigrationTarget.VirtualMachineImage targetVirtualMachineImage in _AzureContextSource.AzureSubscription.ArmTargetVirtualMachineImages) //{ // TreeNode virtualMachineImageParentNode = GetResourceGroupTreeNode(subscriptionNodeARM, ((Azure.Arm.VirtualMachineImage)targetVirtualMachineImage.Source).ResourceGroup); // TreeNode tnVirtualMachineImage = new TreeNode(targetVirtualMachineImage.SourceName); // tnVirtualMachineImage.Name = targetVirtualMachineImage.SourceName; // tnVirtualMachineImage.Tag = targetVirtualMachineImage; // tnVirtualMachineImage.ImageKey = "VirtualMachineImage"; // tnVirtualMachineImage.SelectedImageKey = "VirtualMachineImage"; // virtualMachineImageParentNode.Nodes.Add(tnVirtualMachineImage); //} subscriptionNodeARM.Expand(); treeAzureARM.Sort(); treeAzureARM.Enabled = true; } } } catch (Exception exc) { UnhandledExceptionDialog exceptionDialog = new UnhandledExceptionDialog(_LogProvider, exc); exceptionDialog.ShowDialog(); } _StatusProvider.UpdateStatus("Ready"); }
private static void Application_ThreadException(object sender, System.Threading.ThreadExceptionEventArgs e) { UnhandledExceptionDialog exceptionDialog = new UnhandledExceptionDialog(programForm.LogProvider, e.Exception); exceptionDialog.ShowDialog(); }
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"); }