AdministrationController.cs

Go to the documentation of this file.

using System;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
 
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
 
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.Authority;
using Tgstation.Server.Host.Configuration;
using Tgstation.Server.Host.Controllers.Results;
using Tgstation.Server.Host.Database;
using Tgstation.Server.Host.IO;
using Tgstation.Server.Host.Security;
using Tgstation.Server.Host.System;
using Tgstation.Server.Host.Utils;
 
namespace Tgstation.Server.Host.Controllers
{
    [Authorize]
    [Route(Routes.Administration)]
    public sealed class AdministrationController : ApiController
    {
        readonly IRestAuthorityInvoker<IAdministrationAuthority> administrationAuthority;
 
        readonly IAssemblyInformationProvider assemblyInformationProvider;
 
        readonly IIOManager ioManager;
 
        readonly IPlatformIdentifier platformIdentifier;
 
        readonly IOptions<FileLoggingConfiguration> fileLoggingConfigurationOptions;
 
        public AdministrationController(
            IDatabaseContext databaseContext,
            IAuthenticationContext authenticationContext,
            IApiHeadersProvider apiHeadersProvider,
            ILogger<AdministrationController> logger,
            IRestAuthorityInvoker<IAdministrationAuthority> administrationAuthority,
            IAssemblyInformationProvider assemblyInformationProvider,
            IIOManager ioManager,
            IPlatformIdentifier platformIdentifier,
            IOptions<FileLoggingConfiguration> fileLoggingConfigurationOptions)
            : base(
                  databaseContext,
                  authenticationContext,
                  apiHeadersProvider,
                  logger,
                  true)
        {
            this.administrationAuthority = administrationAuthority ?? throw new ArgumentNullException(nameof(administrationAuthority));
            this.assemblyInformationProvider = assemblyInformationProvider ?? throw new ArgumentNullException(nameof(assemblyInformationProvider));
            this.ioManager = ioManager ?? throw new ArgumentNullException(nameof(ioManager));
            this.platformIdentifier = platformIdentifier ?? throw new ArgumentNullException(nameof(platformIdentifier));
            this.fileLoggingConfigurationOptions = fileLoggingConfigurationOptions ?? throw new ArgumentNullException(nameof(fileLoggingConfigurationOptions));
        }
 
        [HttpGet]
        [ProducesResponseType(typeof(AdministrationResponse), 200)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 424)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 429)]
        public ValueTask<IActionResult> Read([FromQuery] bool? fresh, CancellationToken cancellationToken)
            => administrationAuthority.Invoke<AdministrationResponse, AdministrationResponse>(
                this,
                authority => authority.GetUpdateInformation(fresh ?? false, cancellationToken));
 
        [HttpPost]
        [ProducesResponseType(typeof(ServerUpdateResponse), 202)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 410)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 422)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 424)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 429)]
        public async ValueTask<IActionResult> Update([FromBody] ServerUpdateRequest model, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(model);
 
            if (model.NewVersion == null)
                return BadRequest(new ErrorMessageResponse(ErrorCode.ModelValidationFailure)
                {
                    AdditionalData = "newVersion is required!",
                });
 
            return await administrationAuthority.Invoke<ServerUpdateResponse, ServerUpdateResponse>(
                this,
                authority => authority.TriggerServerVersionChange(model.NewVersion, model.UploadZip ?? false, cancellationToken));
        }
 
        [HttpDelete]
        [ProducesResponseType(204)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 422)]
        public ValueTask<IActionResult> Delete()
#pragma warning disable API1001 // Action returns undeclared success result
            => administrationAuthority.Invoke(
                this,
                authority => authority.TriggerServerRestart());
#pragma warning restore API1001 // Action returns undeclared success result
 
        [HttpGet(Routes.Logs)]
        [TgsAuthorize(AdministrationRights.DownloadLogs)]
        [ProducesResponseType(typeof(PaginatedResponse<LogFileResponse>), 200)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 409)]
        public ValueTask<IActionResult> ListLogs([FromQuery] int? page, [FromQuery] int? pageSize, CancellationToken cancellationToken)
            => Paginated(
                async () =>
                {
                    var path = fileLoggingConfigurationOptions.Value.GetFullLogDirectory(ioManager, assemblyInformationProvider, platformIdentifier);
                    try
                    {
                        var files = await ioManager.GetFiles(path, cancellationToken);
                        var tasks = files.Select(
                            async file => new LogFileResponse
                            {
                                Name = ioManager.GetFileName(file),
                                LastModified = await ioManager
                                    .GetLastModified(
                                        ioManager.ConcatPath(path, file),
                                        cancellationToken),
                            })
                            .ToList();
 
                        await Task.WhenAll(tasks);
 
                        return new PaginatableResult<LogFileResponse>(
                            tasks
                                .AsQueryable()
                                .Select(x => x.Result)
                                .OrderByDescending(x => x.Name));
                    }
                    catch (IOException ex)
                    {
                        return new PaginatableResult<LogFileResponse>(
                            Conflict(new ErrorMessageResponse(ErrorCode.IOError)
                            {
                                AdditionalData = ex.ToString(),
                            }));
                    }
                },
                null,
                page,
                pageSize,
                cancellationToken);
 
        [HttpGet(Routes.Logs + "/{*path}")]
        [TgsAuthorize(AdministrationRights.DownloadLogs)]
        [ProducesResponseType(typeof(LogFileResponse), 200)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 409)]
        public ValueTask<IActionResult> GetLog(string path, CancellationToken cancellationToken)
            => administrationAuthority.Invoke<LogFileResponse, LogFileResponse>(
                this,
                authority => authority.GetLog(path, cancellationToken));
    }
}