Process.cs

Go to the documentation of this file.

using Microsoft.Extensions.Logging;
using System;
using System.Diagnostics;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

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 StringBuilder outputStringBuilder;
        readonly StringBuilder errorStringBuilder;
        readonly StringBuilder combinedStringBuilder;

        public Process(
            IProcessFeatures processFeatures,
            global::System.Diagnostics.Process handle,
            Task<int> lifetime,
            StringBuilder outputStringBuilder,
            StringBuilder errorStringBuilder,
            StringBuilder combinedStringBuilder,
            ILogger<Process> logger,
            bool preExisting)
        {
            this.processFeatures = processFeatures ?? throw new ArgumentNullException(nameof(processFeatures));
            this.handle = handle ?? throw new ArgumentNullException(nameof(handle));

            this.outputStringBuilder = outputStringBuilder;
            this.errorStringBuilder = errorStringBuilder;
            this.combinedStringBuilder = combinedStringBuilder;

            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));

            Lifetime = WrapLifetimeTask(lifetime ?? throw new ArgumentNullException(nameof(lifetime)));

            Id = handle.Id;

            if (preExisting)
            {
                Startup = Task.CompletedTask;
                return;
            }

            Startup = Task.Factory.StartNew(() =>
            {
                try
                {
                    handle.WaitForInputIdle();
                }
                catch (InvalidOperationException) { }
            }, default, TaskCreationOptions.LongRunning, TaskScheduler.Current);

            logger.LogTrace("Created process ID: {0}", Id);
        }

        public void Dispose() => handle.Dispose();

        async Task<int> WrapLifetimeTask(Task<int> lifetimeTask)
        {
            var result = await lifetimeTask.ConfigureAwait(false);
            logger.LogTrace("PID {0} ended with code {1}", Id, result);
            return result;
        }

        public string GetCombinedOutput()
        {
            if (combinedStringBuilder == null)
                throw new InvalidOperationException("Output/Error reading was not enabled!");
            return combinedStringBuilder.ToString().TrimStart(Environment.NewLine.ToCharArray());
        }

        public string GetErrorOutput()
        {
            if (errorStringBuilder == null)
                throw new InvalidOperationException("Error reading was not enabled!");
            return errorStringBuilder.ToString().TrimStart(Environment.NewLine.ToCharArray());
        }

        public string GetStandardOutput()
        {
            if (outputStringBuilder == null)
                throw new InvalidOperationException("Output reading was not enabled!");
            return outputStringBuilder.ToString().TrimStart(Environment.NewLine.ToCharArray());
        }

        public void Terminate()
        {
            if (handle.HasExited)
                return;
            try
            {
                logger.LogTrace("Terminating PID {0}...", Id);
                handle.Kill();
                handle.WaitForExit();
            }
            catch (Exception e)
            {
                logger.LogDebug("Process termination exception: {0}", e);
            }
        }

        public void SetHighPriority()
        {
            try
            {
                handle.PriorityClass = ProcessPriorityClass.AboveNormal;
                logger.LogTrace("Set PID {0} to above normal priority", Id);
            }
            catch (Exception e)
            {
                logger.LogWarning("Unable to raise process priority for PID {0}! Exception: {1}", Id, e);
            }
        }

        public void Suspend() => processFeatures.SuspendProcess(handle);

        public void Resume() => processFeatures.ResumeProcess(handle);

        public async Task<string> GetExecutingUsername(CancellationToken cancellationToken)
        {
            var result = await processFeatures.GetExecutingUsername(handle, cancellationToken).ConfigureAwait(false);
            logger.LogTrace("PID {0} Username: {1}", Id, result);
            return result;
        }
    }
}