CommandPipeManager.cs

Go to the documentation of this file.

using System;
using System.IO;
using System.IO.Pipes;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
 
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
 
using Tgstation.Server.Host.Common;
using Tgstation.Server.Host.Components;
using Tgstation.Server.Host.Configuration;
 
namespace Tgstation.Server.Host.Core
{
    sealed class CommandPipeManager : BackgroundService
    {
        readonly IServerControl serverControl;
 
        readonly IInstanceManager instanceManager;
 
        readonly ILogger<CommandPipeManager> logger;
 
        readonly InternalConfiguration internalConfiguration;
 
        public CommandPipeManager(
            IServerControl serverControl,
            IInstanceManager instanceManager,
            IOptions<InternalConfiguration> internalConfigurationOptions,
            ILogger<CommandPipeManager> logger)
        {
            this.serverControl = serverControl ?? throw new ArgumentNullException(nameof(serverControl));
            this.instanceManager = instanceManager ?? throw new ArgumentNullException(nameof(instanceManager));
            internalConfiguration = internalConfigurationOptions?.Value ?? throw new ArgumentNullException(nameof(internalConfigurationOptions));
            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
        }
 
        protected override async Task ExecuteAsync(CancellationToken cancellationToken)
        {
            logger.LogTrace("Starting...");
 
            // grab both pipes asap so we can close them on error
            var commandPipe = internalConfiguration.CommandPipe;
            var supportsPipeCommands = !String.IsNullOrWhiteSpace(commandPipe);
            await using var commandPipeClient = supportsPipeCommands
                ? new AnonymousPipeClientStream(
                    PipeDirection.In,
                    commandPipe!)
                : null;
 
            if (!supportsPipeCommands)
                logger.LogDebug("No command pipe name specified in configuration");
 
            var readyPipe = internalConfiguration.ReadyPipe;
            var supportsReadyNotification = !String.IsNullOrWhiteSpace(readyPipe);
            if (supportsReadyNotification)
            {
                await using var readyPipeClient = new AnonymousPipeClientStream(
                    PipeDirection.Out,
                    readyPipe!);
 
                logger.LogTrace("Waiting to send ready notification...");
                await instanceManager.Ready.WaitAsync(cancellationToken);
 
                using var streamWriter = new StreamWriter(readyPipeClient, Encoding.UTF8, leaveOpen: true);
                await streamWriter.WriteLineAsync(PipeCommands.CommandStartupComplete.AsMemory(), cancellationToken);
            }
            else
                logger.LogDebug("No ready pipe name specified in configuration");
 
            if (!supportsPipeCommands)
                return;
 
            try
            {
                using var streamReader = new StreamReader(commandPipeClient!, Encoding.UTF8, leaveOpen: true);
                while (!cancellationToken.IsCancellationRequested)
                {
                    logger.LogTrace("Waiting to read command line...");
                    var line = await streamReader.ReadLineAsync(cancellationToken);
 
                    logger.LogInformation("Received pipe command: {command}", line);
                    switch (line)
                    {
                        case PipeCommands.CommandStop:
                            await serverControl.Die(null);
                            break;
                        case PipeCommands.CommandGracefulShutdown:
                            await serverControl.GracefulShutdown(false);
                            break;
                        case PipeCommands.CommandDetachingShutdown:
                            await serverControl.GracefulShutdown(true);
                            break;
                        case null:
                            logger.LogError("Read null from pipe!");
                            return;
                        default:
                            logger.LogWarning("Unrecognized pipe command: {command}", line);
                            break;
                    }
                }
            }
            catch (OperationCanceledException ex)
            {
                logger.LogTrace(ex, "Command read task cancelled!");
            }
            catch (Exception ex)
            {
                logger.LogError(ex, "Command read task errored!");
            }
            finally
            {
                logger.LogTrace("Command read task exiting...");
            }
        }
    }
}