ServerService.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.Versioning;
using System.ServiceProcess;
using System.Threading;
 
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.EventLog;
 
using Tgstation.Server.Common;
using Tgstation.Server.Host.Watchdog;
 
namespace Tgstation.Server.Host.Service
{
    [SupportedOSPlatform("windows")]
    sealed class ServerService : ServiceBase
    {
        public const string Name = Constants.CanonicalPackageName;
 
        readonly IWatchdogFactory watchdogFactory;
 
        readonly Lazy<ILoggerFactory> loggerFactory;
 
        readonly string[] commandLineArguments;
 
#pragma warning disable CA2213 // Disposable fields should be disposed
        volatile ServiceLifetime? serviceLifetime;
#pragma warning restore CA2213 // Disposable fields should be disposed
 
        public ServerService(IWatchdogFactory watchdogFactory, string[] commandLineArguments, LogLevel minimumLogLevel)
        {
            this.watchdogFactory = watchdogFactory ?? throw new ArgumentNullException(nameof(watchdogFactory));
            this.commandLineArguments = commandLineArguments ?? throw new ArgumentNullException(nameof(commandLineArguments));
 
            ServiceName = Name;
            loggerFactory = new Lazy<ILoggerFactory>(() => LoggerFactory.Create(builder => builder.AddEventLog(new EventLogSettings
            {
                LogName = EventLog.Log,
                MachineName = EventLog.MachineName,
                SourceName = EventLog.Source,
                Filter = (message, logLevel) => logLevel >= minimumLogLevel,
            })));
        }
 
        public void Run() => Run(this);
 
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                OnStop();
 
                if (loggerFactory.IsValueCreated)
                    loggerFactory.Value.Dispose();
            }
 
            base.Dispose(disposing);
        }
 
        protected override void OnCustomCommand(int command) => serviceLifetime!.HandleCustomCommand(command);
 
        protected override void OnStart(string[] args)
        {
            var newArgs = new List<string>(commandLineArguments.Length + args.Length + 1)
            {
                "--General:SetupWizardMode=Never",
            };
 
            newArgs.AddRange(commandLineArguments);
            newArgs.AddRange(args);
 
            serviceLifetime = new ServiceLifetime(
                Stop,
                signalChecker => watchdogFactory.CreateWatchdog(signalChecker, loggerFactory.Value),
                loggerFactory.Value.CreateLogger<ServiceLifetime>(),
                newArgs.ToArray());
        }
 
        protected override void OnStop()
        {
            var oldLifetime = Interlocked.Exchange(ref serviceLifetime, null);
            oldLifetime?.DisposeAsync().GetAwaiter().GetResult();
        }
    }
}