Process.cs

Go to the documentation of this file.

using System;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;
 
using Microsoft.Extensions.Logging;
using Microsoft.Win32.SafeHandles;
 
using Tgstation.Server.Host.IO;
 
namespace Tgstation.Server.Host.System
{
    sealed class Process : IProcess
    {
        public int Id { get; }
 
        public Task Startup { get; }
 
        public Task<int> Lifetime { get; }
 
        readonly IProcessFeatures processFeatures;
 
        readonly ILogger<Process> logger;
 
        readonly global::System.Diagnostics.Process handle;
 
        readonly CancellationTokenSource readerCts;
 
        readonly SafeProcessHandle safeHandle;
 
        readonly Task<string> readTask;
 
        public Process(
            IProcessFeatures processFeatures,
            global::System.Diagnostics.Process handle,
            CancellationTokenSource readerCts,
            Task<int> lifetime,
            Task<string> readTask,
            ILogger<Process> logger,
            bool preExisting)
        {
            this.handle = handle ?? throw new ArgumentNullException(nameof(handle));
 
            // Do this fast because the runtime will bitch if we try to access it after it ends
            safeHandle = handle.SafeHandle;
            Id = handle.Id;
 
            this.readerCts = readerCts;
 
            this.processFeatures = processFeatures ?? throw new ArgumentNullException(nameof(processFeatures));
 
            this.readTask = readTask;
 
            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
 
            Lifetime = WrapLifetimeTask(lifetime ?? throw new ArgumentNullException(nameof(lifetime)));
 
            if (preExisting)
            {
                Startup = Task.CompletedTask;
                return;
            }
 
            Startup = Task.Factory.StartNew(
                () =>
                {
                    try
                    {
                        handle.WaitForInputIdle();
                    }
                    catch (Exception ex)
                    {
                        logger.LogTrace(ex, "WaitForInputIdle() failed, this is normal.");
                    }
                },
                CancellationToken.None, // DCT: None available
                DefaultIOManager.BlockingTaskCreationOptions,
                TaskScheduler.Current);
 
            logger.LogTrace("Created process ID: {pid}", Id);
        }
 
        public async ValueTask DisposeAsync()
        {
            logger.LogTrace("Disposing PID {pid}...", Id);
            readerCts?.Cancel();
            readerCts?.Dispose();
            if (readTask != null)
                await readTask;
 
            safeHandle.Dispose();
            handle.Dispose();
        }
 
        public Task<string> GetCombinedOutput(CancellationToken cancellationToken)
        {
            if (readTask == null)
                throw new InvalidOperationException("Output/Error stream reading was not enabled!");
            return readTask;
        }
 
        public void Terminate()
        {
            if (handle.HasExited)
            {
                logger.LogTrace("PID {pid} already exited", Id);
                return;
            }
 
            try
            {
                logger.LogTrace("Terminating PID {pid}...", Id);
                handle.Kill();
                if (!handle.WaitForExit(5000))
                    logger.LogWarning("WaitForExit() on PID {pid} timed out!", Id);
            }
            catch (Exception e)
            {
                logger.LogDebug(e, "PID {pid} termination exception!", Id);
            }
        }
 
        public void AdjustPriority(bool higher)
        {
            var targetPriority = higher ? ProcessPriorityClass.AboveNormal : ProcessPriorityClass.BelowNormal;
            try
            {
                handle.PriorityClass = targetPriority;
                logger.LogTrace("Set PID {pid} to {targetPriority} priority", Id, targetPriority);
            }
            catch (Exception ex)
            {
                logger.LogWarning(ex, "Unable to set priority for PID {id} to {targetPriority}!", Id, targetPriority);
            }
        }
 
        public void Suspend()
        {
            try
            {
                processFeatures.SuspendProcess(handle);
                logger.LogTrace("Suspended PID {pid}", Id);
            }
            catch (Exception e)
            {
                logger.LogError(e, "Failed to suspend PID {pid}!", Id);
                throw;
            }
        }
 
        public void Resume()
        {
            try
            {
                processFeatures.ResumeProcess(handle);
                logger.LogTrace("Resumed PID {pid}", Id);
            }
            catch (Exception e)
            {
                logger.LogError(e, "Failed to resume PID {pid}!", Id);
                throw;
            }
        }
 
        public async Task<string> GetExecutingUsername(CancellationToken cancellationToken)
        {
            var result = await processFeatures.GetExecutingUsername(handle, cancellationToken);
            logger.LogTrace("PID {pid} Username: {username}", Id, result);
            return result;
        }
 
        public Task CreateDump(string outputFile, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(outputFile);
 
            logger.LogTrace("Dumping PID {pid} to {dumpFilePath}...", Id, outputFile);
            return processFeatures.CreateDump(handle, outputFile, cancellationToken);
        }
 
        async Task<int> WrapLifetimeTask(Task<int> lifetimeTask)
        {
            var exitCode = await lifetimeTask;
            logger.LogTrace("PID {pid} exited with code {exitCode}", Id, exitCode);
            return exitCode;
        }
    }
}