PosixSignalHandler.cs

Go to the documentation of this file.

using System;
using System.Threading;
using System.Threading.Tasks;
 
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Mono.Unix;
using Mono.Unix.Native;
 
using Tgstation.Server.Host.Core;
using Tgstation.Server.Host.Utils;
 
namespace Tgstation.Server.Host.System
{
    sealed class PosixSignalHandler : IHostedService, IDisposable
    {
        const int CheckDelayMs = 250;
 
        readonly IServerControl serverControl;
 
        readonly IAsyncDelayer asyncDelayer;
 
        readonly ILogger<PosixSignalHandler> logger;
 
        readonly CancellationTokenSource cancellationTokenSource;
 
        Task? signalCheckerTask;
 
        public PosixSignalHandler(IServerControl serverControl, IAsyncDelayer asyncDelayer, ILogger<PosixSignalHandler> logger)
        {
            this.serverControl = serverControl ?? throw new ArgumentNullException(nameof(serverControl));
            this.asyncDelayer = asyncDelayer ?? throw new ArgumentNullException(nameof(asyncDelayer));
            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
 
            cancellationTokenSource = new CancellationTokenSource();
        }
 
        public void Dispose() => cancellationTokenSource.Dispose();
 
        public Task StartAsync(CancellationToken cancellationToken)
        {
            if (signalCheckerTask != null)
                throw new InvalidOperationException("Attempted to start PosixSignalHandler twice!");
 
            signalCheckerTask = Task.WhenAll(
                SignalChecker(Signum.SIGUSR1, false),
                SignalChecker(Signum.SIGUSR2, true));
 
            return Task.CompletedTask;
        }
 
        public async Task StopAsync(CancellationToken cancellationToken)
        {
            if (signalCheckerTask?.IsCompleted != false)
                return;
 
            logger.LogDebug("Stopping SignalCheckerThread...");
            cancellationTokenSource.Cancel();
 
            logger.LogTrace("Joining SignalCheckerThread...");
            await signalCheckerTask;
        }
 
        async Task SignalChecker(Signum signum, bool detach)
        {
            try
            {
                logger.LogTrace("Started SignalChecker");
 
                using var unixSignal = new UnixSignal(signum);
                if (!unixSignal.IsSet)
                {
                    logger.LogTrace("Waiting for {signum}...", signum);
                    var cancellationToken = cancellationTokenSource.Token;
                    while (!unixSignal.IsSet)
                        await asyncDelayer.Delay(TimeSpan.FromMilliseconds(CheckDelayMs), cancellationToken);
 
                    logger.LogTrace("{signum} received!", signum);
                }
                else
                    logger.LogDebug("{signum} has already been sent", signum);
 
                logger.LogTrace("Triggering graceful shutdown...");
                await serverControl.GracefulShutdown(detach);
            }
            catch (OperationCanceledException ex)
            {
                logger.LogDebug(ex, "SignalChecker cancelled!");
            }
            catch (Exception ex)
            {
                logger.LogError(ex, "SignalChecker crashed!");
            }
            finally
            {
                logger.LogTrace("Exiting SignalChecker...");
            }
        }
    }
}