InstanceController.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Threading;
using System.Threading.Tasks;
 
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
 
using NCrontab;
 
using Tgstation.Server.Api;
using Tgstation.Server.Api.Models;
using Tgstation.Server.Api.Models.Request;
using Tgstation.Server.Api.Models.Response;
using Tgstation.Server.Api.Rights;
using Tgstation.Server.Common.Extensions;
using Tgstation.Server.Host.Components;
using Tgstation.Server.Host.Configuration;
using Tgstation.Server.Host.Controllers.Results;
using Tgstation.Server.Host.Database;
using Tgstation.Server.Host.Extensions;
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;
using Tgstation.Server.Host.Utils;
 
namespace Tgstation.Server.Host.Controllers
{
    [Route(Routes.InstanceManager)]
#pragma warning disable CA1506 // TODO: Decomplexify
    public sealed class InstanceController : ComponentInterfacingController
    {
        public const string InstanceAttachFileName = "TGS4_ALLOW_INSTANCE_ATTACH";
 
        readonly IJobManager jobManager;
 
        readonly IIOManager ioManager;
 
        readonly IPlatformIdentifier platformIdentifier;
 
        readonly IPortAllocator portAllocator;
 
        readonly IOptions<SwarmConfiguration> swarmConfigurationOptions;
 
        readonly IOptionsSnapshot<GeneralConfiguration> generalConfigurationOptions;
 
        readonly IPermissionsUpdateNotifyee permissionsUpdateNotifyee;
 
        public InstanceController(
            IDatabaseContext databaseContext,
            IAuthenticationContext authenticationContext,
            ILogger<InstanceController> logger,
            IInstanceManager instanceManager,
            IJobManager jobManager,
            IIOManager ioManager,
            IPlatformIdentifier platformIdentifier,
            IPortAllocator portAllocator,
            IPermissionsUpdateNotifyee permissionsUpdateNotifyee,
            IOptions<SwarmConfiguration> swarmConfigurationOptions,
            IOptionsSnapshot<GeneralConfiguration> generalConfigurationOptions,
            IApiHeadersProvider apiHeaders)
            : base(
                  databaseContext,
                  authenticationContext,
                  logger,
                  instanceManager,
                  apiHeaders,
                  false)
        {
            this.jobManager = jobManager ?? throw new ArgumentNullException(nameof(jobManager));
            this.ioManager = ioManager ?? throw new ArgumentNullException(nameof(ioManager));
            this.platformIdentifier = platformIdentifier ?? throw new ArgumentNullException(nameof(platformIdentifier));
            this.portAllocator = portAllocator ?? throw new ArgumentNullException(nameof(portAllocator));
            this.permissionsUpdateNotifyee = permissionsUpdateNotifyee ?? throw new ArgumentNullException(nameof(permissionsUpdateNotifyee));
 
            this.swarmConfigurationOptions = swarmConfigurationOptions ?? throw new ArgumentNullException(nameof(swarmConfigurationOptions));
            this.generalConfigurationOptions = generalConfigurationOptions ?? throw new ArgumentNullException(nameof(generalConfigurationOptions));
        }
 
        [HttpPut]
        [TgsAuthorize(InstanceManagerRights.Create)]
        [ProducesResponseType(typeof(InstanceResponse), 200)]
        [ProducesResponseType(typeof(InstanceResponse), 201)]
        public async ValueTask<IActionResult> Create([FromBody] InstanceCreateRequest model, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(model);
 
            if (String.IsNullOrWhiteSpace(model.Name) || String.IsNullOrWhiteSpace(model.Path))
                return BadRequest(new ErrorMessageResponse(ErrorCode.InstanceWhitespaceNameOrPath));
 
            IActionResult? earlyOut = ValidateCronSetting(model);
            if (earlyOut != null)
                return earlyOut;
 
            var targetInstancePath = NormalizePath(model.Path!);
            model.Path = targetInstancePath;
 
            var installationDirectoryPath = DefaultIOManager.CurrentDirectory;
            if (await ioManager.PathIsChildOf(installationDirectoryPath, targetInstancePath, cancellationToken))
                return Conflict(new ErrorMessageResponse(ErrorCode.InstanceAtConflictingPath));
 
            // Validate it's not a child of any other instance
            var instancePaths = await DatabaseContext
                .Instances
                .Where(x => x.SwarmIdentifer == swarmConfigurationOptions.Value.Identifier)
                .Select(x => new Models.Instance
                {
                    Path = x.Path,
                })
                .ToListAsync(cancellationToken);
 
            var generalConfiguration = generalConfigurationOptions.Value;
            if ((instancePaths.Count + 1) >= generalConfiguration.InstanceLimit)
                return Conflict(new ErrorMessageResponse(ErrorCode.InstanceLimitReached));
 
            var instancePathChecks = instancePaths
                .Select(otherInstance => ioManager.PathIsChildOf(otherInstance.Path!, targetInstancePath, cancellationToken))
                .ToArray();
 
            await Task.WhenAll(instancePathChecks);
 
            if (instancePathChecks.Any(task => task.Result))
                return Conflict(new ErrorMessageResponse(ErrorCode.InstanceAtConflictingPath));
 
            // Last test, ensure it's in the list of valid paths
            var pathChecks = generalConfiguration.ValidInstancePaths?
                .Select(path => ioManager.PathIsChildOf(path, targetInstancePath, cancellationToken))
                .ToArray()
                ?? Enumerable.Empty<Task<bool>>();
            await Task.WhenAll(pathChecks);
            if (!pathChecks.All(task => task.Result))
                return BadRequest(new ErrorMessageResponse(ErrorCode.InstanceNotAtWhitelistedPath));
 
            async ValueTask<bool> DirExistsAndIsNotEmpty()
            {
                if (!await ioManager.DirectoryExists(targetInstancePath, cancellationToken))
                    return false;
 
                var filesTask = ioManager.GetFiles(targetInstancePath, cancellationToken);
                var dirsTask = ioManager.GetDirectories(targetInstancePath, cancellationToken);
 
                var files = await filesTask;
                var dirs = await dirsTask;
 
                return files.Concat(dirs).Any();
            }
 
            var dirExistsTask = DirExistsAndIsNotEmpty();
            bool attached = false;
            if (await ioManager.FileExists(targetInstancePath, cancellationToken) || await dirExistsTask)
                if (!await ioManager.FileExists(ioManager.ConcatPath(targetInstancePath, InstanceAttachFileName), cancellationToken))
                    return Conflict(new ErrorMessageResponse(ErrorCode.InstanceAtExistingPath));
                else
                    attached = true;
 
            var newInstance = await CreateDefaultInstance(model, cancellationToken);
            if (newInstance == null)
                return Conflict(new ErrorMessageResponse(ErrorCode.NoPortsAvailable));
 
            DatabaseContext.Instances.Add(newInstance);
            try
            {
                await DatabaseContext.Save(cancellationToken);
 
                try
                {
                    // actually reserve it now
                    await ioManager.CreateDirectory(targetInstancePath, cancellationToken);
                    await ioManager.DeleteFile(ioManager.ConcatPath(targetInstancePath, InstanceAttachFileName), cancellationToken);
                }
                catch
                {
                    // oh shit delete the model
                    DatabaseContext.Instances.Remove(newInstance);
 
                    // DCT: Operation must always run
                    await DatabaseContext.Save(CancellationToken.None);
                    throw;
                }
            }
            catch (IOException e)
            {
                return Conflict(new ErrorMessageResponse(ErrorCode.IOError)
                {
                    AdditionalData = e.Message,
                });
            }
 
            Logger.LogInformation(
                "{userName} {attachedOrCreated} instance {instanceName}: {instanceId} ({instancePath})",
                AuthenticationContext.User.Name,
                attached ? "attached" : "created",
                newInstance.Name,
                newInstance.Id,
                newInstance.Path);
 
            await permissionsUpdateNotifyee.InstancePermissionSetCreated(
                newInstance.InstancePermissionSets.First(),
                cancellationToken);
 
            var api = newInstance.ToApi();
            api.Accessible = true; // instances are always accessible by their creator
            return attached ? Json(api) : this.Created(api);
        }
 
        [HttpDelete("{id}")]
        [TgsAuthorize(InstanceManagerRights.Delete)]
        [ProducesResponseType(204)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 410)]
        public async ValueTask<IActionResult> Delete(long id, CancellationToken cancellationToken)
        {
            var originalModel = await DatabaseContext
                .Instances
                .Where(x => x.Id == id && x.SwarmIdentifer == swarmConfigurationOptions.Value.Identifier)
                .FirstOrDefaultAsync(cancellationToken);
            if (originalModel == default)
                return this.Gone();
            if (originalModel.Online!.Value)
                return Conflict(new ErrorMessageResponse(ErrorCode.InstanceDetachOnline));
 
            var originalPath = originalModel.Path!;
            var attachFileName = ioManager.ConcatPath(originalPath, InstanceAttachFileName);
            try
            {
                if (await ioManager.DirectoryExists(originalPath, cancellationToken))
                    await ioManager.WriteAllBytes(attachFileName, Array.Empty<byte>(), cancellationToken);
            }
            catch (OperationCanceledException)
            {
                // DCT: Operation must always run
                await ioManager.DeleteFile(attachFileName, CancellationToken.None);
                throw;
            }
 
            try
            {
                // yes this is racy af. I hate it
                // there's a bug where removing the root instance doesn't work sometimes
                await DatabaseContext
                    .CompileJobs
                    .Where(x => x.Job!.Instance!.Id == id)
                    .ExecuteDeleteAsync(cancellationToken);
                await DatabaseContext
                    .RevInfoTestMerges
                    .Where(x => x.RevisionInformation.InstanceId == id)
                    .ExecuteDeleteAsync(cancellationToken);
                await DatabaseContext
                    .RevisionInformations
                    .Where(x => x.InstanceId == id)
                    .ExecuteDeleteAsync(cancellationToken);
 
                DatabaseContext.Instances.Remove(originalModel);
                await DatabaseContext.Save(cancellationToken); // cascades everything else
            }
            catch
            {
                await ioManager.DeleteFile(attachFileName, CancellationToken.None); // DCT: Shouldn't be cancelled
                throw;
            }
 
            return NoContent();
        }
 
        [HttpPost]
        [TgsAuthorize(
            InstanceManagerRights.Relocate
            | InstanceManagerRights.Rename
            | InstanceManagerRights.SetAutoUpdate
            | InstanceManagerRights.SetConfiguration
            | InstanceManagerRights.SetOnline
            | InstanceManagerRights.SetChatBotLimit
            | InstanceManagerRights.SetAutoStart
            | InstanceManagerRights.SetAutoStop)]
        [ProducesResponseType(typeof(InstanceResponse), 200)]
        [ProducesResponseType(typeof(InstanceResponse), 202)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 410)]
#pragma warning disable CA1502 // TODO: Decomplexify
        public async ValueTask<IActionResult> Update([FromBody] InstanceUpdateRequest model, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(model);
 
            IQueryable<Models.Instance> InstanceQuery() => DatabaseContext
                .Instances
                .Where(x => x.Id == model.Id && x.SwarmIdentifer == swarmConfigurationOptions.Value.Identifier);
 
            var moveJob = await InstanceQuery()
                .SelectMany(x => x.Jobs)
                .Where(x => !x.StoppedAt.HasValue && x.JobCode == JobCode.Move)
                .Select(x => new Job(x.Id!.Value))
                .FirstOrDefaultAsync(cancellationToken);
 
            if (moveJob != null)
            {
                // don't allow them to cancel it if they can't start it.
                if (!AuthenticationContext.PermissionSet.InstanceManagerRights!.Value.HasFlag(InstanceManagerRights.Relocate))
                    return Forbid();
                await jobManager.CancelJob(moveJob, AuthenticationContext.User, true, cancellationToken); // 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);
            if (originalModel == default(Models.Instance))
                return this.Gone();
 
            if (ValidateInstanceOnlineStatus(originalModel))
                await DatabaseContext.Save(cancellationToken);
 
            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? normalizedPath = null;
            var originalOnline = originalModel.Online!.Value;
            if (model.Path != null)
            {
                normalizedPath = NormalizePath(model.Path);
 
                if (normalizedPath != originalModel.Path)
                {
                    if (!userRights.HasFlag(InstanceManagerRights.Relocate))
                        return Forbid();
                    if (originalOnline && model.Online != true)
                        return Conflict(new ErrorMessageResponse(ErrorCode.InstanceRelocateOnline));
 
                    var dirExistsTask = ioManager.DirectoryExists(model.Path, cancellationToken);
                    if (await ioManager.FileExists(model.Path, cancellationToken) || await dirExistsTask)
                        return Conflict(new ErrorMessageResponse(ErrorCode.InstanceAtExistingPath));
 
                    originalModelPath = originalModel.Path;
                    originalModel.Path = normalizedPath;
                }
            }
 
            var oldAutoUpdateInterval = originalModel.AutoUpdateInterval!.Value;
            var oldAutoUpdateCron = originalModel.AutoUpdateCron;
            var oldAutoStartCron = originalModel.AutoStartCron;
            var oldAutoStopCron = originalModel.AutoStopCron;
 
            var earlyOut = ValidateCronSetting(model);
            if (earlyOut != null)
                return earlyOut;
 
            var changedAutoUpdateInterval = model.AutoUpdateInterval.HasValue && oldAutoUpdateInterval != model.AutoUpdateInterval;
            var changedAutoUpdateCron = model.AutoUpdateCron != null && oldAutoUpdateCron != model.AutoUpdateCron;
 
            var changedAutoStart = model.AutoStartCron != null && oldAutoStartCron != model.AutoStartCron;
            var changedAutoStop = model.AutoStopCron != null && oldAutoStopCron != model.AutoStopCron;
 
            var renamed = model.Name != null && originalModel.Name != model.Name;
 
            if (CheckModified(x => x.AutoUpdateInterval, InstanceManagerRights.SetAutoUpdate)
                || CheckModified(x => x.AutoUpdateCron, 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)
                || CheckModified(x => x.AutoStartCron, InstanceManagerRights.SetAutoStart)
                || CheckModified(x => x.AutoStopCron, InstanceManagerRights.SetAutoStop))
                return Forbid();
 
            if (model.ChatBotLimit.HasValue)
            {
                var countOfExistingChatBots = await DatabaseContext
                    .ChatBots
                    .Where(x => x.InstanceId == originalModel.Id)
                    .CountAsync(cancellationToken);
 
                if (countOfExistingChatBots > model.ChatBotLimit.Value)
                    return Conflict(new ErrorMessageResponse(ErrorCode.ChatBotMax));
            }
 
            if (changedAutoUpdateCron)
                model.AutoUpdateInterval = 0;
            else if (changedAutoUpdateInterval)
                model.AutoUpdateCron = String.Empty;
 
            await DatabaseContext.Save(cancellationToken);
 
            if (renamed)
            {
                // ignoring retval because we don't care if it's offline
                await WithComponentInstanceNullable(
                    async componentInstance =>
                    {
                        await componentInstance.InstanceRenamed(originalModel.Name!, cancellationToken);
                        return null;
                    },
                    originalModel);
            }
 
            var oldAutoStart = originalModel.DreamDaemonSettings!.AutoStart;
            try
            {
                if (originalOnline && model.Online == false)
                    await InstanceOperations.OfflineInstance(originalModel, AuthenticationContext.User, cancellationToken);
                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 InstanceOperations.OnlineInstance(originalModel, cancellationToken);
                }
            }
            catch (Exception e)
            {
                if (e is not OperationCanceledException)
                    Logger.LogError(e, "Error changing instance online state!");
                originalModel.Online = originalOnline;
                originalModel.DreamDaemonSettings.AutoStart = oldAutoStart;
                if (originalModelPath != null)
                    originalModel.Path = originalModelPath;
 
                // DCT: Operation must always run
                await DatabaseContext.Save(CancellationToken.None);
                throw;
            }
 
            var api = (AuthenticationContext.GetRight(RightsType.InstanceManager) & (ulong)InstanceManagerRights.Read) != 0 ? originalModel.ToApi() : new InstanceResponse
            {
                Id = originalModel.Id,
            };
 
            var moving = originalModelPath != null;
            if (moving)
            {
                var description = $"Move instance ID {originalModel.Id} from {originalModelPath} to {normalizedPath}";
                var job = Job.Create(JobCode.Move, AuthenticationContext.User, originalModel, InstanceManagerRights.Relocate);
                job.Description = description;
 
                await jobManager.RegisterOperation(
                    job,
                    (core, databaseContextFactory, paramJob, progressHandler, ct) // core will be null here since the instance is offline
                        => InstanceOperations.MoveInstance(originalModel, originalModelPath!, ct),
                    cancellationToken);
                api.MoveJob = job.ToApi();
            }
 
            var changedAutoUpdate = changedAutoUpdateInterval || changedAutoUpdateCron;
            if (changedAutoUpdate || changedAutoStart || changedAutoStop)
            {
                // ignoring retval because we don't care if it's offline
                await WithComponentInstanceNullable(
                    async componentInstance =>
                    {
                        var autoUpdateTask = changedAutoUpdate
                            ? componentInstance.ScheduleAutoUpdate(model.AutoUpdateInterval!.Value, model.AutoUpdateCron)
                            : ValueTask.CompletedTask;
 
                        var autoStartTask = changedAutoStart
                            ? componentInstance.ScheduleServerStart(model.AutoStartCron)
                            : ValueTask.CompletedTask;
 
                        var autoStopTask = changedAutoStop
                            ? componentInstance.ScheduleServerStop(model.AutoStopCron)
                            : ValueTask.CompletedTask;
 
                        await ValueTaskExtensions.WhenAll(autoUpdateTask, autoStartTask, autoStopTask);
 
                        return null;
                    },
                    originalModel);
            }
 
            await CheckAccessible(api, cancellationToken);
            return moving ? Accepted(api) : Json(api);
        }
#pragma warning restore CA1502
 
        [HttpGet(Routes.List)]
        [TgsAuthorize(InstanceManagerRights.List | InstanceManagerRights.Read)]
        [ProducesResponseType(typeof(PaginatedResponse<InstanceResponse>), 200)]
        public async ValueTask<IActionResult> List(
            [FromQuery] int? page,
            [FromQuery] int? pageSize,
            CancellationToken cancellationToken)
        {
            IQueryable<Models.Instance> GetBaseQuery()
            {
                var query = DatabaseContext
                    .Instances
                    .Where(x => x.SwarmIdentifer == swarmConfigurationOptions.Value.Identifier);
                if (!AuthenticationContext.PermissionSet.InstanceManagerRights!.Value.HasFlag(InstanceManagerRights.List))
                    query = query
                        .Where(x => x.InstancePermissionSets.Any(y => y.PermissionSetId == AuthenticationContext.PermissionSet.Id))
                        .Where(x => x.InstancePermissionSets.Any(instanceUser =>
                            instanceUser.EngineRights != EngineRights.None ||
                            instanceUser.ChatBotRights != ChatBotRights.None ||
                            instanceUser.ConfigurationRights != ConfigurationRights.None ||
                            instanceUser.DreamDaemonRights != DreamDaemonRights.None ||
                            instanceUser.DreamMakerRights != DreamMakerRights.None ||
                            instanceUser.InstancePermissionSetRights != InstancePermissionSetRights.None));
 
                // Hack for EF IAsyncEnumerable BS
                return query.Select(x => x);
            }
 
            var moveJobs = await GetBaseQuery()
                .SelectMany(x => x.Jobs)
                .Where(x => !x.StoppedAt.HasValue && x.JobCode == JobCode.Move)
                .Include(x => x.StartedBy!)
                    .ThenInclude(x => x.CreatedBy)
                .Include(x => x.Instance)
                .ToListAsync(cancellationToken);
 
            var needsUpdate = false;
            var result = await Paginated<Models.Instance, InstanceResponse>(
                () => ValueTask.FromResult<PaginatableResult<Models.Instance>?>(
                    new PaginatableResult<Models.Instance>(
                        GetBaseQuery()
                            .OrderBy(x => x.Id))),
                async instance =>
                {
                    needsUpdate |= ValidateInstanceOnlineStatus(instance);
                    instance.MoveJob = moveJobs.FirstOrDefault(x => x.Instance!.Id == instance.Id)?.ToApi();
                    await CheckAccessible(instance, cancellationToken);
                },
                page,
                pageSize,
                cancellationToken);
 
            if (needsUpdate)
                await DatabaseContext.Save(cancellationToken);
 
            return result;
        }
 
        [HttpGet("{id}")]
        [TgsAuthorize(InstanceManagerRights.List | InstanceManagerRights.Read)]
        [ProducesResponseType(typeof(InstanceResponse), 200)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 410)]
        public async ValueTask<IActionResult> GetId(long id, CancellationToken cancellationToken)
        {
            var cantList = !AuthenticationContext.PermissionSet.InstanceManagerRights!.Value.HasFlag(InstanceManagerRights.List);
            IQueryable<Models.Instance> QueryForUser()
            {
                var query = DatabaseContext
                    .Instances
                    .Where(x => x.Id == id && x.SwarmIdentifer == swarmConfigurationOptions.Value.Identifier);
 
                if (cantList)
                    query = query.Include(x => x.InstancePermissionSets);
                return query;
            }
 
            var instance = await QueryForUser().FirstOrDefaultAsync(cancellationToken);
 
            if (instance == null)
                return this.Gone();
 
            if (ValidateInstanceOnlineStatus(instance))
                await DatabaseContext.Save(cancellationToken);
 
            if (cantList && !instance.InstancePermissionSets.Any(instanceUser => instanceUser.PermissionSetId == AuthenticationContext.PermissionSet.Require(x => x.Id)
                && (instanceUser.RepositoryRights != RepositoryRights.None ||
                instanceUser.EngineRights != EngineRights.None ||
                instanceUser.ChatBotRights != ChatBotRights.None ||
                instanceUser.ConfigurationRights != ConfigurationRights.None ||
                instanceUser.DreamDaemonRights != DreamDaemonRights.None ||
                instanceUser.DreamMakerRights != DreamMakerRights.None ||
                instanceUser.InstancePermissionSetRights != InstancePermissionSetRights.None)))
                return Forbid();
 
            var api = instance.ToApi();
 
            var moveJob = await QueryForUser()
                .SelectMany(x => x.Jobs)
                .Where(x => !x.StoppedAt.HasValue && x.JobCode == JobCode.Move)
                .Include(x => x.StartedBy!)
                    .ThenInclude(x => x.CreatedBy)
                .Include(x => x.Instance)
                .FirstOrDefaultAsync(cancellationToken);
            api.MoveJob = moveJob?.ToApi();
            await CheckAccessible(api, cancellationToken);
            return Json(api);
        }
 
        [HttpPatch("{id}")]
        [TgsAuthorize(InstanceManagerRights.GrantPermissions)]
        [ProducesResponseType(204)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 410)]
        public async ValueTask<IActionResult> GrantPermissions(long id, CancellationToken cancellationToken)
        {
            IQueryable<Models.Instance> BaseQuery() => DatabaseContext
                .Instances
                .Where(x => x.Id == id && x.SwarmIdentifer == swarmConfigurationOptions.Value.Identifier);
 
            // ensure the current user has write privilege on the instance
            var usersInstancePermissionSet = await BaseQuery()
                .SelectMany(x => x.InstancePermissionSets)
                .Where(x => x.PermissionSetId == AuthenticationContext.PermissionSet.Id)
                .FirstOrDefaultAsync(cancellationToken);
            if (usersInstancePermissionSet == default)
            {
                // does the instance actually exist?
                var instanceExists = await BaseQuery()
                    .AnyAsync(cancellationToken);
 
                if (!instanceExists)
                    return this.Gone();
 
                var instanceAdminUser = InstanceAdminPermissionSet(null);
                instanceAdminUser.InstanceId = id;
                DatabaseContext.InstancePermissionSets.Add(instanceAdminUser);
            }
            else
                InstanceAdminPermissionSet(usersInstancePermissionSet);
 
            await DatabaseContext.Save(cancellationToken);
 
            return NoContent();
        }
 
        async ValueTask<Models.Instance?> CreateDefaultInstance(InstanceCreateRequest initialSettings, CancellationToken cancellationToken)
        {
            var ddPort = await portAllocator.GetAvailablePort(1024, false, cancellationToken);
            if (!ddPort.HasValue)
                return null;
 
            // try to use the old default if possible
            const ushort DefaultDreamDaemonPort = 1337;
            if (ddPort.Value < DefaultDreamDaemonPort)
                ddPort = await portAllocator.GetAvailablePort(DefaultDreamDaemonPort, false, cancellationToken) ?? ddPort;
 
            const ushort DefaultApiValidationPort = 1339;
            var dmPort = await portAllocator
                .GetAvailablePort(
                    Math.Min((ushort)(ddPort.Value + 1), DefaultApiValidationPort),
                    false,
                    cancellationToken);
            if (!dmPort.HasValue)
                return null;
 
            // try to use the old default if possible
            if (dmPort < DefaultApiValidationPort)
                dmPort = await portAllocator.GetAvailablePort(DefaultApiValidationPort, false, cancellationToken) ?? dmPort;
 
            return new Models.Instance
            {
                ConfigurationType = initialSettings.ConfigurationType ?? ConfigurationType.Disallowed,
                DreamDaemonSettings = new DreamDaemonSettings
                {
                    AllowWebClient = false,
                    AutoStart = false,
                    Port = ddPort,
                    OpenDreamTopicPort = 0,
                    SecurityLevel = DreamDaemonSecurity.Safe,
                    Visibility = DreamDaemonVisibility.Public,
                    StartupTimeout = 60,
                    HealthCheckSeconds = 60,
                    DumpOnHealthCheckRestart = false,
                    TopicRequestTimeout = generalConfigurationOptions.Value.ByondTopicTimeout,
                    AdditionalParameters = String.Empty,
                    StartProfiler = false,
                    LogOutput = false,
                    MapThreads = 0,
                    Minidumps = true,
                },
                DreamMakerSettings = new DreamMakerSettings
                {
                    ApiValidationPort = dmPort,
                    ApiValidationSecurityLevel = DreamDaemonSecurity.Safe,
                    DMApiValidationMode = DMApiValidationMode.Required,
                    Timeout = TimeSpan.FromHours(1),
                    CompilerAdditionalArguments = null,
                },
                Name = initialSettings.Name,
                Online = false,
                Path = initialSettings.Path,
                AutoUpdateInterval = initialSettings.AutoUpdateInterval ?? 0,
                AutoUpdateCron = initialSettings.AutoUpdateCron ?? String.Empty,
                AutoStartCron = initialSettings.AutoStartCron ?? String.Empty,
                AutoStopCron = initialSettings.AutoStopCron ?? String.Empty,
                ChatBotLimit = initialSettings.ChatBotLimit ?? Models.Instance.DefaultChatBotLimit,
                RepositorySettings = new Models.RepositorySettings
                {
                    CommitterEmail = Components.Repository.Repository.DefaultCommitterEmail,
                    CommitterName = Components.Repository.Repository.DefaultCommitterName,
                    PushTestMergeCommits = false,
                    ShowTestMergeCommitters = false,
                    AutoUpdatesKeepTestMerges = false,
                    AutoUpdatesSynchronize = false,
                    PostTestMergeComment = false,
                    CreateGitHubDeployments = false,
                    UpdateSubmodules = true,
                },
                InstancePermissionSets = new List<InstancePermissionSet> // give this user full privileges on the instance
                {
                    InstanceAdminPermissionSet(null),
                },
                SwarmIdentifer = swarmConfigurationOptions.Value.Identifier,
            };
        }
 
        InstancePermissionSet InstanceAdminPermissionSet(InstancePermissionSet? permissionSetToModify)
        {
            permissionSetToModify ??= new InstancePermissionSet()
            {
                PermissionSet = AuthenticationContext.PermissionSet,
                PermissionSetId = AuthenticationContext.PermissionSet.Require(x => x.Id),
            };
            permissionSetToModify.EngineRights = RightsHelper.AllRights<EngineRights>();
            permissionSetToModify.ChatBotRights = RightsHelper.AllRights<ChatBotRights>();
            permissionSetToModify.ConfigurationRights = RightsHelper.AllRights<ConfigurationRights>();
            permissionSetToModify.DreamDaemonRights = RightsHelper.AllRights<DreamDaemonRights>();
            permissionSetToModify.DreamMakerRights = RightsHelper.AllRights<DreamMakerRights>();
            permissionSetToModify.RepositoryRights = RightsHelper.AllRights<RepositoryRights>();
            permissionSetToModify.InstancePermissionSetRights = RightsHelper.AllRights<InstancePermissionSetRights>();
            return permissionSetToModify;
        }
 
        [return: NotNullIfNotNull(nameof(path))]
        string? NormalizePath(string? path)
        {
            if (path == null)
                return null;
 
            path = ioManager.ResolvePath(path);
            path = platformIdentifier.NormalizePath(path);
 
            return path;
        }
 
        async ValueTask CheckAccessible(InstanceResponse instanceResponse, CancellationToken cancellationToken)
        {
            instanceResponse.Accessible = await DatabaseContext
                .InstancePermissionSets
                .Where(x => x.InstanceId == instanceResponse.Id && x.PermissionSetId == AuthenticationContext.PermissionSet.Id)
                .AnyAsync(cancellationToken);
        }
 
        BadRequestObjectResult? ValidateCronSetting(Api.Models.Instance instance)
        {
            if (!String.IsNullOrWhiteSpace(instance.AutoUpdateCron))
            {
                if ((instance.AutoUpdateInterval.HasValue && instance.AutoUpdateInterval.Value != 0)
                   || (CrontabSchedule.TryParse(
                       instance.AutoUpdateCron,
                       new CrontabSchedule.ParseOptions
                       {
                           IncludingSeconds = true,
                       }) == null))
                    return BadRequest(new ErrorMessageResponse(ErrorCode.ModelValidationFailure));
 
                instance.AutoUpdateInterval = 0;
            }
            else
                instance.AutoUpdateCron = String.Empty;
 
            return null;
        }
    }
}