SwarmController.cs

Go to the documentation of this file.

using System;
using System.Linq;
using System.Net;
using System.Net.Mime;
using System.Threading;
using System.Threading.Tasks;
 
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
 
using Serilog.Context;
 
using Tgstation.Server.Host.Configuration;
using Tgstation.Server.Host.Extensions;
using Tgstation.Server.Host.Properties;
using Tgstation.Server.Host.Swarm;
using Tgstation.Server.Host.Transfer;
using Tgstation.Server.Host.Utils;
 
namespace Tgstation.Server.Host.Controllers
{
    [Route(SwarmConstants.ControllerRoute)]
    [ApiExplorerSettings(IgnoreApi = true)]
    [AllowAnonymous] // We have custom private key auth
    public sealed class SwarmController : ApiControllerBase
    {
        internal Guid RequestRegistrationId => Guid.Parse(Request.Headers[SwarmConstants.RegistrationIdHeader].First()!);
 
        readonly ISwarmOperations swarmOperations;
 
        readonly IFileTransferStreamHandler transferService;
 
        readonly ILogger<SwarmController> logger;
 
        readonly SwarmConfiguration swarmConfiguration;
 
        public SwarmController(
            ISwarmOperations swarmOperations,
            IFileTransferStreamHandler transferService,
            IOptions<SwarmConfiguration> swarmConfigurationOptions,
            ILogger<SwarmController> logger)
        {
            this.swarmOperations = swarmOperations ?? throw new ArgumentNullException(nameof(swarmOperations));
            this.transferService = transferService ?? throw new ArgumentNullException(nameof(transferService));
            swarmConfiguration = swarmConfigurationOptions?.Value ?? throw new ArgumentNullException(nameof(swarmConfigurationOptions));
            this.logger = logger;
        }
 
        [HttpPost(SwarmConstants.RegisterRoute)]
        public async ValueTask<IActionResult> Register([FromBody] SwarmRegistrationRequest registrationRequest, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(registrationRequest);
 
            var swarmProtocolVersion = Version.Parse(MasterVersionsAttribute.Instance.RawSwarmProtocolVersion);
            if (registrationRequest.ServerVersion?.Major != swarmProtocolVersion.Major)
                return StatusCode((int)HttpStatusCode.UpgradeRequired);
 
            var registrationResult = await swarmOperations.RegisterNode(registrationRequest, RequestRegistrationId, cancellationToken);
            if (registrationResult == null)
                return Conflict();
 
            if (registrationRequest.ServerVersion != swarmProtocolVersion)
                logger.LogWarning("Allowed node {identifier} to register despite having a slightly different swarm protocol version!", registrationRequest.Identifier);
 
            return Json(registrationResult);
        }
 
        [HttpDelete(SwarmConstants.RegisterRoute)]
        public async ValueTask<IActionResult> UnregisterNode(CancellationToken cancellationToken)
        {
            if (!ValidateRegistration())
                return Forbid();
 
            await swarmOperations.UnregisterNode(RequestRegistrationId, cancellationToken);
            return NoContent();
        }
 
        [HttpGet]
        public IActionResult HealthCheck()
        {
            if (!ValidateRegistration())
                return Forbid();
 
            return NoContent();
        }
 
        [HttpGet(SwarmConstants.UpdateRoute)]
        [Produces(MediaTypeNames.Application.Octet)]
        public ValueTask<IActionResult> GetUpdatePackage([FromQuery] string ticket, CancellationToken cancellationToken)
            => transferService.GenerateDownloadResponse(this, ticket, cancellationToken);
 
        [HttpPost]
        public IActionResult UpdateNodeList([FromBody] SwarmServersUpdateRequest serversUpdateRequest)
        {
            ArgumentNullException.ThrowIfNull(serversUpdateRequest);
 
            if (serversUpdateRequest.SwarmServers == null)
                return BadRequest();
 
            if (!ValidateRegistration())
                return Forbid();
 
            swarmOperations.UpdateSwarmServersList(serversUpdateRequest.SwarmServers);
            return NoContent();
        }
 
        [HttpPut(SwarmConstants.UpdateRoute)]
        public async ValueTask<IActionResult> PrepareUpdate([FromBody] SwarmUpdateRequest updateRequest, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(updateRequest);
 
            if (!ValidateRegistration())
                return Forbid();
 
            var prepareResult = await swarmOperations.PrepareUpdateFromController(updateRequest, cancellationToken);
            if (!prepareResult)
                return Conflict();
 
            return NoContent();
        }
 
        [HttpPost(SwarmConstants.UpdateRoute)]
        public async ValueTask<IActionResult> CommitUpdate(CancellationToken cancellationToken)
        {
            if (!ValidateRegistration())
                return Forbid();
 
            var result = await swarmOperations.RemoteCommitReceived(RequestRegistrationId, cancellationToken);
            if (!result)
                return Conflict();
            return NoContent();
        }
 
        [HttpDelete(SwarmConstants.UpdateRoute)]
        public async ValueTask<IActionResult> AbortUpdate()
        {
            if (!ValidateRegistration())
                return Forbid();
 
            await swarmOperations.AbortUpdate();
            return NoContent();
        }
 
        protected override async ValueTask<IActionResult?> HookExecuteAction(Func<Task> executeAction, CancellationToken cancellationToken)
        {
            using (LogContext.PushProperty(SerilogContextHelper.RequestPathContextProperty, $"{Request.Method} {Request.Path}"))
            {
                logger.LogTrace("Swarm request from {remoteIP}...", Request.HttpContext.Connection.RemoteIpAddress);
                if (swarmConfiguration.PrivateKey == null)
                {
                    logger.LogDebug("Attempted swarm request without private key configured!");
                    return Forbid();
                }
 
                if (!(Request.Headers.TryGetValue(SwarmConstants.ApiKeyHeader, out var apiKeyHeaderValues)
                    && apiKeyHeaderValues.Count == 1
                    && apiKeyHeaderValues.First() == swarmConfiguration.PrivateKey))
                {
                    logger.LogDebug("Unauthorized swarm request!");
                    return Unauthorized();
                }
 
                if (!(Request.Headers.TryGetValue(SwarmConstants.RegistrationIdHeader, out var registrationHeaderValues)
                    && registrationHeaderValues.Count == 1
                    && Guid.TryParse(registrationHeaderValues.First(), out var registrationId)))
                {
                    logger.LogDebug("Swarm request without registration ID!");
                    return BadRequest();
                }
 
                // we validate the registration itself on a case-by-case basis
                if (ModelState?.IsValid == false)
                {
                    var errorMessages = ModelState
                        .SelectMany(x => x.Value!.Errors)
                        .Select(x => x.ErrorMessage);
 
                    logger.LogDebug(
                        "Swarm request model validation failed!{newLine}{messages}",
                        Environment.NewLine,
                        String.Join(Environment.NewLine, errorMessages));
                    return BadRequest();
                }
 
                logger.LogTrace("Starting swarm request processing...");
                await executeAction();
                return null;
            }
        }
 
        bool ValidateRegistration() => swarmOperations.ValidateRegistration(RequestRegistrationId);
    }
}