mirror of
https://github.com/xcp-ng/xenadmin.git
synced 2024-11-23 12:30:50 +01:00
742 lines
29 KiB
C#
742 lines
29 KiB
C#
/* Copyright (c) Cloud Software Group, Inc.
|
|
*
|
|
* Redistribution and use in source and binary forms,
|
|
* with or without modification, are permitted provided
|
|
* that the following conditions are met:
|
|
*
|
|
* * Redistributions of source code must retain the above
|
|
* copyright notice, this list of conditions and the
|
|
* following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above
|
|
* copyright notice, this list of conditions and the
|
|
* following disclaimer in the documentation and/or other
|
|
* materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
|
|
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
|
|
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
using System;
|
|
using System.ComponentModel;
|
|
using System.Diagnostics;
|
|
using System.Drawing;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Reflection;
|
|
using System.Runtime.InteropServices;
|
|
using System.Threading;
|
|
using System.Windows.Forms;
|
|
using XenAdmin.Core;
|
|
using XenAdmin.Dialogs;
|
|
using XenAdmin.Network;
|
|
using XenAPI;
|
|
using XenCenterLib;
|
|
|
|
|
|
namespace XenAdmin
|
|
{
|
|
public static class Program
|
|
{
|
|
/// <summary>
|
|
/// A UUID for the current instance of XenCenter. Used to identify our own task instances.
|
|
/// </summary>
|
|
public static readonly string XenCenterUUID = Guid.NewGuid().ToString();
|
|
|
|
private static NamedPipes.Pipe _pipe;
|
|
private static string _pipePath;
|
|
private const string PIPE_PATH_PATTERN = @"\\.\pipe\{0}-{1}-{2}-{3}";
|
|
|
|
public static Font DefaultFont = FormFontFixer.DefaultFont;
|
|
public static Font DefaultFontBold;
|
|
public static Font DefaultFontUnderline;
|
|
public static Font DefaultFontItalic;
|
|
public static Font DefaultFontHeader;
|
|
|
|
public static MainWindow MainWindow;
|
|
|
|
public static CollectionChangeEventHandler ProgramInvokeHandler(CollectionChangeEventHandler handler)
|
|
{
|
|
return delegate (object s, CollectionChangeEventArgs args)
|
|
{
|
|
if (MainWindow != null)
|
|
{
|
|
BeginInvoke(MainWindow, delegate
|
|
{
|
|
if (handler != null)
|
|
handler(s, args);
|
|
});
|
|
}
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// The secure hash of the main password used to load the client session.
|
|
/// If this is null then no prior session existed and the user should be prompted
|
|
/// to save his session when the UI is quit.
|
|
/// </summary>
|
|
public static byte[] MainPassword = null;
|
|
|
|
/// <summary>
|
|
/// A true value here indicates the user does not want to save session information for this
|
|
/// particular instance of the UI; but when the UI is restarted he should be prompted again.
|
|
/// </summary>
|
|
public static bool SkipSessionSave = false;
|
|
|
|
public static bool RunInAutomatedTestMode = false;
|
|
public static string TestExceptionString; // an exception passed back to the test framework
|
|
private static readonly log4net.ILog log;
|
|
|
|
public static volatile bool Exiting;
|
|
|
|
public static readonly string AssemblyDir;
|
|
public static readonly Version Version;
|
|
public static readonly string VersionText;
|
|
|
|
private static readonly System.Threading.Timer dailyTimer;
|
|
|
|
static Program()
|
|
{
|
|
XenAdminConfigManager.Provider = new WinformsXenAdminConfigProvider();
|
|
// Start timer to record resource usage every 24hrs
|
|
dailyTimer = new System.Threading.Timer(delegate
|
|
{
|
|
LogApplicationStats();
|
|
}, null, new TimeSpan(24, 0, 0), new TimeSpan(24, 0, 0));
|
|
|
|
var assembly = Assembly.GetExecutingAssembly();
|
|
AssemblyDir = Path.GetDirectoryName(assembly.Location);
|
|
Version = assembly.GetName().Version;
|
|
|
|
VersionText = Version.Major == 0 && Version.Minor == 0 && Version.Build == 0
|
|
? "vNext"
|
|
: $"{Version.Major}.{Version.Minor}.{Version.Build}";
|
|
|
|
var logFolder = Path.Combine(
|
|
Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
|
|
BrandManager.ProductBrand,
|
|
BrandManager.BrandConsole,
|
|
"logs");
|
|
|
|
log4net.GlobalContext.Properties["LOG_FILE"] = Path.Combine(logFolder, $"{BrandManager.BrandConsole}.log");
|
|
log4net.GlobalContext.Properties["AUDIT_TRAIL"] = Path.Combine(logFolder, $"{BrandManager.BrandConsole}-AuditTrail.log");
|
|
log4net.GlobalContext.Properties["NETWORK_TRACE"] = Path.Combine(logFolder, $"{BrandManager.BrandConsole}-NetworkTrace.log");
|
|
|
|
log4net.Config.XmlConfigurator.ConfigureAndWatch(new FileInfo(Assembly.GetCallingAssembly().Location + ".config"));
|
|
log = log4net.LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
|
|
|
|
SetDefaultFonts();
|
|
}
|
|
|
|
/// <summary>
|
|
/// The main entry point for the application.
|
|
/// </summary>
|
|
[STAThread]
|
|
public static void Main(string[] args)
|
|
{
|
|
_pipePath = string.Format(PIPE_PATH_PATTERN,
|
|
BrandManager.BrandConsole,
|
|
Process.GetCurrentProcess().SessionId,
|
|
Environment.UserName,
|
|
Assembly.GetExecutingAssembly().Location.Replace('\\', '-'));
|
|
|
|
if (NamedPipes.Pipe.ExistsPipe(_pipePath))
|
|
{
|
|
NamedPipes.Pipe.SendMessageToPipe(_pipePath, string.Join(" ", args));
|
|
return;
|
|
}
|
|
|
|
log.Info("Application started");
|
|
|
|
AppDomain.CurrentDomain.UnhandledException -= CurrentDomain_UnhandledException;
|
|
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
|
|
Application.ThreadException -= Application_ThreadException;
|
|
Application.ThreadException += Application_ThreadException;
|
|
Application.ApplicationExit -= Application_ApplicationExit;
|
|
Application.ApplicationExit += Application_ApplicationExit;
|
|
|
|
ConnectPipe();
|
|
|
|
// We must NEVER request ProfessionalColors before we have called Application.EnableVisualStyles
|
|
// as it may prevent the program from displayed as expected.
|
|
Application.EnableVisualStyles();
|
|
Application.SetCompatibleTextRenderingDefault(false);
|
|
|
|
// Force the current culture, to make the layout the same whatever the culture of the underlying OS (CA-46983).
|
|
Thread.CurrentThread.CurrentUICulture = Thread.CurrentThread.CurrentCulture = new CultureInfo(InvisibleMessages.LOCALE, false);
|
|
|
|
if (string.IsNullOrEmpty(Thread.CurrentThread.Name))
|
|
Thread.CurrentThread.Name = "Main program thread";
|
|
|
|
ServicePointManager.DefaultConnectionLimit = 20;
|
|
ServicePointManager.ServerCertificateValidationCallback = SSL.ValidateServerCertificate;
|
|
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12;
|
|
Session.UserAgent = $"{BrandManager.BrandConsole} {Version}";
|
|
|
|
LogSystemDetails();
|
|
|
|
Application.Run(new SplashScreenContext(args));
|
|
|
|
log.Info("Application main thread exited" + Environment.NewLine);
|
|
}
|
|
|
|
/// <summary>
|
|
/// If the pipe doesn't already exist, it creates a new one and starts a thread
|
|
/// that listens for incoming data on the pipe (from new invocations of XenCenter)
|
|
/// and deals with the command line arguments of those instances.
|
|
/// </summary>
|
|
private static void ConnectPipe()
|
|
{
|
|
_pipe = new NamedPipes.Pipe(_pipePath);
|
|
|
|
if (_pipe != null)
|
|
{
|
|
_pipe.Read += pipe_Read;
|
|
_pipe.BeginRead();
|
|
}
|
|
}
|
|
|
|
private static void pipe_Read(string message)
|
|
{
|
|
MainWindow m = MainWindow;
|
|
|
|
if (m != null && !RunInAutomatedTestMode)
|
|
{
|
|
Invoke(m, delegate
|
|
{
|
|
m.WindowState = FormWindowState.Normal;
|
|
m.ProcessCommand(message.Split(' ').ToArray());
|
|
});
|
|
}
|
|
}
|
|
|
|
private static void DisconnectPipe()
|
|
{
|
|
if (_pipe != null)
|
|
{
|
|
log.Debug("Disconnecting from named pipe in Program.DisconnectPipe()");
|
|
ThreadPool.QueueUserWorkItem(state => _pipe.EndRead());
|
|
}
|
|
}
|
|
|
|
private static void LogSystemDetails()
|
|
{
|
|
log.InfoFormat("Version: {0}", Version);
|
|
log.InfoFormat(".NET runtime version: {0}", Environment.Version.ToString(4));
|
|
log.InfoFormat("OS version: {0}", Environment.OSVersion);
|
|
log.InfoFormat("UI Culture: {0}", Thread.CurrentThread.CurrentUICulture.EnglishName);
|
|
log.InfoFormat("Bitness: {0}-bit", IntPtr.Size * 8);
|
|
}
|
|
|
|
private static void LogApplicationStats()
|
|
{
|
|
Process p = Process.GetCurrentProcess();
|
|
|
|
log.Info("Log Application State");
|
|
log.InfoFormat("ExitCode: {0}", Environment.ExitCode);
|
|
|
|
log.InfoFormat("Time since process started: {0}", (DateTime.Now - Process.GetCurrentProcess().StartTime).ToString());
|
|
|
|
log.InfoFormat("Handles open: {0}", p.HandleCount.ToString());
|
|
log.InfoFormat("USER handles open: {0}", Win32.GetGuiResourcesUserCount(p.Handle));
|
|
log.InfoFormat("GDI handles open: {0}", Win32.GetGuiResourcesGDICount(p.Handle));
|
|
log.InfoFormat("Thread count: {0}", p.Threads.Count);
|
|
|
|
log.InfoFormat("Virtual memory size: {0} B({1})", p.VirtualMemorySize64, Util.MemorySizeStringSuitableUnits(p.VirtualMemorySize64, false));
|
|
log.InfoFormat("Working set: {0} B({1})", p.WorkingSet64, Util.MemorySizeStringSuitableUnits(p.WorkingSet64, false));
|
|
log.InfoFormat("Private memory size: {0} B({1})", p.PrivateMemorySize64, Util.MemorySizeStringSuitableUnits(p.PrivateMemorySize64, false));
|
|
log.InfoFormat("Nonpaged system memory size: {0} B({1})", p.NonpagedSystemMemorySize64, Util.MemorySizeStringSuitableUnits(p.NonpagedSystemMemorySize64, false));
|
|
log.InfoFormat("Paged memory size: {0} B({1})", p.PagedMemorySize64, Util.MemorySizeStringSuitableUnits(p.PagedMemorySize64, false));
|
|
log.InfoFormat("Paged system memory size: {0} B({1})", p.PagedSystemMemorySize64, Util.MemorySizeStringSuitableUnits(p.PagedSystemMemorySize64, false));
|
|
|
|
log.InfoFormat("Peak paged memory size: {0} B({1})", p.PeakPagedMemorySize64, Util.MemorySizeStringSuitableUnits(p.PeakPagedMemorySize64, false));
|
|
log.InfoFormat("Peak virtual memory size: {0} B({1})", p.PeakVirtualMemorySize64, Util.MemorySizeStringSuitableUnits(p.PeakVirtualMemorySize64, false));
|
|
log.InfoFormat("Peak working set: {0} B({1})", p.PeakWorkingSet64, Util.MemorySizeStringSuitableUnits(p.PeakWorkingSet64, false));
|
|
|
|
log.InfoFormat("Process priority class: {0}", p.PriorityClass.ToString());
|
|
log.InfoFormat("Privileged processor time: {0}", p.PrivilegedProcessorTime.ToString());
|
|
|
|
log.InfoFormat("Total processor time: {0}", p.TotalProcessorTime.ToString());
|
|
log.InfoFormat("User processor time: {0}", p.UserProcessorTime.ToString());
|
|
}
|
|
|
|
private static void Application_ApplicationExit(object sender, EventArgs e)
|
|
{
|
|
Exiting = true;
|
|
try
|
|
{
|
|
Clip.UnregisterClipboardViewer();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
log.Warn("Error while unregistering clipboard viewer on application exit", ex);
|
|
}
|
|
|
|
try
|
|
{
|
|
// Let's save the connections first, so we can save their connected state
|
|
Settings.SaveServerList(); //this calls Settings.TrySaveSettings()
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
log.Warn("Error while saving server list on application exit", ex);
|
|
}
|
|
|
|
try
|
|
{
|
|
// The application is about to exit - gracefully close connections to
|
|
// avoid a bunch of WinForms related race conditions...
|
|
foreach (IXenConnection conn in ConnectionsManager.XenConnectionsCopy)
|
|
conn.EndConnect(false, true);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
log.Warn("Error while ending connections on application exit", ex);
|
|
}
|
|
|
|
DisconnectPipe();
|
|
LogApplicationStats();
|
|
}
|
|
|
|
private static void Application_ThreadException(object sender, ThreadExceptionEventArgs e)
|
|
{
|
|
ProcessUnhandledException(e.Exception);
|
|
}
|
|
|
|
private static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
|
|
{
|
|
ProcessUnhandledException(e.ExceptionObject as Exception);
|
|
}
|
|
|
|
private static void ProcessUnhandledException(Exception e)
|
|
{
|
|
try
|
|
{
|
|
if (e != null)
|
|
{
|
|
log.Fatal("Uncaught exception", e);
|
|
if (e.InnerException != null)
|
|
log.Fatal("Inner exception", e.InnerException);
|
|
}
|
|
else
|
|
{
|
|
log.Fatal("Fatal error");
|
|
}
|
|
LogSystemDetails();
|
|
LogApplicationStats();
|
|
|
|
if (RunInAutomatedTestMode)
|
|
{
|
|
if (e != null && TestExceptionString == null)
|
|
TestExceptionString = e.GetBaseException().ToString();
|
|
}
|
|
else
|
|
{
|
|
string filepath = GetLogFile() ?? Messages.MESSAGEBOX_LOGFILE_MISSING;
|
|
|
|
using (var d = new ErrorDialog(String.Format(Messages.MESSAGEBOX_PROGRAM_UNEXPECTED, HelpersGUI.DateTimeToString(DateTime.Now, "yyyy-MM-dd HH:mm:ss", false), filepath))
|
|
{ WindowTitle = string.Format(Messages.MESSAGEBOX_PROGRAM_UNEXPECTED_TITLE, BrandManager.BrandConsole) })
|
|
{
|
|
// CA-44733
|
|
if (IsInvokable(MainWindow) && !MainWindow.InvokeRequired)
|
|
d.ShowDialog(MainWindow);
|
|
else
|
|
d.ShowDialog();
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
try
|
|
{
|
|
log.Fatal("Fatal error while handling fatal error!", exception);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
// ignored
|
|
}
|
|
|
|
if (!RunInAutomatedTestMode)
|
|
{
|
|
using (var dlg = new ErrorDialog(exception.ToString()))
|
|
dlg.ShowDialog();
|
|
// To be handled by WER
|
|
throw;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Set the default fonts.
|
|
/// Some locales have a known correct font, which we just use. Otherwise (e.g. English),
|
|
/// we need to make sure that our fonts fit in with our panel layout. This can be a problem
|
|
/// on far-Eastern platforms in particular, because the default fonts there are wider in the
|
|
/// English range than Tahoma / Segoe UI. Anything bigger than them is going to cause us to
|
|
/// overflow on the panels, so we force it back to an appropriate font. We need to be careful
|
|
/// not to override the user's settings if they've deliberately scaled up the text for readability
|
|
/// reasons, so we only override if the font size is 9pt or smaller, which is the usual default.
|
|
/// We also define a registry key to turn this off, just in case someone in the field complains.
|
|
/// </summary>
|
|
private static void SetDefaultFonts()
|
|
{
|
|
if (Registry.ForceSystemFonts)
|
|
{
|
|
log.Debug("ForceSystemFonts registry key is defined");
|
|
}
|
|
else if (InvisibleMessages.LOCALE.StartsWith("ja-"))
|
|
{
|
|
Font new_font =
|
|
(Environment.OSVersion.Version.Major < 6 || Environment.OSVersion.Version.Major == 6 && Environment.OSVersion.Version.Minor == 0) ?
|
|
new Font("MS UI Gothic", 9.0f) : // 2K (5.0), XP (5.1), 2K3 and XP Pro (5.2), Vista and 2K8 (6.0)
|
|
new Font("Meiryo UI", 9.0f); // Win 7 and 2K8R2 (6.1) and above
|
|
log.DebugFormat("Running on localized resources with Japanese fonts; switching the font from {0} {1}pt to {2} {3}pt.",
|
|
DefaultFont.Name, DefaultFont.Size, new_font.Name, new_font.Size);
|
|
SetDefaultFonts(new_font);
|
|
return;
|
|
}
|
|
else if (InvisibleMessages.LOCALE.StartsWith("zh-"))
|
|
{
|
|
Font new_font =
|
|
Environment.OSVersion.Version.Major < 6 ?
|
|
new Font("MS Shell Dlg", 9.0f) : // 2K (5.0), XP (5.1), 2K3 and XP Pro (5.2)
|
|
new Font("Microsoft YaHei", 9.0f); // Vista and above
|
|
log.DebugFormat("Running on localized resources with Simplified Chinese fonts; switching the font from {0} {1}pt to {2} {3}pt.",
|
|
DefaultFont.Name, DefaultFont.Size, new_font.Name, new_font.Size);
|
|
SetDefaultFonts(new_font);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
if (DefaultFont.Size <= 9.0f)
|
|
{
|
|
Size s = Drawing.MeasureText("Lorum ipsum", DefaultFont);
|
|
// Segoe UI 9pt gives 78x15 here. Tahoma 8pt gives 66x13.
|
|
// We allow a bit of slop just in case antialias or hinting settings make a small difference.
|
|
if (s.Width > 80 || s.Height > 16)
|
|
{
|
|
Font new_font =
|
|
Environment.OSVersion.Version.Major < 6 ?
|
|
new Font("Tahoma", 8.0f) : // 2K (5.0), XP (5.1), 2K3 and XP Pro (5.2)
|
|
new Font("Segoe UI", 9.0f); // Vista and above
|
|
|
|
log.DebugFormat("Running on default resources with large default font; switching the font from {0} {1}pt to {2} {3}pt.",
|
|
DefaultFont.Name, DefaultFont.Size, new_font.Name, new_font.Size);
|
|
SetDefaultFonts(new_font);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
log.Debug("Running on default resources and happy with the font.");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
log.Debug("Running on default resources but the font is bigger than usual.");
|
|
}
|
|
}
|
|
log.DebugFormat("Leaving the default font as {0} {1}pt.", DefaultFont.Name, DefaultFont.Size);
|
|
SetDefaultFonts(DefaultFont);
|
|
}
|
|
|
|
private static void SetDefaultFonts(Font f)
|
|
{
|
|
DefaultFont = f;
|
|
DefaultFontBold = new Font(f, FontStyle.Bold);
|
|
DefaultFontUnderline = new Font(f, FontStyle.Underline);
|
|
DefaultFontItalic = new Font(f, FontStyle.Italic);
|
|
DefaultFontHeader = new Font(f.FontFamily, 9.75f, FontStyle.Bold);
|
|
|
|
FormFontFixer.DefaultFont = f;
|
|
}
|
|
|
|
internal static void AssertOffEventThread()
|
|
{
|
|
if (MainWindow.Visible && !MainWindow.InvokeRequired)
|
|
{
|
|
FatalError();
|
|
}
|
|
}
|
|
|
|
internal static void AssertOnEventThread()
|
|
{
|
|
if (MainWindow != null && MainWindow.Visible && MainWindow.InvokeRequired)
|
|
{
|
|
FatalError();
|
|
}
|
|
}
|
|
|
|
private static void FatalError()
|
|
{
|
|
string msg = String.Format(Messages.MESSAGEBOX_PROGRAM_UNEXPECTED,
|
|
HelpersGUI.DateTimeToString(DateTime.Now, "yyyy-MM-dd HH:mm:ss", false), GetLogFile());
|
|
|
|
var msgWithStackTrace = string.Format("{0}\n{1}", msg, Environment.StackTrace);
|
|
log.Fatal(msgWithStackTrace);
|
|
|
|
MainWindow m = MainWindow;
|
|
if (m == null)
|
|
{
|
|
log.Fatal("Program.MainWindow is null");
|
|
}
|
|
else
|
|
{
|
|
log.FatalFormat("Program.MainWindow.Visible == {0}", m.Visible);
|
|
log.FatalFormat("Program.MainWindow.InvokeRequired == {0}", m.InvokeRequired);
|
|
log.FatalFormat("CurrentThread.Name == {0}", Thread.CurrentThread.Name);
|
|
}
|
|
|
|
if (RunInAutomatedTestMode)
|
|
{
|
|
if (TestExceptionString == null)
|
|
TestExceptionString = msgWithStackTrace;
|
|
}
|
|
else
|
|
{
|
|
using (var dlg = new ErrorDialog(msg)
|
|
{ WindowTitle = string.Format(Messages.MESSAGEBOX_PROGRAM_UNEXPECTED_TITLE, BrandManager.BrandConsole) })
|
|
dlg.ShowDialog();
|
|
}
|
|
}
|
|
|
|
public static void ViewLogFiles()
|
|
{
|
|
string s = GetLogFile();
|
|
if (s == null)
|
|
{
|
|
using (var dlg = new ErrorDialog(Messages.MESSAGEBOX_LOGFILE_MISSING))
|
|
dlg.ShowDialog();
|
|
}
|
|
else
|
|
{
|
|
Process.Start(Path.GetDirectoryName(s));
|
|
}
|
|
}
|
|
|
|
public static string GetLogFile()
|
|
{
|
|
foreach (log4net.Appender.IAppender appender in log.Logger.Repository.GetAppenders())
|
|
{
|
|
var fileAppender = appender as log4net.Appender.FileAppender;
|
|
if (fileAppender != null)
|
|
{
|
|
// Assume that the first FileAppender is the primary log file.
|
|
return fileAppender.File;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
#region Invocations
|
|
|
|
/// <summary>
|
|
/// Safely invoke the given delegate on the given control.
|
|
/// </summary>
|
|
public static void Invoke(Control c, MethodInvoker f)
|
|
{
|
|
try
|
|
{
|
|
if (IsInvokable(c))
|
|
{
|
|
if (c.InvokeRequired)
|
|
{
|
|
MethodInvoker exceptionLogger = () =>
|
|
{
|
|
try
|
|
{
|
|
f();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
log.Error(string.Format("Exception in Invoke (ControlType={0}, MethodName={1})",
|
|
c.GetType(), f.Method.Name), e);
|
|
throw;
|
|
}
|
|
};
|
|
|
|
c.Invoke(exceptionLogger);
|
|
}
|
|
else
|
|
{
|
|
f();
|
|
}
|
|
}
|
|
}
|
|
catch (ObjectDisposedException e)
|
|
{
|
|
if (IsInvokable(c))
|
|
throw;
|
|
log.Error(e);
|
|
}
|
|
catch (InvalidAsynchronousStateException e)
|
|
{
|
|
if (IsInvokable(c))
|
|
throw;
|
|
log.Error(e);
|
|
}
|
|
catch (InvalidOperationException e)
|
|
{
|
|
if (IsInvokable(c))
|
|
throw;
|
|
log.Error(e);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Safely invoke the given delegate on the given control.
|
|
/// </summary>
|
|
/// <returns>The result of the function call, or null if the control cannot be invoked.</returns>
|
|
public static object Invoke(Control c, Delegate f, params object[] p)
|
|
{
|
|
try
|
|
{
|
|
if (IsInvokable(c))
|
|
{
|
|
if (c.InvokeRequired)
|
|
{
|
|
Func<object> exceptionLogger = () =>
|
|
{
|
|
try
|
|
{
|
|
return f.DynamicInvoke(p);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
log.Error(string.Format("Exception in Invoke (ControlType={0}, MethodName={1})",
|
|
c.GetType(), f.Method.Name), e);
|
|
throw;
|
|
}
|
|
};
|
|
|
|
return c.Invoke(exceptionLogger);
|
|
}
|
|
else
|
|
{
|
|
return f.DynamicInvoke(p);
|
|
}
|
|
}
|
|
}
|
|
catch (ObjectDisposedException e)
|
|
{
|
|
if (IsInvokable(c))
|
|
throw;
|
|
log.Error(e);
|
|
}
|
|
catch (InvalidAsynchronousStateException e)
|
|
{
|
|
if (IsInvokable(c))
|
|
throw;
|
|
log.Error(e);
|
|
}
|
|
catch (InvalidOperationException e)
|
|
{
|
|
if (IsInvokable(c))
|
|
throw;
|
|
log.Error(e);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public static IAsyncResult BeginInvoke(Control c, Delegate f, params object[] p)
|
|
{
|
|
try
|
|
{
|
|
if (IsInvokable(c))
|
|
return c.BeginInvoke(f, p);
|
|
}
|
|
catch (ObjectDisposedException e)
|
|
{
|
|
if (IsInvokable(c))
|
|
throw;
|
|
log.Error(e);
|
|
}
|
|
catch (InvalidAsynchronousStateException e)
|
|
{
|
|
if (IsInvokable(c))
|
|
throw;
|
|
log.Error(e);
|
|
}
|
|
catch (InvalidOperationException e)
|
|
{
|
|
if (IsInvokable(c))
|
|
throw;
|
|
log.Error(e);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public static void BeginInvoke(Control c, MethodInvoker f)
|
|
{
|
|
try
|
|
{
|
|
if (IsInvokable(c))
|
|
c.BeginInvoke(f);
|
|
}
|
|
catch (ObjectDisposedException e)
|
|
{
|
|
if (IsInvokable(c))
|
|
throw;
|
|
log.Error(e);
|
|
}
|
|
catch (InvalidAsynchronousStateException e)
|
|
{
|
|
if (IsInvokable(c))
|
|
throw;
|
|
log.Error(e);
|
|
}
|
|
catch (InvalidOperationException e)
|
|
{
|
|
if (IsInvokable(c))
|
|
throw;
|
|
log.Error(e);
|
|
}
|
|
}
|
|
|
|
private static bool IsInvokable(Control c)
|
|
{
|
|
return !Exiting && c != null && !c.Disposing && !c.IsDisposed && c.IsHandleCreated;
|
|
}
|
|
|
|
#endregion
|
|
|
|
public static void OpenURL(string url)
|
|
{
|
|
if (RunInAutomatedTestMode || string.IsNullOrEmpty(url))
|
|
return;
|
|
try
|
|
{
|
|
Process.Start(url);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
log.Debug(string.Format("Exception while opening url {0}:", url), e);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// If true action threads will close themselves instantly...
|
|
/// </summary>
|
|
public static bool ForcedExiting = false;
|
|
|
|
public static string CurrentLanguage => Thread.CurrentThread.CurrentCulture.TwoLetterISOLanguageName;
|
|
|
|
public static string VersionAndLanguage => $"{Version}.{CurrentLanguage}";
|
|
|
|
public static CultureInfo CurrentCulture => Thread.CurrentThread.CurrentCulture;
|
|
}
|
|
}
|