DreamMakerController.cs

Go to the documentation of this file.

using System;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
 
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
 
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.Host.Components;
using Tgstation.Server.Host.Controllers.Results;
using Tgstation.Server.Host.Database;
using Tgstation.Server.Host.Extensions;
using Tgstation.Server.Host.Jobs;
using Tgstation.Server.Host.Models;
using Tgstation.Server.Host.Security;
using Tgstation.Server.Host.Utils;
 
namespace Tgstation.Server.Host.Controllers
{
    [Route(Routes.DreamMaker)]
    public sealed class DreamMakerController : InstanceRequiredController
    {
        readonly IJobManager jobManager;
 
        readonly IPortAllocator portAllocator;
 
        public DreamMakerController(
            IDatabaseContext databaseContext,
            IAuthenticationContext authenticationContext,
            ILogger<DreamMakerController> logger,
            IInstanceManager instanceManager,
            IJobManager jobManager,
            IPortAllocator portAllocator,
            IApiHeadersProvider apiHeaders)
            : base(
                  databaseContext,
                  authenticationContext,
                  logger,
                  instanceManager,
                  apiHeaders)
        {
            this.jobManager = jobManager ?? throw new ArgumentNullException(nameof(jobManager));
            this.portAllocator = portAllocator ?? throw new ArgumentNullException(nameof(portAllocator));
        }
 
        [HttpGet]
        [TgsAuthorize(DreamMakerRights.Read)]
        [ProducesResponseType(typeof(DreamMakerResponse), 200)]
        public async ValueTask<IActionResult> Read(CancellationToken cancellationToken)
        {
            var dreamMakerSettings = await DatabaseContext
                .DreamMakerSettings
                .AsQueryable()
                .Where(x => x.InstanceId == Instance.Id)
                .FirstOrDefaultAsync(cancellationToken);
 
            if (dreamMakerSettings == null)
                return this.Gone();
 
            return Json(dreamMakerSettings.ToApi());
        }
 
        [HttpGet("{id}")]
        [TgsAuthorize(DreamMakerRights.CompileJobs)]
        [ProducesResponseType(typeof(CompileJobResponse), 200)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 404)]
        public async ValueTask<IActionResult> GetId(long id, CancellationToken cancellationToken)
        {
            var compileJob = await BaseCompileJobsQuery()
                .Where(x => x.Id == id)
                .FirstOrDefaultAsync(cancellationToken);
            if (compileJob == default)
                return NotFound();
            return Json(compileJob.ToApi());
        }
 
        [HttpGet(Routes.List)]
        [TgsAuthorize(DreamMakerRights.CompileJobs)]
        [ProducesResponseType(typeof(PaginatedResponse<CompileJobResponse>), 200)]
        public ValueTask<IActionResult> List([FromQuery] int? page, [FromQuery] int? pageSize, CancellationToken cancellationToken)
            => Paginated<CompileJob, CompileJobResponse>(
                () => ValueTask.FromResult(
                    new PaginatableResult<CompileJob>(
                        BaseCompileJobsQuery()
                            .OrderByDescending(x => x.Job.StoppedAt))),
                null,
                page,
                pageSize,
                cancellationToken);
 
        [HttpPut]
        [TgsAuthorize(DreamMakerRights.Compile)]
        [ProducesResponseType(typeof(JobResponse), 202)]
        public async ValueTask<IActionResult> Create(CancellationToken cancellationToken)
        {
            var job = Job.Create(JobCode.Deployment, AuthenticationContext.User, Instance, DreamMakerRights.CancelCompile);
 
            await jobManager.RegisterOperation(
                job,
                (core, databaseContextFactory, paramJob, progressReporter, jobCancellationToken)
                    => core!.DreamMaker.DeploymentProcess(paramJob, databaseContextFactory, progressReporter, jobCancellationToken),
                cancellationToken);
            return Accepted(job.ToApi());
        }
 
        [HttpPost]
        [TgsAuthorize(
            DreamMakerRights.SetDme
            | DreamMakerRights.SetApiValidationPort
            | DreamMakerRights.SetSecurityLevel
            | DreamMakerRights.SetApiValidationRequirement
            | DreamMakerRights.SetTimeout
            | DreamMakerRights.SetCompilerArguments)]
        [ProducesResponseType(typeof(DreamMakerResponse), 200)]
        [ProducesResponseType(204)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 410)]
#pragma warning disable CA1506 // TODO: Decomplexify
        public async ValueTask<IActionResult> Update([FromBody] DreamMakerRequest model, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(model);
 
            if (model.ApiValidationPort == 0)
                throw new InvalidOperationException("ApiValidationPort cannot be 0!");
 
            var hostModel = await DatabaseContext
                .DreamMakerSettings
                .AsQueryable()
                .Where(x => x.InstanceId == Instance.Id)
                .FirstOrDefaultAsync(cancellationToken);
            if (hostModel == null)
                return this.Gone();
 
            var dreamMakerRights = InstancePermissionSet.DreamMakerRights!.Value;
            if (model.ProjectName != null)
            {
                if (!dreamMakerRights.HasFlag(DreamMakerRights.SetDme))
                    return Forbid();
 
                if (model.ProjectName.Length == 0) // can't use isnullorwhitespace because linux memes
                    hostModel.ProjectName = null;
                else
                    hostModel.ProjectName = model.ProjectName;
            }
 
            if (model.ApiValidationPort.HasValue)
            {
                if (!dreamMakerRights.HasFlag(DreamMakerRights.SetApiValidationPort))
                    return Forbid();
 
                if (model.ApiValidationPort.Value != hostModel.ApiValidationPort!.Value)
                {
                    Logger.LogTrace(
                        "Triggering port allocator for DM-I:{instanceId} because model port {modelPort} doesn't match DB port {dbPort}...",
                        Instance.Id,
                        model.ApiValidationPort,
                        hostModel.ApiValidationPort);
                    var verifiedPort = await portAllocator
                        .GetAvailablePort(
                            model.ApiValidationPort.Value,
                            true,
                            cancellationToken);
                    if (verifiedPort != model.ApiValidationPort)
                        return Conflict(new ErrorMessageResponse(ErrorCode.PortNotAvailable));
 
                    hostModel.ApiValidationPort = model.ApiValidationPort;
                }
            }
 
            if (model.ApiValidationSecurityLevel.HasValue)
            {
                if (!dreamMakerRights.HasFlag(DreamMakerRights.SetSecurityLevel))
                    return Forbid();
 
                hostModel.ApiValidationSecurityLevel = model.ApiValidationSecurityLevel;
            }
 
#pragma warning disable CS0618 // Type or member is obsolete
            bool? legacyRequireDMApiValidation = model.RequireDMApiValidation;
#pragma warning restore CS0618 // Type or member is obsolete
            if (legacyRequireDMApiValidation.HasValue)
            {
                if (!dreamMakerRights.HasFlag(DreamMakerRights.SetApiValidationRequirement))
                    return Forbid();
 
                hostModel.DMApiValidationMode = legacyRequireDMApiValidation.Value
                    ? DMApiValidationMode.Required
                    : DMApiValidationMode.Optional;
            }
 
            if (model.DMApiValidationMode.HasValue)
            {
                if (legacyRequireDMApiValidation.HasValue)
                    return BadRequest(new ErrorMessageResponse(ErrorCode.ModelValidationFailure));
 
                if (!dreamMakerRights.HasFlag(DreamMakerRights.SetApiValidationRequirement))
                    return Forbid();
 
                hostModel.DMApiValidationMode = model.DMApiValidationMode;
            }
 
            if (model.Timeout.HasValue)
            {
                if (!dreamMakerRights.HasFlag(DreamMakerRights.SetTimeout))
                    return Forbid();
 
                hostModel.Timeout = model.Timeout;
            }
 
            if (model.CompilerAdditionalArguments != null)
            {
                if (!dreamMakerRights.HasFlag(DreamMakerRights.SetCompilerArguments))
                    return Forbid();
 
                var sanitizedArguments = model.CompilerAdditionalArguments.Trim();
                if (sanitizedArguments.Length == 0)
                    hostModel.CompilerAdditionalArguments = null;
                else
                    hostModel.CompilerAdditionalArguments = sanitizedArguments;
            }
 
            await DatabaseContext.Save(cancellationToken);
 
            if (!dreamMakerRights.HasFlag(DreamMakerRights.Read))
                return NoContent();
 
            return await Read(cancellationToken);
        }
#pragma warning restore CA1506
 
        IQueryable<CompileJob> BaseCompileJobsQuery() => DatabaseContext
            .CompileJobs
            .AsQueryable()
            .Include(x => x.Job!)
                .ThenInclude(x => x.StartedBy)
            .Include(x => x.Job!)
                .ThenInclude(x => x.Instance)
            .Include(x => x.RevisionInformation!)
                .ThenInclude(x => x.PrimaryTestMerge!)
                    .ThenInclude(x => x.MergedBy)
            .Include(x => x.RevisionInformation)
                .ThenInclude(x => x.ActiveTestMerges!)
                    .ThenInclude(x => x!.TestMerge)
                        .ThenInclude(x => x!.MergedBy)
            .Where(x => x.Job.Instance!.Id == Instance.Id);
    }
}