void CatchUnhandledException(object sender, UnhandledExceptionEventArgs e) { _settings.ExceptionCallback?.Invoke((Exception)e.ExceptionObject); _log.Fatal("The service threw an unhandled exception", (Exception)e.ExceptionObject); HostLogger.Shutdown(); if (e.IsTerminating) { _exitCode = TopshelfExitCode.UnhandledServiceException; _exit.Set(); #if !NET35 // it isn't likely that a TPL thread should land here, but if it does let's no block it if (Task.CurrentId.HasValue) { return; } #endif // this is evil, but perhaps a good thing to let us clean up properly. int deadThreadId = Interlocked.Increment(ref _deadThread); Thread.CurrentThread.IsBackground = true; Thread.CurrentThread.Name = "Unhandled Exception " + deadThreadId.ToString(); while (true) { Thread.Sleep(TimeSpan.FromHours(1)); } } }
public bool RunAsAdministrator() { if (Environment.OSVersion.Version.Major == 6) { string commandLine = CommandLine.Replace("--sudo", ""); var startInfo = new ProcessStartInfo(Assembly.GetEntryAssembly().Location, commandLine) { Verb = "runas", UseShellExecute = true, CreateNoWindow = true, }; try { HostLogger.Shutdown(); Process process = Process.Start(startInfo); process.WaitForExit(); return(true); } catch (Win32Exception ex) { _log.Debug("Process Start Exception", ex); } } return(false); }
public TopshelfExitCode Run() { Directory.SetCurrentDirectory(AppDomain.CurrentDomain.BaseDirectory); AppDomain.CurrentDomain.UnhandledException += CatchUnhandledException; if (_environment.IsServiceInstalled(_settings.ServiceName)) { if (!_environment.IsServiceStopped(_settings.ServiceName)) { _log.ErrorFormat("The {0} service is running and must be stopped before running via the console", _settings.ServiceName); return(TopshelfExitCode.ServiceAlreadyRunning); } } bool started = false; try { _log.Debug("Starting up as a console application"); _exit = new ManualResetEvent(false); Console.Title = _settings.DisplayName; Console.CancelKeyPress += HandleCancelKeyPress; if (!_serviceHandle.Start(this)) { throw new TopshelfException("The service failed to start (return false)."); } started = true; _log.InfoFormat("The {0} service is now running, press Control+C to exit.", _settings.ServiceName); _exit.WaitOne(); } catch (Exception ex) { _log.Error("An exception occurred", ex); return(TopshelfExitCode.AbnormalExit); } finally { if (started) { StopService(); } _exit.Close(); (_exit as IDisposable).Dispose(); HostLogger.Shutdown(); } return(TopshelfExitCode.Ok); }
private void CatchUnhandledException(object sender, UnhandledExceptionEventArgs e) { _logWriter.Fatal(string.Format(Resources.UnhandledException, _settings.ServiceName), (Exception)e.ExceptionObject); HostLogger.Shutdown(); if (e.IsTerminating) { _exitCode = TopshelfExitCode.UnhandledServiceException; SetStopSignal(); // Author Topshelf: it isn't likely that a TPL thread should land here, but if it does let's no block it if (!Task.CurrentId.HasValue) { // Author Topshelf: this is evil, but perhaps a good thing to let us clean up properly var deadThreadId = Interlocked.Increment(ref _deadThread); Thread.CurrentThread.IsBackground = true; Thread.CurrentThread.Name = "Unhandled Exception " + deadThreadId; while (true) { Thread.Sleep(TimeSpan.FromHours(1)); } } } }
void CatchUnhandledException(object sender, UnhandledExceptionEventArgs e) { _log.Fatal("The service threw an unhandled exception", (Exception)e.ExceptionObject); HostLogger.Shutdown(); // // IF not terminating, then no reason to stop the service? // if (!e.IsTerminating) // return; // This needs to be a configuration option to avoid breaking compatibility ExitCode = (int)TopshelfExitCode.UnhandledServiceException; _unhandledException = e.ExceptionObject as Exception; Stop(); #if !NET35 // it isn't likely that a TPL thread should land here, but if it does let's no block it if (Task.CurrentId.HasValue) { return; } #endif int deadThreadId = Interlocked.Increment(ref _deadThread); Thread.CurrentThread.IsBackground = true; Thread.CurrentThread.Name = "Unhandled Exception " + deadThreadId.ToString(); while (true) { Thread.Sleep(TimeSpan.FromHours(1)); } }
public TopshelfExitCode Run() { try { _log.Debug("Starting application."); _exitCode = TopshelfExitCode.Ok; if (_serviceHandle.Start(this) == false) { throw new TopshelfException("The application failed to start (return false)."); } _log.InfoFormat("The {0} application is now running.", _settings.ServiceName); } catch (Exception ex) { var exceptionCallback = _settings.ExceptionCallback; if (exceptionCallback != null) { Exception exception = ex; exceptionCallback(exception); } _log.Error("An exception occurred", ex); HostLogger.Shutdown(); return(TopshelfExitCode.AbnormalExit); } return(_exitCode); }
public TopshelfExitCode Run() { Directory.SetCurrentDirectory(AppDomain.CurrentDomain.BaseDirectory); // AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(this.CatchUnhandledException); if (this._environment.IsServiceInstalled(this._settings.ServiceName) && !this._environment.IsServiceStopped(this._settings.ServiceName)) { this._log.ErrorFormat("The {0} service is running and must be stopped before running as winforms application", new object[] { this._settings.ServiceName }); return(TopshelfExitCode.ServiceAlreadyRunning); } try { this._log.Debug("Starting up as a winforms application"); var form = new Form(); form.Text = this._settings.DisplayName; var btn = new Button(); if (_Autostart) { Start(); } btn.Click += (s, e) => { if (_IsRunning == 1) { Stop(); btn.Text = "Start"; } else { Start(); btn.Text = "Stop"; } }; btn.Text = _IsRunning == 1 ? "Stop" : "Start"; btn.Dock = DockStyle.Fill; btn.Parent = form; Application.Run(form); return(TopshelfExitCode.Ok); } catch (Exception exception) { this._log.Error("An exception occurred", exception); return(TopshelfExitCode.AbnormalExit); } finally { Stop(); HostLogger.Shutdown(); } }
/// <summary> /// Configures and runs a new service host, handling any exceptions and writing them to the log. /// </summary> /// <param name="configureCallback"> Configuration method to call </param> /// <returns> Returns the exit code of the process that should be returned by your application's main method </returns> public static TopshelfExitCode Run(Action <HostConfigurator> configureCallback) { try { return(New(configureCallback).Run()); } catch (Exception ex) { HostLogger.Get(typeof(HostFactory)).Error("The service terminated abnormally", ex); HostLogger.Shutdown(); return(TopshelfExitCode.AbnormalExit); } }
private static void StartServiceAsync(object state) { var service = (ServiceProxy)state; try { service.Start(); } catch (Exception ex) { HostLogger.Get(typeof(Run)).Fatal("Service could not start", ex); HostLogger.Shutdown(); throw; } }
void CatchUnhandledException(object sender, UnhandledExceptionEventArgs e) { _settings.ExceptionCallback?.Invoke((Exception)e.ExceptionObject); if (_settings.UnhandledExceptionPolicy == UnhandledExceptionPolicyCode.TakeNoAction) { return; } _log.Fatal("The service threw an unhandled exception", (Exception)e.ExceptionObject); if (_settings.UnhandledExceptionPolicy == UnhandledExceptionPolicyCode.LogErrorOnly) { return; } HostLogger.Shutdown(); // // IF not terminating, then no reason to stop the service? // if (!e.IsTerminating) // return; // This needs to be a configuration option to avoid breaking compatibility ExitCode = (int)TopshelfExitCode.AbnormalExit; _unhandledException = (Exception)e.ExceptionObject; Stop(); // it isn't likely that a TPL thread should land here, but if it does let's no block it if (Task.CurrentId.HasValue) { return; } int deadThreadId = Interlocked.Increment(ref _deadThread); Thread.CurrentThread.IsBackground = true; Thread.CurrentThread.Name = "Unhandled Exception " + deadThreadId; while (true) { Thread.Sleep(TimeSpan.FromHours(1)); } }
public TopshelfExitCode Run() { Directory.SetCurrentDirectory(AppDomain.CurrentDomain.BaseDirectory); AppDomain.CurrentDomain.UnhandledException += CatchUnhandledException; if (_environment.IsServiceInstalled(_settings.ServiceName)) { _log.ErrorFormat("The {0} service is installed as a service", _settings.ServiceName); return(TopshelfExitCode.ServiceAlreadyInstalled); } try { _log.Debug("Starting up as a console application"); _exit = new ManualResetEvent(false); Console.CancelKeyPress += HandleCancelKeyPress; _serviceHandle.Start(this); _log.InfoFormat("The {0} service is now running, press Control+C to exit.", _settings.ServiceName); _exit.WaitOne(); } catch (Exception ex) { _log.Error("An exception occurred", ex); return(TopshelfExitCode.AbnormalExit); } finally { StopService(); _exit.Close(); (_exit as IDisposable).Dispose(); HostLogger.Shutdown(); } return(TopshelfExitCode.Ok); }
public static int Service <TService>() where TService : IService, new() { Type serviceType = typeof(TService); _serviceProxy = new ServiceProxy(serviceType); ProcessCustomCommand(); if (!_startService) { return(0); } TopshelfExitCode code = RunServiceNormally <TService>(serviceType); HostLogger.Shutdown(); return((int)code); }
/// <summary> /// Configures a new service host /// </summary> /// <param name="configureCallback"> Configuration method to call </param> /// <returns> A Topshelf service host, ready to run </returns> public static Host New(Action <HostConfigurator> configureCallback) { try { if (configureCallback == null) { throw new ArgumentNullException("configureCallback"); } var configurator = new HostConfiguratorImpl(); Type declaringType = configureCallback.Method.DeclaringType; if (declaringType != null) { string defaultServiceName = declaringType.Namespace; if (!string.IsNullOrEmpty(defaultServiceName)) { configurator.SetServiceName(defaultServiceName); } } configureCallback(configurator); configurator.ApplyCommandLine(); ConfigurationResult result = ValidateConfigurationResult.CompileResults(configurator.Validate()); if (result.Message.Length > 0) { HostLogger.Get(typeof(HostFactory)) .InfoFormat("Configuration Result:\n{0}", result.Message); } return(configurator.CreateHost()); } catch (Exception ex) { HostLogger.Get(typeof(HostFactory)).Error("An exception occurred creating the host", ex); HostLogger.Shutdown(); throw; } }
public TopshelfExitCode Run() { AppDomain.CurrentDomain.UnhandledException += CatchUnhandledException; Directory.SetCurrentDirectory(AppDomain.CurrentDomain.BaseDirectory); _exitCode = TopshelfExitCode.Ok; _signalListener.Listen(); var started = false; try { StartService(); started = true; WaitStopSignal(); } catch (Exception error) { _logWriter.Fatal(error); _exitCode = TopshelfExitCode.AbnormalExit; } finally { if (started) { StopService(); } HostLogger.Shutdown(); } return(_exitCode); }
public static int Service <TService>(Action <HostConfigurator, TService> options = null) where TService : IService, new() { _serviceProxy = new ServiceProxy(typeof(TService)); ProcessCustomCommand(); if (!_startService) { return(0); } _serviceProxy.SetupService(); if (options == null) { options = (configurator, config) => { }; } TopshelfExitCode code = RunServiceNormally(options); HostLogger.Shutdown(); return((int)code); }
public TopshelfExitCode Run() { Directory.SetCurrentDirectory(AppDomain.CurrentDomain.BaseDirectory); AppDomain.CurrentDomain.UnhandledException += CatchUnhandledException; #if NETCORE if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { #endif if (_environment.IsServiceInstalled(_settings.ServiceName)) { if (!_environment.IsServiceStopped(_settings.ServiceName)) { _log.ErrorFormat( "The {0} service is running and must be stopped before running via the console", _settings.ServiceName); return(TopshelfExitCode.ServiceAlreadyRunning); } } #if NETCORE } #endif bool started = false; try { _log.Debug("Starting up as a console application"); _exit = new ManualResetEvent(false); _exitCode = TopshelfExitCode.Ok; if ( #if NETCORE !RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || #endif IntPtr.Zero != GetConsoleWindow()) { try { // It is common to run console applications in windowless mode, this prevents // the process from crashing when attempting to set the title. Console.Title = _settings.DisplayName; } catch (Exception e) when(e is IOException || e is PlatformNotSupportedException) { _log.Info("It was not possible to set the console window title. See the inner exception for details.", e); } } Console.CancelKeyPress += HandleCancelKeyPress; if (!_serviceHandle.Start(this)) { throw new TopshelfException("The service failed to start (return false)."); } started = true; _log.InfoFormat("The {0} service is now running, press Control+C to exit.", _settings.ServiceName); _exit.WaitOne(); } catch (Exception ex) { _settings.ExceptionCallback?.Invoke(ex); _log.Error("An exception occurred", ex); return(TopshelfExitCode.AbnormalExit); } finally { if (started) { StopService(); } _exit.Close(); (_exit as IDisposable).Dispose(); HostLogger.Shutdown(); } return(_exitCode); }
void HostControl.Stop(TopshelfExitCode exitCode) { _log.Info($"Application Stop requested, exiting with exit code: {exitCode}."); StopService(); HostLogger.Shutdown(); }