InstanceController.cs

Go to the documentation of this file.

using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Net;
using System.Reflection;
using System.Threading;
using System.Threading.Tasks;
using Tgstation.Server.Api;
using Tgstation.Server.Api.Models;
using Tgstation.Server.Api.Rights;
using Tgstation.Server.Host.Components;
using Tgstation.Server.Host.Configuration;
using Tgstation.Server.Host.Database;
using Tgstation.Server.Host.IO;
using Tgstation.Server.Host.Jobs;
using Tgstation.Server.Host.Models;
using Tgstation.Server.Host.Security;
using Tgstation.Server.Host.System;

namespace Tgstation.Server.Host.Controllers
{
    [Route(Routes.InstanceManager)]
    #pragma warning disable CA1506 // TODO: Decomplexify
    public sealed class InstanceController : ApiController
    {
        const string InstanceAttachFileName = "TGS4_ALLOW_INSTANCE_ATTACH";

        const string MoveInstanceJobPrefix = "Move instance ID ";

        readonly IJobManager jobManager;

        readonly IInstanceManager instanceManager;

        readonly IIOManager ioManager;

        readonly IAssemblyInformationProvider assemblyInformationProvider;

        readonly IPlatformIdentifier platformIdentifier;

        readonly GeneralConfiguration generalConfiguration;

        public InstanceController(
            IDatabaseContext databaseContext,
            IAuthenticationContextFactory authenticationContextFactory,
            IJobManager jobManager,
            IInstanceManager instanceManager,
            IIOManager ioManager,
            IAssemblyInformationProvider assemblyInformationProvider,
            IPlatformIdentifier platformIdentifier,
            IOptions<GeneralConfiguration> generalConfigurationOptions,
            ILogger<InstanceController> logger)
            : base(databaseContext, authenticationContextFactory, logger, false, true)
        {
            this.jobManager = jobManager ?? throw new ArgumentNullException(nameof(jobManager));
            this.instanceManager = instanceManager ?? throw new ArgumentNullException(nameof(instanceManager));
            this.ioManager = ioManager ?? throw new ArgumentNullException(nameof(ioManager));
            this.assemblyInformationProvider = assemblyInformationProvider ?? throw new ArgumentNullException(nameof(assemblyInformationProvider));
            this.platformIdentifier = platformIdentifier ?? throw new ArgumentNullException(nameof(platformIdentifier));
            generalConfiguration = generalConfigurationOptions?.Value ?? throw new ArgumentNullException(nameof(generalConfigurationOptions));
        }

        string NormalizePath(string path)
        {
            if (path == null)
                return null;

            path = ioManager.ResolvePath(path);
            if (platformIdentifier.IsWindows)
                path = path.ToUpperInvariant().Replace('\\', '/');

            return path;
        }

        Models.InstanceUser InstanceAdminUser() => new Models.InstanceUser
        {
            ByondRights = (ByondRights)~0U,
            ChatBotRights = (ChatBotRights)~0U,
            ConfigurationRights = (ConfigurationRights)~0U,
            DreamDaemonRights = (DreamDaemonRights)~0U,
            DreamMakerRights = (DreamMakerRights)~0U,
            RepositoryRights = (RepositoryRights)~0U,
            InstanceUserRights = (InstanceUserRights)~0U,
            UserId = AuthenticationContext.User.Id
        };

        [HttpPut]
        [TgsAuthorize(InstanceManagerRights.Create)]
        [ProducesResponseType(typeof(Api.Models.Instance), 200)]
        [ProducesResponseType(typeof(Api.Models.Instance), 201)]
        public async Task<IActionResult> Create([FromBody] Api.Models.Instance model, CancellationToken cancellationToken)
        {
            if (model == null)
                throw new ArgumentNullException(nameof(model));

            if (String.IsNullOrWhiteSpace(model.Name))
                return BadRequest(new ErrorMessage(ErrorCode.InstanceWhitespaceName));

            var targetInstancePath = NormalizePath(model.Path);
            model.Path = targetInstancePath;

            var installationDirectoryPath = NormalizePath(DefaultIOManager.CurrentDirectory);

            bool InstanceIsChildOf(string otherPath)
            {
                if (!targetInstancePath.StartsWith(otherPath, StringComparison.Ordinal))
                    return false;

                bool sameLength = targetInstancePath.Length == otherPath.Length;
                char dirSeparatorChar = targetInstancePath.ToCharArray()[Math.Min(otherPath.Length, targetInstancePath.Length - 1)];
                return sameLength
                    || dirSeparatorChar == Path.DirectorySeparatorChar
                    || dirSeparatorChar == Path.AltDirectorySeparatorChar;
            }

            if (InstanceIsChildOf(installationDirectoryPath))
                return Conflict(new ErrorMessage(ErrorCode.InstanceAtConflictingPath));

            // Validate it's not a child of any other instance
            IActionResult earlyOut = null;
            ulong countOfOtherInstances = 0;
            using (var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken))
            {
                var newCancellationToken = cts.Token;
                try
                {
                    await DatabaseContext
                        .Instances
                        .AsQueryable()
                        .Select(x => new Models.Instance
                        {
                            Path = x.Path
                        })
                        .ForEachAsync(
                            otherInstance =>
                            {
                                if (++countOfOtherInstances >= generalConfiguration.InstanceLimit)
                                    earlyOut ??= Conflict(new ErrorMessage(ErrorCode.InstanceLimitReached));
                                else if (InstanceIsChildOf(otherInstance.Path))
                                    earlyOut ??= Conflict(new ErrorMessage(ErrorCode.InstanceAtConflictingPath));

                                if (earlyOut != null && !newCancellationToken.IsCancellationRequested)
                                    cts.Cancel();
                            },
                            newCancellationToken)
                        .ConfigureAwait(false);
                }
                catch (OperationCanceledException)
                {
                    cancellationToken.ThrowIfCancellationRequested();
                }
            }

            if (earlyOut != null)
                return earlyOut;

            // Last test, ensure it's in the list of valid paths
            if (!(generalConfiguration.ValidInstancePaths?
                .Select(path => NormalizePath(path))
                .Any(path => InstanceIsChildOf(path)) ?? true))
                return BadRequest(new ErrorMessage(ErrorCode.InstanceNotAtWhitelistedPath));

            async Task<bool> DirExistsAndIsNotEmpty()
            {
                if (!await ioManager.DirectoryExists(model.Path, cancellationToken).ConfigureAwait(false))
                    return false;

                var filesTask = ioManager.GetFiles(model.Path, cancellationToken);
                var dirsTask = ioManager.GetDirectories(model.Path, cancellationToken);

                var files = await filesTask.ConfigureAwait(false);
                var dirs = await dirsTask.ConfigureAwait(false);

                return files.Concat(dirs).Any();
            }

            var dirExistsTask = DirExistsAndIsNotEmpty();
            bool attached = false;
            if (await ioManager.FileExists(model.Path, cancellationToken).ConfigureAwait(false) || await dirExistsTask.ConfigureAwait(false))
                if (!await ioManager.FileExists(ioManager.ConcatPath(model.Path, InstanceAttachFileName), cancellationToken).ConfigureAwait(false))
                    return Conflict(new ErrorMessage(ErrorCode.InstanceAtExistingPath));
                else
                    attached = true;

            var newInstance = new Models.Instance
            {
                ConfigurationType = model.ConfigurationType ?? ConfigurationType.Disallowed,
                DreamDaemonSettings = new DreamDaemonSettings
                {
                    AllowWebClient = false,
                    AutoStart = false,
                    PrimaryPort = 1337,
                    SecondaryPort = 1338,
                    SecurityLevel = DreamDaemonSecurity.Safe,
                    StartupTimeout = 60,
                    HeartbeatSeconds = 60
                },
                DreamMakerSettings = new DreamMakerSettings
                {
                    ApiValidationPort = 1339,
                    ApiValidationSecurityLevel = DreamDaemonSecurity.Safe
                },
                Name = model.Name,
                Online = false,
                Path = model.Path,
                AutoUpdateInterval = model.AutoUpdateInterval ?? 0,
                ChatBotLimit = model.ChatBotLimit ?? Models.Instance.DefaultChatBotLimit,
                RepositorySettings = new RepositorySettings
                {
                    CommitterEmail = "tgstation-server@users.noreply.github.com",
                    CommitterName = assemblyInformationProvider.VersionPrefix,
                    PushTestMergeCommits = false,
                    ShowTestMergeCommitters = false,
                    AutoUpdatesKeepTestMerges = false,
                    AutoUpdatesSynchronize = false,
                    PostTestMergeComment = false
                },
                InstanceUsers = new List<Models.InstanceUser> // give this user full privileges on the instance
                {
                    InstanceAdminUser()
                }
            };

            DatabaseContext.Instances.Add(newInstance);
            try
            {
                await DatabaseContext.Save(cancellationToken).ConfigureAwait(false);

                try
                {
                    // actually reserve it now
                    await ioManager.CreateDirectory(targetInstancePath, cancellationToken).ConfigureAwait(false);
                    await ioManager.DeleteFile(ioManager.ConcatPath(targetInstancePath, InstanceAttachFileName), cancellationToken).ConfigureAwait(false);
                }
                catch
                {
                    // oh shit delete the model
                    DatabaseContext.Instances.Remove(newInstance);

                    await DatabaseContext.Save(default).ConfigureAwait(false);
                    throw;
                }
            }
            catch (IOException e)
            {
                return Conflict(new ErrorMessage(ErrorCode.IOError)
                {
                    AdditionalData = e.Message
                });
            }

            Logger.LogInformation("{0} {1} instance {2}: {3} ({4})", AuthenticationContext.User.Name, attached ? "attached" : "created", newInstance.Name, newInstance.Id, newInstance.Path);

            var api = newInstance.ToApi();
            return attached ? (IActionResult)Json(api) : StatusCode((int)HttpStatusCode.Created, api);
        }

        [HttpDelete("{id}")]
        [TgsAuthorize(InstanceManagerRights.Delete)]
        [ProducesResponseType(204)]
        [ProducesResponseType(410)]
        public async Task<IActionResult> Delete(long id, CancellationToken cancellationToken)
        {
            var originalModel = await DatabaseContext
                .Instances
                .AsQueryable()
                .Where(x => x.Id == id)
                .Include(x => x.WatchdogReattachInformation)
                .Include(x => x.WatchdogReattachInformation.Alpha)
                .Include(x => x.WatchdogReattachInformation.Bravo)
                .FirstOrDefaultAsync(cancellationToken).ConfigureAwait(false);
            if (originalModel == default)
                return StatusCode((int)HttpStatusCode.Gone);
            if (originalModel.Online.Value)
                return Conflict(new ErrorMessage(ErrorCode.InstanceDetachOnline));

            if (originalModel.WatchdogReattachInformation != null)
            {
                DatabaseContext.WatchdogReattachInformations.Remove(originalModel.WatchdogReattachInformation);
                if (originalModel.WatchdogReattachInformation.Alpha != null)
                    DatabaseContext.ReattachInformations.Remove(originalModel.WatchdogReattachInformation.Alpha);
                if (originalModel.WatchdogReattachInformation.Bravo != null)
                    DatabaseContext.ReattachInformations.Remove(originalModel.WatchdogReattachInformation.Bravo);
            }

            DatabaseContext.Instances.Remove(originalModel);

            var attachFileName = ioManager.ConcatPath(originalModel.Path, InstanceAttachFileName);
            await ioManager.WriteAllBytes(attachFileName, Array.Empty<byte>(), default).ConfigureAwait(false);
            await DatabaseContext.Save(cancellationToken).ConfigureAwait(false); // cascades everything
            return NoContent();
        }

        [HttpPost]
        [TgsAuthorize(InstanceManagerRights.Relocate | InstanceManagerRights.Rename | InstanceManagerRights.SetAutoUpdate | InstanceManagerRights.SetConfiguration | InstanceManagerRights.SetOnline | InstanceManagerRights.SetChatBotLimit)]
        [ProducesResponseType(typeof(Api.Models.Instance), 200)]
        [ProducesResponseType(typeof(Api.Models.Instance), 202)]
        [ProducesResponseType(410)]
#pragma warning disable CA1502 // TODO: Decomplexify
        public async Task<IActionResult> Update([FromBody] Api.Models.Instance model, CancellationToken cancellationToken)
        {
            if (model == null)
                throw new ArgumentNullException(nameof(model));

            IQueryable<Models.Instance> InstanceQuery() => DatabaseContext
                .Instances
                .AsQueryable()
                .Where(x => x.Id == model.Id);

            var moveJob = await InstanceQuery()
                .SelectMany(x => x.Jobs).
#pragma warning disable CA1307 // Specify StringComparison
                Where(x => !x.StoppedAt.HasValue && x.Description.StartsWith(MoveInstanceJobPrefix))
#pragma warning restore CA1307 // Specify StringComparison
                .Select(x => new Models.Job
                {
                    Id = x.Id
                }).FirstOrDefaultAsync(cancellationToken).ConfigureAwait(false);

            if (moveJob != default)
                await jobManager.CancelJob(moveJob, AuthenticationContext.User, true, cancellationToken).ConfigureAwait(false); // cancel it now

            var originalModel = await InstanceQuery()
                .Include(x => x.RepositorySettings)
                .Include(x => x.ChatSettings)
                .ThenInclude(x => x.Channels)
                .Include(x => x.DreamDaemonSettings) // need these for onlining
                .FirstOrDefaultAsync(cancellationToken).ConfigureAwait(false);
            if (originalModel == default(Models.Instance))
                return StatusCode((int)HttpStatusCode.Gone);

            var userRights = (InstanceManagerRights)AuthenticationContext.GetRight(RightsType.InstanceManager);
            bool CheckModified<T>(Expression<Func<Api.Models.Instance, T>> expression, InstanceManagerRights requiredRight)
            {
                var memberSelectorExpression = (MemberExpression)expression.Body;
                var property = (PropertyInfo)memberSelectorExpression.Member;

                var newVal = property.GetValue(model);
                if (newVal == null)
                    return false;
                if (!userRights.HasFlag(requiredRight) && property.GetValue(originalModel) != newVal)
                    return true;

                property.SetValue(originalModel, newVal);
                return false;
            }

            string originalModelPath = null;
            string rawPath = null;
            if (model.Path != null)
            {
                rawPath = NormalizePath(model.Path);

                if (model.Path != originalModel.Path)
                {
                    if (!userRights.HasFlag(InstanceManagerRights.Relocate))
                        return Forbid();
                    if (originalModel.Online.Value && model.Online != true)
                        return Conflict(new ErrorMessage(ErrorCode.InstanceRelocateOnline));

                    var dirExistsTask = ioManager.DirectoryExists(model.Path, cancellationToken);
                    if (await ioManager.FileExists(model.Path, cancellationToken).ConfigureAwait(false) || await dirExistsTask.ConfigureAwait(false))
                        return Conflict(new ErrorMessage(ErrorCode.InstanceAtExistingPath));

                    originalModelPath = originalModel.Path;
                    originalModel.Path = model.Path;
                }
            }

            var oldAutoUpdateInterval = originalModel.AutoUpdateInterval.Value;
            var originalOnline = originalModel.Online.Value;
            var renamed = model.Name != null && originalModel.Name != model.Name;

            if (CheckModified(x => x.AutoUpdateInterval, InstanceManagerRights.SetAutoUpdate)
                || CheckModified(x => x.ConfigurationType, InstanceManagerRights.SetConfiguration)
                || CheckModified(x => x.Name, InstanceManagerRights.Rename)
                || CheckModified(x => x.Online, InstanceManagerRights.SetOnline)
                || CheckModified(x => x.ChatBotLimit, InstanceManagerRights.SetChatBotLimit))
                return Forbid();

            if (model.ChatBotLimit.HasValue)
            {
                var countOfExistingChatBots = await DatabaseContext
                    .ChatBots
                    .AsQueryable()
                    .Where(x => x.InstanceId == originalModel.Id)
                    .CountAsync(cancellationToken)
                    .ConfigureAwait(false);

                if (countOfExistingChatBots > model.ChatBotLimit.Value)
                    return Conflict(new ErrorMessage(ErrorCode.ChatBotMax));
            }

            // ensure the current user has write privilege on the instance
            var usersInstanceUser = await InstanceQuery()
                .SelectMany(x => x.InstanceUsers)
                .Where(x => x.UserId == AuthenticationContext.User.Id)
                .FirstOrDefaultAsync(cancellationToken)
                .ConfigureAwait(false);
            if (usersInstanceUser == default)
            {
                var instanceAdminUser = InstanceAdminUser();
                instanceAdminUser.InstanceId = originalModel.Id;
                DatabaseContext.InstanceUsers.Add(instanceAdminUser);
            }
            else
                usersInstanceUser.InstanceUserRights |= InstanceUserRights.WriteUsers;

            await DatabaseContext.Save(cancellationToken).ConfigureAwait(false);

            if (renamed)
                await instanceManager.GetInstance(originalModel).InstanceRenamed(originalModel.Name, cancellationToken).ConfigureAwait(false);

            var oldAutoStart = originalModel.DreamDaemonSettings.AutoStart;
            try
            {
                if (originalOnline && model.Online == false)
                    await instanceManager.OfflineInstance(originalModel, AuthenticationContext.User, cancellationToken).ConfigureAwait(false);
                else if (!originalOnline && model.Online == true)
                {
                    // force autostart false here because we don't want any long running jobs right now
                    // remember to document this
                    originalModel.DreamDaemonSettings.AutoStart = false;
                    await instanceManager.OnlineInstance(originalModel, cancellationToken).ConfigureAwait(false);
                }
            }
            catch (Exception e)
            {
                if(!(e is OperationCanceledException))
                    Logger.LogError("Error changing instance online state! Exception: {0}", e);
                originalModel.Online = originalOnline;
                originalModel.DreamDaemonSettings.AutoStart = oldAutoStart;
                if (originalModelPath != null)
                    originalModel.Path = originalModelPath;
                await DatabaseContext.Save(default).ConfigureAwait(false);
                throw;
            }

            var api = (AuthenticationContext.GetRight(RightsType.InstanceManager) & (ulong)InstanceManagerRights.Read) != 0 ? originalModel.ToApi() : new Api.Models.Instance
            {
                Id = originalModel.Id
            };

            var moving = originalModelPath != null;
            if (moving)
            {
                var job = new Models.Job
                {
                    Description = String.Format(CultureInfo.InvariantCulture, MoveInstanceJobPrefix + "{0} from {1} to {2}", originalModel.Id, originalModel.Path, rawPath),
                    Instance = originalModel,
                    CancelRightsType = RightsType.InstanceManager,
                    CancelRight = (ulong)InstanceManagerRights.Relocate,
                    StartedBy = AuthenticationContext.User
                };

                await jobManager.RegisterOperation(job, (paramJob, databaseContextFactory, progressHandler, ct) => instanceManager.MoveInstance(originalModel, rawPath, ct), cancellationToken).ConfigureAwait(false);
                api.MoveJob = job.ToApi();
            }

            if (originalModel.Online.Value && model.AutoUpdateInterval.HasValue && oldAutoUpdateInterval != model.AutoUpdateInterval)
                await instanceManager.GetInstance(originalModel).SetAutoUpdateInterval(model.AutoUpdateInterval.Value).ConfigureAwait(false);

            return moving ? (IActionResult)Accepted(api) : Json(api);
        }
#pragma warning restore CA1502

        [HttpGet(Routes.List)]
        [TgsAuthorize(InstanceManagerRights.List | InstanceManagerRights.Read)]
        [ProducesResponseType(typeof(IEnumerable<Api.Models.Instance>), 200)]
        public async Task<IActionResult> List(CancellationToken cancellationToken)
        {
            IQueryable<Models.Instance> GetBaseQuery()
            {
                IQueryable<Models.Instance> query = DatabaseContext.Instances;
                if (!AuthenticationContext.User.InstanceManagerRights.Value.HasFlag(InstanceManagerRights.List))
                    query = query
                        .Where(x => x.InstanceUsers.Any(y => y.UserId == AuthenticationContext.User.Id))
                        .Where(x => x.InstanceUsers.Any(instanceUser =>
                            instanceUser.ByondRights != ByondRights.None ||
                            instanceUser.ChatBotRights != ChatBotRights.None ||
                            instanceUser.ConfigurationRights != ConfigurationRights.None ||
                            instanceUser.DreamDaemonRights != DreamDaemonRights.None ||
                            instanceUser.DreamMakerRights != DreamMakerRights.None ||
                            instanceUser.InstanceUserRights != InstanceUserRights.None));

                // Hack for EF IAsyncEnumerable BS
                return query.Select(x => x);
            }

            var moveJobs = await GetBaseQuery()
                .SelectMany(x => x.Jobs)
#pragma warning disable CA1307 // Specify StringComparison
                .Where(x => !x.StoppedAt.HasValue && x.Description.StartsWith(MoveInstanceJobPrefix))
#pragma warning restore CA1307 // Specify StringComparison
                .Include(x => x.StartedBy).ThenInclude(x => x.CreatedBy)
                .Include(x => x.Instance)
                .ToListAsync(cancellationToken)
                .ConfigureAwait(false);

            var instances = await GetBaseQuery()
                .ToListAsync(cancellationToken)
                .ConfigureAwait(false);

            var apis = instances.Select(x => x.ToApi());
            foreach(var I in moveJobs)
                apis.Where(x => x.Id == I.Instance.Id).First().MoveJob = I.ToApi(); // if this .First() fails i will personally murder kevinz000 because I just know he is somehow responsible
            return Json(apis);
        }

        [HttpGet("{id}")]
        [TgsAuthorize(InstanceManagerRights.List | InstanceManagerRights.Read)]
        [ProducesResponseType(typeof(Api.Models.Instance), 200)]
        [ProducesResponseType(410)]
        public async Task<IActionResult> GetId(long id, CancellationToken cancellationToken)
        {
            var cantList = !AuthenticationContext.User.InstanceManagerRights.Value.HasFlag(InstanceManagerRights.List);
            IQueryable<Models.Instance> QueryForUser()
            {
                var query = DatabaseContext
                    .Instances
                    .AsQueryable()
                    .Where(x => x.Id == id);

                if (cantList)
                    query = query.Include(x => x.InstanceUsers);
                return query;
            }

            var instance = await QueryForUser().FirstOrDefaultAsync(cancellationToken).ConfigureAwait(false);

            if (instance == null)
                return StatusCode((int)HttpStatusCode.Gone);

            if (cantList && !instance.InstanceUsers.Any(instanceUser => instanceUser.UserId == AuthenticationContext.User.Id &&
                (instanceUser.ByondRights != ByondRights.None ||
                instanceUser.ChatBotRights != ChatBotRights.None ||
                instanceUser.ConfigurationRights != ConfigurationRights.None ||
                instanceUser.DreamDaemonRights != DreamDaemonRights.None ||
                instanceUser.DreamMakerRights != DreamMakerRights.None ||
                instanceUser.InstanceUserRights != InstanceUserRights.None)))
                return Forbid();

            var api = instance.ToApi();

            var moveJob = await QueryForUser()
                .SelectMany(x => x.Jobs)
#pragma warning disable CA1307 // Specify StringComparison
                .Where(x => !x.StoppedAt.HasValue && x.Description.StartsWith(MoveInstanceJobPrefix))
#pragma warning restore CA1307 // Specify StringComparison
                .Include(x => x.StartedBy).ThenInclude(x => x.CreatedBy)
                .FirstOrDefaultAsync(cancellationToken)
                .ConfigureAwait(false);
            api.MoveJob = moveJob?.ToApi();
            return Json(api);
        }
    }
}