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 DateTimeOffset? LaunchTime
        {
            get
            {
                try
                {
                    return handle.StartTime;
                }
                catch (Exception ex)
                {
                    logger.LogWarning(ex, "Failed to get PID {pid}'s memory usage!", Id);
                    return null;
                }
            }
        }
 
        public Task Startup { get; }
 
        public Task<int?> Lifetime { get; }
 
        public long? MemoryUsage
        {
            get
            {
                try
                {
                    return handle.PrivateMemorySize64;
                }
                catch (Exception ex)
                {
                    logger.LogWarning(ex, "Failed to get PID {pid}'s memory usage!", Id);
                    return null;
                }
            }
        }
 
        readonly IProcessFeatures processFeatures;
 
        readonly ILogger<Process> logger;
 
        readonly global::System.Diagnostics.Process handle;
 
        readonly CancellationTokenSource cancellationTokenSource;
 
        readonly SafeProcessHandle safeHandle;
 
        readonly Task<string?>? readTask;
 
        readonly object processTimeMeasureLock;
 
        DateTimeOffset lastProcessorMeasureTime;
 
        TimeSpan lastProcessorUsageTime;
 
        double lastProcessorUsageEstimation;
 
        int disposed;
 
        public Process(
            IProcessFeatures processFeatures,
            global::System.Diagnostics.Process handle,
            CancellationTokenSource? readerCts,
            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;
 
            cancellationTokenSource = readerCts ?? new CancellationTokenSource();
 
            this.processFeatures = processFeatures ?? throw new ArgumentNullException(nameof(processFeatures));
 
            this.readTask = readTask;
 
            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
 
            processTimeMeasureLock = new object();
 
            Lifetime = WrapLifetimeTask();
 
            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);
 
            try
            {
                lastProcessorUsageTime = handle.TotalProcessorTime;
            }
            catch (Exception ex)
            {
                logger.LogTrace(ex, "Failed to measure initial process time.");
                lastProcessorUsageTime = TimeSpan.Zero;
            }
 
            lastProcessorMeasureTime = DateTimeOffset.UtcNow;
 
            logger.LogTrace("Created process ID: {pid}", Id);
        }
 
        public async ValueTask DisposeAsync()
        {
            if (Interlocked.Exchange(ref disposed, 1) != 0)
                return;
 
            logger.LogTrace("Disposing PID {pid}...", Id);
            cancellationTokenSource.Cancel();
            cancellationTokenSource.Dispose();
            if (readTask != null)
                await readTask;
 
            await Lifetime;
 
            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.WaitAsync(cancellationToken);
        }
 
        public void Terminate()
        {
            CheckDisposed();
            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)
        {
            CheckDisposed();
            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 SuspendProcess()
        {
            CheckDisposed();
            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 ResumeProcess()
        {
            CheckDisposed();
            try
            {
                processFeatures.ResumeProcess(handle);
                logger.LogTrace("Resumed PID {pid}", Id);
            }
            catch (Exception e)
            {
                logger.LogError(e, "Failed to resume PID {pid}!", Id);
                throw;
            }
        }
 
        public string GetExecutingUsername()
        {
            CheckDisposed();
            var result = processFeatures.GetExecutingUsername(handle);
            logger.LogTrace("PID {pid} Username: {username}", Id, result);
            return result;
        }
 
        public ValueTask CreateDump(string outputFile, bool minidump, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(outputFile);
            CheckDisposed();
 
            logger.LogTrace("Dumping PID {pid} to {dumpFilePath}...", Id, outputFile);
            return processFeatures.CreateDump(handle, outputFile, minidump, cancellationToken);
        }
 
        public double MeasureProcessorTimeDelta()
        {
            lock (processTimeMeasureLock)
            {
                try
                {
                    var now = DateTimeOffset.UtcNow;
                    var newTime = handle.TotalProcessorTime;
 
                    var timeDelta = now - lastProcessorMeasureTime;
                    var newUsage = newTime - lastProcessorUsageTime;
 
                    lastProcessorMeasureTime = now;
                    lastProcessorUsageTime = newTime;
 
                    if (timeDelta != TimeSpan.Zero)
                        lastProcessorUsageEstimation = newUsage / (Environment.ProcessorCount * timeDelta);
                }
                catch (Exception ex)
                {
                    logger.LogWarning(ex, "Error measuring processor time delta!");
                }
 
                return lastProcessorUsageEstimation;
            }
        }
 
        async Task<int?> WrapLifetimeTask()
        {
            bool hasExited;
            try
            {
                await handle.WaitForExitAsync(cancellationTokenSource.Token);
                hasExited = true;
            }
            catch (OperationCanceledException ex)
            {
                logger.LogTrace(ex, "Process lifetime task cancelled!");
                hasExited = handle.HasExited;
            }
 
            if (!hasExited)
                return null;
 
            var exitCode = handle.ExitCode;
            logger.LogTrace("PID {pid} exited with code {exitCode}", Id, exitCode);
            return exitCode;
        }
 
        void CheckDisposed() => ObjectDisposedException.ThrowIf(disposed != 0, this);
    }
}