PosixProcessFeatures.cs

Go to the documentation of this file.

using System;
using System.Threading;
using System.Threading.Tasks;
 
using Microsoft.Extensions.Logging;
using Mono.Unix;
using Mono.Unix.Native;
 
using Tgstation.Server.Api.Models;
using Tgstation.Server.Host.IO;
using Tgstation.Server.Host.Jobs;
 
namespace Tgstation.Server.Host.System
{
    sealed class PosixProcessFeatures : IProcessFeatures
    {
        readonly Lazy<IProcessExecutor> lazyLoadedProcessExecutor;
 
        readonly IIOManager ioManager;
 
        readonly ILogger<PosixProcessFeatures> logger;
 
        public PosixProcessFeatures(Lazy<IProcessExecutor> lazyLoadedProcessExecutor, IIOManager ioManager, ILogger<PosixProcessFeatures> logger)
        {
            this.lazyLoadedProcessExecutor = lazyLoadedProcessExecutor ?? throw new ArgumentNullException(nameof(lazyLoadedProcessExecutor));
            this.ioManager = ioManager ?? throw new ArgumentNullException(nameof(ioManager));
            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
        }
 
        public void ResumeProcess(global::System.Diagnostics.Process process)
        {
            var result = Syscall.kill(process.Id, Signum.SIGCONT);
            if (result != 0)
                throw new UnixIOException(Stdlib.GetLastError());
        }
 
        public void SuspendProcess(global::System.Diagnostics.Process process)
        {
            var result = Syscall.kill(process.Id, Signum.SIGSTOP);
            if (result != 0)
                throw new UnixIOException(Stdlib.GetLastError());
        }
 
        public Task<string> GetExecutingUsername(global::System.Diagnostics.Process process, CancellationToken cancellationToken)
            => throw new NotSupportedException();
 
        public async Task CreateDump(global::System.Diagnostics.Process process, string outputFile, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(process);
            ArgumentNullException.ThrowIfNull(outputFile);
 
            const string GCorePath = "/usr/bin/gcore";
            if (!await ioManager.FileExists(GCorePath, cancellationToken))
                throw new JobException(ErrorCode.MissingGCore);
 
            int pid;
            try
            {
                if (process.HasExited)
                    throw new JobException(ErrorCode.DreamDaemonOffline);
 
                pid = process.Id;
            }
            catch (InvalidOperationException ex)
            {
                throw new JobException(ErrorCode.DreamDaemonOffline, ex);
            }
 
            string output;
            int exitCode;
            await using (var gcoreProc = await lazyLoadedProcessExecutor.Value.LaunchProcess(
                GCorePath,
                Environment.CurrentDirectory,
                $"-o {outputFile} {process.Id}",
                readStandardHandles: true,
                noShellExecute: true))
            {
                using (cancellationToken.Register(() => gcoreProc.Terminate()))
                    exitCode = await gcoreProc.Lifetime;
 
                output = await gcoreProc.GetCombinedOutput(cancellationToken);
                logger.LogDebug("gcore output:{0}{1}", Environment.NewLine, output);
            }
 
            if (exitCode != 0)
                throw new JobException(
                    ErrorCode.GCoreFailure,
                    new JobException(
                        $"Exit Code: {exitCode}{Environment.NewLine}Output:{Environment.NewLine}{output}"));
 
            // gcore outputs name.pid so remove the pid part
            var generatedGCoreFile = $"{outputFile}.{pid}";
            await ioManager.MoveFile(generatedGCoreFile, outputFile, cancellationToken);
        }
    }
}