ComponentInterfacingController.cs

Go to the documentation of this file.

using System;
using System.Threading;
using System.Threading.Tasks;
 
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Serilog.Context;
 
using Tgstation.Server.Api.Models;
using Tgstation.Server.Api.Models.Response;
using Tgstation.Server.Host.Components;
using Tgstation.Server.Host.Database;
using Tgstation.Server.Host.Extensions;
using Tgstation.Server.Host.Models;
using Tgstation.Server.Host.Security;
using Tgstation.Server.Host.Utils;
 
namespace Tgstation.Server.Host.Controllers
{
    public abstract class ComponentInterfacingController : ApiController
    {
        public IInstanceOperations InstanceOperations => instanceManager;
 
        readonly IInstanceManager instanceManager;
 
        readonly bool useInstanceRequestHeader;
 
        protected ComponentInterfacingController(
            IDatabaseContext databaseContext,
            IAuthenticationContext authenticationContext,
            ILogger<ComponentInterfacingController> logger,
            IInstanceManager instanceManager,
            IApiHeadersProvider apiHeaders,
            bool useInstanceRequestHeader)
            : base(
                  databaseContext,
                  authenticationContext,
                  apiHeaders,
                  logger,
                  true)
        {
            this.instanceManager = instanceManager ?? throw new ArgumentNullException(nameof(instanceManager));
            this.useInstanceRequestHeader = useInstanceRequestHeader;
        }
 
        protected override async ValueTask<IActionResult?> ValidateRequest(CancellationToken cancellationToken)
        {
            if (!useInstanceRequestHeader)
                return null;
 
            if (!ApiHeaders!.InstanceId.HasValue)
                return BadRequest(new ErrorMessageResponse(ErrorCode.InstanceHeaderRequired));
 
            if (AuthenticationContext.InstancePermissionSet == null)
                return Forbid();
 
            var instance = Instance!;
            if (ValidateInstanceOnlineStatus(instance))
                await DatabaseContext.Save(cancellationToken);
 
            using var instanceReferenceCheck = instanceManager.GetInstanceReference(instance);
            if (instanceReferenceCheck == null)
                return Conflict(new ErrorMessageResponse(ErrorCode.InstanceOffline));
 
            return null;
        }
 
        protected bool ValidateInstanceOnlineStatus(Api.Models.Instance metadata)
        {
            ArgumentNullException.ThrowIfNull(metadata);
 
            bool online;
            using (var instanceReferenceCheck = instanceManager.GetInstanceReference(metadata))
                online = instanceReferenceCheck != null;
 
            if (metadata.Require(x => x.Online) == online)
                return false;
 
            const string OfflineWord = "offline";
            const string OnlineWord = "online";
 
            Logger.LogWarning(
                "Instance {instanceId} is says it's {databaseState} in the database, but it is actually {serviceState} in the service. Updating the database to reflect this...",
                metadata.Id,
                online ? OfflineWord : OnlineWord,
                online ? OnlineWord : OfflineWord);
 
            metadata.Online = online;
            return true;
        }
 
        protected async ValueTask<IActionResult?> WithComponentInstanceNullable(Func<IInstanceCore, ValueTask<IActionResult?>> action, Models.Instance? instance = null)
        {
            ArgumentNullException.ThrowIfNull(action);
 
            instance ??= Instance ?? throw new InvalidOperationException("ComponentInterfacingController has no Instance!");
 
            using var instanceReference = instanceManager.GetInstanceReference(instance);
            using (LogContext.PushProperty(SerilogContextHelper.InstanceReferenceContextProperty, instanceReference?.Uid))
            {
                if (instanceReference == null)
                    return Conflict(new ErrorMessageResponse(ErrorCode.InstanceOffline));
                return await action(instanceReference);
            }
        }
 
        protected async ValueTask<IActionResult> WithComponentInstance(Func<IInstanceCore, ValueTask<IActionResult>> action, Models.Instance? instance = null)
            => (await WithComponentInstanceNullable(async core => await action(core), instance))!;
    }
}