AdministrationController.cs

Go to the documentation of this file.

using System;
using System.IO;
using System.Linq;
using System.Net;
using System.Threading;
using System.Threading.Tasks;
using System.Web;
 
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
 
using Octokit;
 
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.Configuration;
using Tgstation.Server.Host.Core;
using Tgstation.Server.Host.Database;
using Tgstation.Server.Host.Extensions;
using Tgstation.Server.Host.IO;
using Tgstation.Server.Host.Security;
using Tgstation.Server.Host.System;
using Tgstation.Server.Host.Transfer;
using Tgstation.Server.Host.Utils.GitHub;
 
namespace Tgstation.Server.Host.Controllers
{
    [Route(Routes.Administration)]
    public sealed class AdministrationController : ApiController
    {
        const string OctokitException = "Bad GitHub API response, check configuration!";
 
        readonly IGitHubService gitHubService;
 
        readonly IServerControl serverControl;
 
        readonly IServerUpdateInitiator serverUpdateInitiator;
 
        readonly IAssemblyInformationProvider assemblyInformationProvider;
 
        readonly IIOManager ioManager;
 
        readonly IPlatformIdentifier platformIdentifier;
 
        readonly IFileTransferTicketProvider fileTransferService;
 
        readonly FileLoggingConfiguration fileLoggingConfiguration;
 
        public AdministrationController(
            IDatabaseContext databaseContext,
            IAuthenticationContextFactory authenticationContextFactory,
            IGitHubService gitHubService,
            IServerControl serverControl,
            IServerUpdateInitiator serverUpdateInitiator,
            IAssemblyInformationProvider assemblyInformationProvider,
            IIOManager ioManager,
            IPlatformIdentifier platformIdentifier,
            IFileTransferTicketProvider fileTransferService,
            ILogger<AdministrationController> logger,
            IOptions<FileLoggingConfiguration> fileLoggingConfigurationOptions)
            : base(
                databaseContext,
                authenticationContextFactory,
                logger,
                true)
        {
            this.gitHubService = gitHubService ?? throw new ArgumentNullException(nameof(gitHubService));
            this.serverControl = serverControl ?? throw new ArgumentNullException(nameof(serverControl));
            this.serverUpdateInitiator = serverUpdateInitiator ?? throw new ArgumentNullException(nameof(serverUpdateInitiator));
            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.fileTransferService = fileTransferService ?? throw new ArgumentNullException(nameof(fileTransferService));
            fileLoggingConfiguration = fileLoggingConfigurationOptions?.Value ?? throw new ArgumentNullException(nameof(fileLoggingConfigurationOptions));
        }
 
        [HttpGet]
        [TgsAuthorize(AdministrationRights.ChangeVersion)]
        [ProducesResponseType(typeof(AdministrationResponse), 200)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 424)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 429)]
        public async Task<IActionResult> Read(CancellationToken cancellationToken)
        {
            try
            {
                Version greatestVersion = null;
                Uri repoUrl = null;
                try
                {
                    var repositoryUrlTask = gitHubService.GetUpdatesRepositoryUrl(cancellationToken);
                    var releases = await gitHubService.GetTgsReleases(cancellationToken);
 
                    foreach (var kvp in releases)
                    {
                        var version = kvp.Key;
                        var release = kvp.Value;
                        if (version.Major > 3 // Forward/backward compatible but not before TGS4
                            && (greatestVersion == null || version > greatestVersion))
                            greatestVersion = version;
                    }
 
                    repoUrl = await repositoryUrlTask;
                }
                catch (NotFoundException e)
                {
                    Logger.LogWarning(e, "Not found exception while retrieving upstream repository info!");
                }
 
                return Json(new AdministrationResponse
                {
                    LatestVersion = greatestVersion,
                    TrackedRepositoryUrl = repoUrl,
                });
            }
            catch (RateLimitExceededException e)
            {
                return RateLimit(e);
            }
            catch (ApiException e)
            {
                Logger.LogWarning(e, OctokitException);
                return this.StatusCode(HttpStatusCode.FailedDependency, new ErrorMessageResponse(ErrorCode.RemoteApiError)
                {
                    AdditionalData = e.Message,
                });
            }
        }
 
        [HttpPost]
        [TgsAuthorize(AdministrationRights.ChangeVersion | AdministrationRights.UploadVersion)]
        [ProducesResponseType(typeof(ServerUpdateResponse), 202)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 410)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 422)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 424)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 429)]
        public async Task<IActionResult> Update([FromBody] ServerUpdateRequest model, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(model);
 
            var attemptingUpload = model.UploadZip == true;
            if (attemptingUpload)
            {
                if (!AuthenticationContext.PermissionSet.AdministrationRights.Value.HasFlag(AdministrationRights.UploadVersion))
                    return Forbid();
            }
            else if (!AuthenticationContext.PermissionSet.AdministrationRights.Value.HasFlag(AdministrationRights.ChangeVersion))
                return Forbid();
 
            if (model.NewVersion == null)
                return BadRequest(new ErrorMessageResponse(ErrorCode.ModelValidationFailure)
                {
                    AdditionalData = "newVersion is required!",
                });
 
            if (model.NewVersion.Major < 3)
                return BadRequest(new ErrorMessageResponse(ErrorCode.CannotChangeServerSuite));
 
            if (!serverControl.WatchdogPresent)
                return UnprocessableEntity(new ErrorMessageResponse(ErrorCode.MissingHostWatchdog));
 
            return await AttemptInitiateUpdate(model.NewVersion, attemptingUpload, cancellationToken);
        }
 
        [HttpDelete]
        [TgsAuthorize(AdministrationRights.RestartHost)]
        [ProducesResponseType(204)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 422)]
        public async Task<IActionResult> Delete()
        {
            try
            {
                if (!serverControl.WatchdogPresent)
                {
                    Logger.LogDebug("Restart request failed due to lack of host watchdog!");
                    return UnprocessableEntity(new ErrorMessageResponse(ErrorCode.MissingHostWatchdog));
                }
 
                await serverControl.Restart();
                return NoContent();
            }
            catch (InvalidOperationException)
            {
                return StatusCode(HttpStatusCode.ServiceUnavailable);
            }
        }
 
        [HttpGet(Routes.Logs)]
        [TgsAuthorize(AdministrationRights.DownloadLogs)]
        [ProducesResponseType(typeof(PaginatedResponse<LogFileResponse>), 200)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 409)]
        public Task<IActionResult> ListLogs([FromQuery] int? page, [FromQuery] int? pageSize, CancellationToken cancellationToken)
            => Paginated(
                async () =>
                {
                    var path = fileLoggingConfiguration.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 async Task<IActionResult> GetLog(string path, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(path);
 
            path = HttpUtility.UrlDecode(path);
 
            // guard against directory navigation
            var sanitizedPath = ioManager.GetFileName(path);
            if (path != sanitizedPath)
                return Forbid();
 
            var fullPath = ioManager.ConcatPath(
                fileLoggingConfiguration.GetFullLogDirectory(ioManager, assemblyInformationProvider, platformIdentifier),
                path);
            try
            {
                var fileTransferTicket = fileTransferService.CreateDownload(
                    new FileDownloadProvider(
                        () => null,
                        null,
                        fullPath,
                        true));
 
                return Ok(new LogFileResponse
                {
                    Name = path,
                    LastModified = await ioManager.GetLastModified(fullPath, cancellationToken),
                    FileTicket = fileTransferTicket.FileTicket,
                });
            }
            catch (IOException ex)
            {
                return Conflict(new ErrorMessageResponse(ErrorCode.IOError)
                {
                    AdditionalData = ex.ToString(),
                });
            }
        }
 
        async Task<IActionResult> AttemptInitiateUpdate(Version newVersion, bool attemptingUpload, CancellationToken cancellationToken)
        {
            IFileUploadTicket uploadTicket = attemptingUpload
                ? fileTransferService.CreateUpload(FileUploadStreamKind.None)
                : null;
 
            ServerUpdateResult updateResult;
            try
            {
                try
                {
                    updateResult = await serverUpdateInitiator.InitiateUpdate(uploadTicket, newVersion, cancellationToken);
                }
                catch
                {
                    if (attemptingUpload)
                        await uploadTicket.DisposeAsync();
 
                    throw;
                }
            }
            catch (RateLimitExceededException e)
            {
                return RateLimit(e);
            }
            catch (ApiException e)
            {
                Logger.LogWarning(e, OctokitException);
                return this.StatusCode(HttpStatusCode.FailedDependency, new ErrorMessageResponse(ErrorCode.RemoteApiError)
                {
                    AdditionalData = e.Message,
                });
            }
 
            return updateResult switch
            {
                ServerUpdateResult.Started => Accepted(new ServerUpdateResponse(newVersion, uploadTicket?.Ticket.FileTicket)),
                ServerUpdateResult.ReleaseMissing => this.Gone(),
                ServerUpdateResult.UpdateInProgress => BadRequest(new ErrorMessageResponse(ErrorCode.ServerUpdateInProgress)),
                ServerUpdateResult.SwarmIntegrityCheckFailed => this.StatusCode(HttpStatusCode.FailedDependency, new ErrorMessageResponse(ErrorCode.SwarmIntegrityCheckFailed)),
                _ => throw new InvalidOperationException($"Unexpected ServerUpdateResult: {updateResult}"),
            };
        }
    }
}