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);
}
void StopService()
{
try
{
if (_hasCancelled == false)
{
_log.InfoFormat("Stopping the {0} service", _settings.ServiceName);
if (!_serviceHandle.Stop(this))
{
throw new TopshelfException("The service failed to stop (returned false).");
}
}
}
catch (Exception ex)
{
_settings.ExceptionCallback?.Invoke(ex);
_log.Error("The service did not shut down gracefully", ex);
_exitCode = TopshelfExitCode.ServiceControlRequestFailed;
}
finally
{
_serviceHandle.Dispose();
_log.InfoFormat("The {0} service has stopped.", _settings.ServiceName);
}
}
static int Main(string[] args)
{
int syncInterval = Convert.ToInt16(ConfigurationManager.AppSettings["SyncInterval"]);
var rc = HostFactory.New(x =>
{
x.Service <SyncingJobService>(sc =>
{
sc.ConstructUsing(s => new SyncingJobService());
sc.WhenStarted((s, hostControl) => s.Start(hostControl));
sc.WhenStopped((s, hostControl) => s.Stop(hostControl));
});
x.RunAsLocalSystem()
.DependsOnEventLog()
.StartAutomatically()
.EnableServiceRecovery(src => src.RestartService(1));
x.SetServiceName("KL2 Files sync service");
x.SetDisplayName("KL2 Files sync service");
x.SetDescription("KL2 Files syncing job service");
});
TopshelfExitCode exitCode = TopshelfExitCode.AbnormalExit;
try
{
exitCode = rc.Run();
}
catch (Exception e)
{
//Trace.TraceError(e, "ERROR on service starting.");
}
return((int)exitCode);
}
public static void Main(string[] args)
{
StandardKernel kernel = new StandardKernel();
kernel.Load("StanBot.*.dll");
TopshelfExitCode topshelfExitCode = HostFactory.Run(x =>
{
x.Service <ServiceManager>(s =>
{
s.ConstructUsing(name => kernel.Get <ServiceManager>());
s.WhenStarted(tc => AsyncContext.Run(tc.Start));
s.WhenStopped(tc => tc.Stop());
});
x.RunAsLocalSystem();
x.UnhandledExceptionPolicy = UnhandledExceptionPolicyCode.LogErrorOnly;
x.OnException(HandleException);
x.SetDescription("Discord bot for the STAIR discord to authenticate students from HSLU. May include more features but I don't really know now so this is for everything else that may be integrated and not mentioned here. Bad Heineken!");
x.SetDisplayName("STAIR Discord Bot");
x.SetServiceName("STAIR Discord Bot");
});
int exitCode = (int)Convert.ChangeType(topshelfExitCode, topshelfExitCode.GetTypeCode());
Environment.ExitCode = exitCode;
}
public static int Main(string[] args)
{
// .\Syringe.Service.exe [verb] [-option:value] [-switch]
// run Runs the service from the command line (default)
// help or –help Displays help
// install Installs the service
var container = IoC.Initialize();
TopshelfExitCode exitCode = HostFactory.Run(host =>
{
host.ApplyCommandLine();
host.Service <Startup>(service =>
{
service.ConstructUsing(() => container.GetInstance <Startup>());
service.WhenStarted(x => x.Start());
service.WhenStopped(x => x.Stop());
});
host.SetServiceName("Syringe");
host.SetDisplayName("Syringe");
host.SetDescription("Syringe RESTful API service");
});
return((int)exitCode);
}
static void Main(string[] args)
{
log4net.Config.XmlConfigurator.Configure(new FileInfo(Path.Combine(path, "log4net.config")));
TopshelfExitCode returnCode = HostFactory.Run(app =>
{
app.UseLog4Net();
app.Service <Worker>(service =>
{
string dvsaConfig = File.ReadAllText(Path.Combine(path, "config.json"));
service.ConstructUsing(name => new Worker(connection, appSettings, dvsaConfig));
service.WhenStarted(worker => worker.Start());
service.WhenStopped(worker => worker.Stop());
});
app.StartAutomatically();
app.RunAsLocalService();
app.SetServiceName("DVSA Service");
app.SetDescription("Checks vehicles against the DVSA MOT History API");
app.EnableServiceRecovery(recovery =>
{
recovery.RestartService(5);
});
});
int exitCode = (int)Convert.ChangeType(returnCode, returnCode.GetTypeCode());
Environment.ExitCode = exitCode;
}
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));
}
}
}
/// <summary>
///
/// </summary>
/// <param name="cancelRunner"></param>
/// <param name="companyConfig"></param>
/// <param name="runnerProgress"></param>
/// <returns></returns>
private ServiceTaskResult RunWindowsService(CancellationToken cancelRunner, CompanyConfig companyConfig,
ServiceProgressInfo runnerProgress)
{
// NOTE: In order to get the initial code delivered, I am reusing the code, or parts of it at least,
// from the original MakoRunner project that uses the Topshelf library. This is not ideal since
// we lose a great deal of control over our services. However, we know the code works for one
// company ID at a time, which is why I'm reusing here, in the Sequential portion of the IF clause.
//
TopshelfExitCode retCode = HostFactory.Run(x =>
{
x.Service <TopshelfWindowsService>(sc =>
{
sc.ConstructUsing(name => new TopshelfWindowsService(companyConfig, runnerProgress));
sc.WhenStarted((s, hostControl) => s.Start(hostControl));
sc.WhenShutdown(s => s.Shutdown());
sc.WhenStopped((s, hostControl) => s.Stop(hostControl));
});
//
x.SetServiceName($"CommRunner {companyConfig.CompanyName + companyConfig.CompanyId}");
x.SetDescription($"Mako Commission Runner for CompanyID ({companyConfig.CompanyId})");
x.SetDisplayName($"Mako Commission Runner {companyConfig.CompanyId}");
//
//x.StartAutomaticallyDelayed();
});
//
int exitCode = (int)Convert.ChangeType(retCode, retCode.GetTypeCode());
// Create and return a ServiceTaskResult.
// TODO: Add properties to the ServiceTaskResult and populate based on service exit code, etc.
return(new ServiceTaskResult()
{
ServiceReturnCode = exitCode
});
}
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));
}
}
}
}
/// <summary>
/// The main entry point for the application.
/// </summary>
static void Main()
{
TopshelfExitCode exitcode = HostFactory.Run(x =>
{
x.RunAsLocalSystem();
x.SetDescription("Open Account Windows Service");
x.SetDisplayName("Open Account Service");
x.SetServiceName("OpenAccountService");
x.Service <OAService>(service =>
{
service.ConstructUsing(name => new OAService());
service.WhenStarted(tc =>
{
tc.Start();
x.StartAutomatically();
});
service.WhenStopped(tc =>
{
tc.Stop();
});
});
});
}
public static int Main(string[] args)
{
ITraceManager traceManager = new Log4netTraceManager(new Log4netWrapper());
var rc = HostFactory.New(x =>
{
x.Service <ApiService>(sc =>
{
sc.ConstructUsing(s => new ApiService());
sc.WhenStarted((s, hostControl) => s.Start(hostControl));
sc.WhenStopped((s, hostControl) => s.Stop(hostControl));
});
x.RunAsLocalSystem();
x.SetDescription(ApiService.Description);
x.SetDisplayName(ApiService.DisplayName);
x.SetServiceName(ApiService.ServiceName);
x.EnableServiceRecovery(recoveryOption => recoveryOption.RestartService(0));
x.StartAutomaticallyDelayed();
});
TopshelfExitCode exitCode = TopshelfExitCode.AbnormalExit;
try
{
exitCode = rc.Run();
}
catch (Exception e)
{
traceManager.TraceError(e, "ERROR on service starting.");
}
return((int)exitCode);
}
static void Main(string[] args)
{
TopshelfExitCode rc = HostFactory.Run(X =>
{
X.RunAsLocalSystem();//服务使用NETWORK_SERVICE内置帐户运行。
//身份标识，有好几种方式，如：X.RunAs("username", "password"); X.RunAsPrompt(); X.RunAsNetworkService(); 等
X.SetDisplayName("自动服务");//显示名称
X.SetDescription("任务调度系统的服务");//安装服务后，服务的描述
X.SetServiceName("自动服务");//服务名称
X.UseOwin(baseAddress: "http://localhost:9000/");
X.SetStartTimeout(TimeSpan.FromMinutes(5));//设置超时之前等待服务启动的时间。 默认值为10秒。
X.SetStopTimeout(TimeSpan.FromMinutes(35));//设置超时之前等待服务停止的时间。 默认值为10秒。
//设置服务失败后的操作
X.EnableServiceRecovery(r =>
{
r.RestartService(1); //等待延迟时间（分钟）后重新启动服务
});
});
Environment.ExitCode = (int)Convert.ChangeType(rc, rc.GetTypeCode());
RecurringJob.AddOrUpdate<SampleService>("TestSimpleJob", X => X.SimpleJob(null), Cron.Minutely(), TimeZoneInfo.Local);
using (var server = new BackgroundJobServer())
{
Console.ReadLine();
}
}
private static int Main(string[] args)
{
IWindsorContainer container = CreateContainer();
TopshelfExitCode exitCode = HostFactory.Run(
config =>
{
config.Service <TimesheetProcessingService>(
s =>
{
s.ConstructUsing(f => container.Resolve <TimesheetProcessingService>());
s.WhenStarted(f => f.Start());
s.WhenStopped(f => f.Stop());
s.WhenShutdown((service, host) => container.Release(service));
});
config.RunAsLocalSystem();
config.SetServiceName(ConfigurationManager.AppSettings["TopShelf.Service.Name"]);
config.SetDisplayName(ConfigurationManager.AppSettings["TopShelf.Service.DisplayName"]);
config.SetDescription(ConfigurationManager.AppSettings["TopShelf.Service.Description"]);
});
return((int)exitCode);
}
private static TopshelfExitCode RunServiceNormally <TService>(Action <HostConfigurator, TService> options)
where TService : IService, new()
{
TopshelfExitCode code = HostFactory.Run(x =>
{
options(x, (TService)_serviceProxy.Service);
VersionLogger.LogVersions();
x.Service <ServiceProxy>(s =>
{
s.ConstructUsing(name => _serviceProxy);
s.WhenStarted(StartService);
s.WhenStopped(tc => tc.Stop());
s.WhenShutdown(tc => tc.Stop());
});
x.EnableShutdown();
x.EnableServiceRecovery(ConfigureRecovery);
x.RunAsLocalSystem();
Assembly serviceAssembly = Assembly.GetEntryAssembly();
string serviceName = GetServiceName(serviceAssembly);
x.SetServiceName(serviceName);
x.SetDisplayName(serviceName.Replace('.', ' '));
x.SetDescription(GetServiceDescription(serviceAssembly));
});
return(code);
}
private void RunService(ServiceController <IGaiaService> serviceController)
{
_topshelfExitCode = HostFactory.Run(x =>
{
//x.UseLinuxIfAvailable();
x.ApplyCommandLine();
x.StartAutomatically();
x.RunAsNetworkService();
x.EnableShutdown();
x.EnableServiceRecovery(r => r.RestartService(2));
x.EnablePauseAndContinue();
x.SetDescription(Description);
x.SetDisplayName(DisplayName);
x.SetServiceName(ServiceName);
x.Service(
s => serviceController,
e => {
e.AfterStoppingService(() => serviceController.Dispose());
});
});
Environment.ExitCode = (int)Convert.ChangeType(_topshelfExitCode, _topshelfExitCode.GetTypeCode());
}
private Program Run()
{
_logger.Information("Starting TopShelf host...");
_exitCode =
HostFactory.Run(
hostConfig =>
{
hostConfig.Service <PlayLogger>(
serviceConfig =>
{
serviceConfig.ConstructUsing(() => _container.GetInstance <PlayLogger>());
serviceConfig.WhenStarted(x => x.Start());
serviceConfig.WhenStopped(x => x.Stop());
});
hostConfig.RunAsLocalSystem();
hostConfig.SetServiceName(ServiceName);
hostConfig.SetDisplayName(ServiceDisplayName);
hostConfig.SetDescription(ServiceDescription);
});
_logger.Information("TopShelf host completed");
return(this);
}
static void Main(string[] args)
{
if (args.Length == 0 && Environment.UserInteractive)
{
IsConsoleMode = true;
InstanceProvider.GetServiceLogger().AppendLine("BedrockService startup detected in Console mode.");;
}
Host host = HostFactory.New(x =>
{
x.SetStartTimeout(TimeSpan.FromSeconds(10));
x.SetStopTimeout(TimeSpan.FromSeconds(10));
//x.UseLog4Net();
x.UseAssemblyInfoForServiceInfo();
x.Service(settings => InstanceProvider.GetBedrockService(), s =>
{
s.BeforeStartingService(_ => InstanceProvider.GetServiceLogger().AppendLine("Starting service..."));
s.BeforeStoppingService(_ => InstanceProvider.GetServiceLogger().AppendLine("Stopping service..."));
});
x.RunAsLocalSystem();
x.SetDescription("Windows Service Wrapper for Windows Bedrock Server");
x.SetDisplayName("BedrockService");
x.SetServiceName("BedrockService");
x.UnhandledExceptionPolicy = UnhandledExceptionPolicyCode.LogErrorOnly;
x.EnableServiceRecovery(src =>
{
src.RestartService(delayInMinutes: 0);
src.RestartService(delayInMinutes: 1);
src.SetResetPeriod(days: 1);
});
x.OnException((ex) =>
{
InstanceProvider.GetServiceLogger().AppendLine("Exception occured Main : " + ex.ToString());
});
});
TopshelfExitCode rc = host.Run();
var exitCode = (int)Convert.ChangeType(rc, rc.GetTypeCode());
if (DebugModeEnabled)
{
Console.Write("Program is force-quitting. Press any key to exit.");
Console.Out.Flush();
Console.ReadLine();
}
Environment.ExitCode = exitCode;
}
static void Main(string[] args)
{
Directory.SetCurrentDirectory(AppDomain.CurrentDomain.BaseDirectory);
var mode = ConfigurationManager.AppSettings["MPE.Pinger.Mode"]?.ToLowerInvariant();
TopshelfExitCode rc = TopshelfExitCode.Ok;
switch (mode)
{
case "server":
rc = HostFactory.Run(x =>
{
x.Service <ServerStartup>(s =>
{
s.ConstructUsing(name => new ServerStartup());
s.WhenStarted(tc => tc.Start());
s.WhenStopped(tc => tc.Stop());
});
x.RunAsLocalSystem();
x.SetDescription("Server to receive metric results");
x.SetDisplayName("MPE_Pinger_Server");
x.SetServiceName("MPE_Pinger_Server");
});
break;
case "client":
rc = HostFactory.Run(x =>
{
x.Service <ClientStartup>(s =>
{
s.ConstructUsing(name => new ClientStartup());
s.WhenStarted(tc => tc.Start());
s.WhenStopped(tc => tc.Stop());
});
x.RunAsLocalSystem();
x.SetDescription("Service to call different endpoint to check for life");
x.SetDisplayName("MPE_Pinger");
x.SetServiceName("MPE_Pinger");
});
break;
}
Console.ReadLine();
var exitCode = (int)Convert.ChangeType(rc, rc.GetTypeCode());
Environment.ExitCode = exitCode;
}
static void Main(string[] args)
{
TopshelfExitCode exitCode = TopshelfExitCode.Ok;
try
{
// https://github.com/serilog/serilog/wiki/AppSettings
Log.Logger = new LoggerConfiguration()
.ReadFrom.AppSettings()
.CreateLogger();
Log.Information("*** Begin Application. ***");
exitCode = HostFactory.Run(x =>
{
var settings = new LoggerJsonSettings().Load();
Log.Information("Loaded settings at {0}", settings.DefaultPath);
x.Service <LoggerService>(s =>
{
s.ConstructUsing(name => new LoggerService(settings));
s.WhenStarted(tc => tc.Start());
s.WhenStopped(tc => tc.Stop());
});
x.EnableServiceRecovery(r =>
{
r.OnCrashOnly();
r.RestartService(1); //first
r.RestartService(1); //second
r.RestartService(1); //subsequents
});
//Windowsサービスの設定
x.RunAs(settings.LoggerSettings.ServiceUserName, settings.LoggerSettings.ServicePassword);
x.SetDescription(loggerConstants.ServiceDescription);
x.SetDisplayName(loggerConstants.ServiceDsiplayName);
x.SetServiceName(loggerConstants.ServiceServiceName);
x.StartAutomaticallyDelayed();
});
}
catch (Exception ex)
{
Log.Error(ex, "Topshelf down?");
}
finally
{
Log.Information("*** Topshelf exit code is {0} ***", exitCode);
Log.CloseAndFlush();
}
}
static void Main()
{
TopshelfExitCode topshelfExitCode = HostFactory.Run(configure =>
{
configure.Service <ObsOverwatchService>();
configure.RunAsLocalSystem();
configure.SetServiceName("OBS Overwatch");
configure.SetDisplayName("OBS Overwatch");
configure.SetDescription("Service that controls OBS program and manages automatic recovery from failure.");
});
int exitCode = (int)Convert.ChangeType(topshelfExitCode, topshelfExitCode.GetTypeCode());
Environment.ExitCode = exitCode;
}
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);
}
static void Main(string[] args)
{
TopshelfExitCode TSExitCode = HostFactory.Run(x =>
{
x.Service <Observer>(s =>
{
s.ConstructUsing(Observer => new Observer());
s.WhenStarted(Observer => Observer.Start());
s.WhenStopped(Observer => Observer.Stop());
});
x.RunAsLocalSystem();
x.StartAutomatically();
x.SetDisplayName("ProccessObserverLocal");
x.SetDescription("Observes all starting services and writes their names in a log file");
});
int exitCode = (int)Convert.ChangeType(TSExitCode, TSExitCode.GetTypeCode());
Environment.ExitCode = exitCode;
}
static void Main(string[] args)
{
try
{
Type service_type = Type.GetType($"Service_Project.Services.{SERVICE_NAME}");
MethodInfo get_host_factory = service_type.GetMethod(
"GetHostFactory", BindingFlags.Static | BindingFlags.Public);
TopshelfExitCode exit_code = (TopshelfExitCode)get_host_factory.Invoke(null, null);
int exit_code_value = (int)Convert.ChangeType(exit_code, exit_code.GetTypeCode());
Environment.ExitCode = exit_code_value;
}
catch (Exception exception)
{
Console.WriteLine($"{exception.GetType()}: {exception.Message}");
Console.ReadKey();
}
}
static void Main(string[] args)
{
IConfigurationRoot configuration = new ConfigurationBuilder()
.AddJsonFile(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), Constants.AppSettingsFileName))
.Build();
IServiceCollection services = new ServiceCollection()
.AddLogging()
.EnableTraceLogging()
.AddCloudFtpBridgeCore(configuration.GetSection(Constants.CloudFtpBridgeConfigSectionName))
.AddCloudFtpBridgeService();
IServiceProvider serviceProvider = services.BuildServiceProvider();
ILoggerFactory loggerFactory = serviceProvider.GetService <ILoggerFactory>();
loggerFactory.AddPsgLogging(configuration.GetSection(Constants.LoggingConfigSectionName));
TopshelfExitCode topshelfExitCode = HostFactory.Run(topshelf =>
{
topshelf.EnableServiceRecovery(x =>
{
x.RestartService(1).RestartService(2).RestartService(4);
});
topshelf.Service <PollingService>(service =>
{
service.ConstructUsing(() => serviceProvider.GetService <PollingService>());
service.WhenStarted(x => x.Start());
service.WhenStopped(x => x.Stop());
});
topshelf.RunAsLocalService();
topshelf.SetDescription(_ServiceDescription);
topshelf.SetDisplayName(_ServiceDisplayName);
topshelf.SetServiceName(_ServiceName);
topshelf.StartAutomatically();
});
int exitCode = (int)Convert.ChangeType(topshelfExitCode, topshelfExitCode.GetTypeCode());
Environment.ExitCode = exitCode;
}
/// <summary>
/// Main
/// </summary>
/// <param name="args"></param>
/// <returns>Returns void.</returns>
public static void Main(string[] args)
{
bool result = BootLoader();
if (!result)
{
return;
}
SCHostLoader Hostloader = new SCHostLoader();
TopshelfExitCode rc = HostFactory.Run(x =>
{
x.Service <SCLoader>(sc =>
{
sc.ConstructUsing(name => new SCLoader());
sc.WhenStarted(tc => tc.WhenStart());
sc.WhenStopped(tc => tc.WhenStop());
sc.WhenPaused(tc => tc.WhenPause());
sc.WhenContinued(tc => tc.WhenContinue());
sc.WhenShutdown(tc => tc.WhenShutdown());
});
x.RunAsLocalSystem();
x.SetServiceName(DeployServer.ServiceName);
x.SetDisplayName(DeployServer.ServiceDisplayName);
x.SetInstanceName(DeployServer.ServiceInstanceName);
x.SetDescription(DeployServer.ServiceDescription);
x.BeforeInstall(settings => Hostloader.BeforeInstall());
x.BeforeUninstall(() => Hostloader.BeforeUninstall());
x.AfterInstall(settings => Hostloader.AfterInstall());
x.AfterUninstall(() => Hostloader.AfterUninstall());
});
int exitCode = (int)Convert.ChangeType(rc, rc.GetTypeCode(), CultureInfo.InvariantCulture);
Environment.ExitCode = exitCode;
}
static void Main()
{
TopshelfExitCode returnCode = HostFactory.Run(x =>
{
x.Service <WebService>(s =>
{
s.ConstructUsing(name => new WebService());
s.WhenStarted(ws => ws.Start());
s.WhenStopped(ws => ws.Stop());
});
x.RunAsLocalService();
x.SetDescription("SVB-Ticker service for live results.");
x.SetDisplayName("SVB-Ticker");
x.SetServiceName("SVB-Ticker");
});
Environment.ExitCode = (int)Convert.ChangeType(returnCode, returnCode.GetTypeCode());
}
static void Main(string[] args)
{
TopshelfExitCode exitCode = HostFactory.Run(x =>
{
x.Service <GooseBotService>(s =>
{
s.ConstructUsing(gooseBot => new GooseBotService());
s.WhenStarted(gooseBot => gooseBot.Start());
s.WhenStopped(gooseBot => gooseBot.Stop());
});
x.RunAsLocalSystem();
x.SetServiceName("GooseBot");
x.SetDisplayName("Goose Bot");
x.SetDescription("My first Discord bot. Honk!");
});
int exitCodeValue = (int)Convert.ChangeType(exitCode, exitCode.GetTypeCode());
Environment.ExitCode = exitCodeValue;
}
static void Main(string[] args)
{
TopshelfExitCode exitCode = HostFactory.Run(x =>
{
x.Service <HeartBeat>(s =>
{
s.ConstructUsing(heartbeat => new HeartBeat());
s.WhenStarted(heartbeat => heartbeat.Start());
s.WhenStopped(heartbeat => heartbeat.Stop());
});
x.RunAsLocalSystem();
x.SetServiceName("HeartBeatService");
x.SetDisplayName("HeartBeat Service");
x.SetDescription("Test service");
});
int exitCodeValue = (int)Convert.ChangeType(exitCode, exitCode.GetTypeCode());
Environment.ExitCode = exitCodeValue;
}
internal static TopshelfExitCode Configure( )
{
TopshelfExitCode exitCode = TopshelfExitCode.Ok;
try
{
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterType <RealWork>().As <IAmDoingRealWork>();
containerBuilder.RegisterType <MyService>();
var container = containerBuilder.Build();
exitCode = HostFactory.Run(x =>
{
x.UseAutofacContainer(container);
x.Service <MyService>(hostSettings =>
{
hostSettings.ConstructUsing(() => container.Resolve <MyService>());
hostSettings.WhenStarted(s => s.StartService());
hostSettings.WhenStopped(s => s.StopService());
});
x.RunAsLocalSystem();
x.StartAutomatically();
x.SetServiceName("TopshelfTemplateService");
x.SetDisplayName("TopshelfTemplateService");
x.SetDescription("TopshelfTemplateService");
});
}
catch (Exception ex)
{
Log.Information(ex, "Error in ConfigureService.Configure()");
throw;
}
return(exitCode);
}
static void Main(string[] args)
{
TopshelfExitCode rc = HostFactory.Run(x =>
{
x.Service <GenericRestService>(s =>
{
s.ConstructUsing(name => new GenericRestService());
s.WhenStarted(tc => tc.Start());
s.WhenStopped(tc => tc.Stop());
});
x.RunAsLocalSystem();
x.SetDescription("Generic POS Rest Service");
x.SetDisplayName("Generic POS Rest Service");
x.SetServiceName("GenericPOSRestService");
});
int exitCode = (int)Convert.ChangeType(rc, rc.GetTypeCode());
Environment.ExitCode = exitCode;
}
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;
}
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));
}
}
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));
}
}
}
}
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);
_exitCode = TopshelfExitCode.Ok;
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)
{
_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;
}
