AdministrationController.cs

Go to the documentation of this file.

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Microsoft.Extensions.Primitives;
using Octokit;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Net;
using System.Threading;
using System.Threading.Tasks;
using Tgstation.Server.Api;
using Tgstation.Server.Api.Models;
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;

namespace Tgstation.Server.Host.Controllers
{
    [Route(Routes.Administration)]
    public sealed class AdministrationController : ApiController
    {
        const string OctokitException = "Bad GitHub API response, check configuration! Exception: {0}";

        readonly IGitHubClientFactory gitHubClientFactory;

        readonly IServerControl serverUpdater;

        readonly IAssemblyInformationProvider assemblyInformationProvider;

        readonly IIOManager ioManager;

        readonly IPlatformIdentifier platformIdentifier;

        readonly UpdatesConfiguration updatesConfiguration;

        readonly GeneralConfiguration generalConfiguration;

        public AdministrationController(
            IDatabaseContext databaseContext,
            IAuthenticationContextFactory authenticationContextFactory,
            IGitHubClientFactory gitHubClientFactory,
            IServerControl serverUpdater,
            IAssemblyInformationProvider assemblyInformationProvider,
            IIOManager ioManager,
            IPlatformIdentifier platformIdentifier,
            ILogger<AdministrationController> logger,
            IOptions<UpdatesConfiguration> updatesConfigurationOptions,
            IOptions<GeneralConfiguration> generalConfigurationOptions)
            : base(
                databaseContext,
                authenticationContextFactory,
                logger,
                false,
                true)
        {
            this.gitHubClientFactory = gitHubClientFactory ?? throw new ArgumentNullException(nameof(gitHubClientFactory));
            this.serverUpdater = serverUpdater ?? throw new ArgumentNullException(nameof(serverUpdater));
            this.assemblyInformationProvider = assemblyInformationProvider ?? throw new ArgumentNullException(nameof(assemblyInformationProvider));
            this.ioManager = ioManager ?? throw new ArgumentNullException(nameof(ioManager));
            this.platformIdentifier = platformIdentifier ?? throw new ArgumentNullException(nameof(platformIdentifier));
            updatesConfiguration = updatesConfigurationOptions?.Value ?? throw new ArgumentNullException(nameof(updatesConfigurationOptions));
            generalConfiguration = generalConfigurationOptions?.Value ?? throw new ArgumentNullException(nameof(generalConfigurationOptions));
        }

        StatusCodeResult RateLimit(RateLimitExceededException exception)
        {
            Logger.LogWarning("Exceeded GitHub rate limit! Exception {0}", exception);
            var secondsString = Math.Ceiling((exception.Reset - DateTimeOffset.Now).TotalSeconds).ToString(CultureInfo.InvariantCulture);
            Response.Headers.Add("Retry-After", new StringValues(secondsString));
            return StatusCode(429);
        }

        async Task<IActionResult> CheckReleasesAndApplyUpdate(Version newVersion, CancellationToken cancellationToken)
        {
            Logger.LogDebug("Looking for GitHub releases version {0}...", newVersion);
            IEnumerable<Release> releases;
            try
            {
                var gitHubClient = GetGitHubClient();
                releases = await gitHubClient
                    .Repository
                    .Release
                    .GetAll(updatesConfiguration.GitHubRepositoryId)
                    .WithToken(cancellationToken)
                    .ConfigureAwait(false);
            }
            catch (RateLimitExceededException e)
            {
                return RateLimit(e);
            }
            catch (ApiException e)
            {
                Logger.LogWarning(OctokitException, e);
                return StatusCode((int)HttpStatusCode.FailedDependency);
            }

            releases = releases.Where(x => x.TagName.StartsWith(updatesConfiguration.GitTagPrefix, StringComparison.InvariantCulture));

            Logger.LogTrace("Release query complete!");

            foreach (var release in releases)
                if (Version.TryParse(release.TagName.Replace(updatesConfiguration.GitTagPrefix, String.Empty, StringComparison.Ordinal), out var version) && version == newVersion)
                {
                    var asset = release.Assets.Where(x => x.Name.Equals(updatesConfiguration.UpdatePackageAssetName, StringComparison.Ordinal)).FirstOrDefault();
                    if (asset == default)
                        continue;

                    if (!serverUpdater.ApplyUpdate(version, new Uri(asset.BrowserDownloadUrl), ioManager))
                        return Conflict(new ErrorMessage(ErrorCode.ServerUpdateInProgress));
                    return Accepted(new Administration
                    {
                        WindowsHost = platformIdentifier.IsWindows,
                        NewVersion = newVersion
                    }); // gtfo of here before all the cancellation tokens fire
                }

            return StatusCode((int)HttpStatusCode.Gone);
        }

        IGitHubClient GetGitHubClient() => String.IsNullOrEmpty(generalConfiguration.GitHubAccessToken) ? gitHubClientFactory.CreateClient() : gitHubClientFactory.CreateClient(generalConfiguration.GitHubAccessToken);

        [HttpGet]
        [TgsAuthorize]
        [ProducesResponseType(typeof(Administration), 200)]
        [ProducesResponseType(424)]
        [ProducesResponseType(typeof(ErrorMessage), 429)]
        public async Task<IActionResult> Read()
        {
            try
            {
                Version greatestVersion = null;
                Uri repoUrl = null;
                try
                {
                    var gitHubClient = GetGitHubClient();
                    var repositoryTask = gitHubClient.Repository.Get(updatesConfiguration.GitHubRepositoryId);
                    var releases = (await gitHubClient.Repository.Release.GetAll(updatesConfiguration.GitHubRepositoryId).ConfigureAwait(false)).Where(x => x.TagName.StartsWith(updatesConfiguration.GitTagPrefix, StringComparison.InvariantCulture));

                    foreach (var I in releases)
                        if (Version.TryParse(I.TagName.Replace(updatesConfiguration.GitTagPrefix, String.Empty, StringComparison.Ordinal), out var version)
                            && version.Major == assemblyInformationProvider.Version.Major
                            && (greatestVersion == null || version > greatestVersion))
                            greatestVersion = version;
                    repoUrl = new Uri((await repositoryTask.ConfigureAwait(false)).HtmlUrl);
                }
                catch (NotFoundException e)
                {
                    Logger.LogWarning("Not found exception while retrieving upstream repository info: {0}", e);
                }

                return Json(new Administration
                {
                    LatestVersion = greatestVersion,
                    TrackedRepositoryUrl = repoUrl,
                    WindowsHost = platformIdentifier.IsWindows
                });
            }
            catch (RateLimitExceededException e)
            {
                return RateLimit(e);
            }
            catch (ApiException e)
            {
                Logger.LogWarning(OctokitException, e);
                return StatusCode((int)HttpStatusCode.FailedDependency, new ErrorMessage(ErrorCode.GitHubApiError)
                {
                    AdditionalData = e.Message
                });
            }
        }

        [HttpPost]
        [TgsAuthorize(AdministrationRights.ChangeVersion)]
        [ProducesResponseType(typeof(Administration), 202)]
        [ProducesResponseType(410)]
        [ProducesResponseType(typeof(ErrorMessage), 422)]
        [ProducesResponseType(424)]
        [ProducesResponseType(typeof(ErrorMessage), 429)]
        public async Task<IActionResult> Update([FromBody] Administration model, CancellationToken cancellationToken)
        {
            if (model == null)
                throw new ArgumentNullException(nameof(model));

            if (model.NewVersion == null)
                return BadRequest(new ErrorMessage(ErrorCode.ModelValidationFailure)
                {
                    AdditionalData = "newVersion is required!"
                });

            if (model.NewVersion.Major != assemblyInformationProvider.Version.Major)
                return BadRequest(new ErrorMessage(ErrorCode.CannotChangeServerSuite));

            if(!serverUpdater.WatchdogPresent)
                return UnprocessableEntity(new ErrorMessage(ErrorCode.MissingHostWatchdog));

            return await CheckReleasesAndApplyUpdate(model.NewVersion, cancellationToken).ConfigureAwait(false);
        }

        [HttpDelete]
        [TgsAuthorize(AdministrationRights.RestartHost)]
        [ProducesResponseType(204)]
        [ProducesResponseType(typeof(ErrorMessage), 422)]
        public async Task<IActionResult> Delete()
        {
            try
            {
                if (!serverUpdater.WatchdogPresent)
                {
                    Logger.LogDebug("Restart request failed due to lack of host watchdog!");
                    return UnprocessableEntity(new ErrorMessage(ErrorCode.MissingHostWatchdog));
                }

                await serverUpdater.Restart().ConfigureAwait(false);
                return NoContent();
            }
            catch (InvalidOperationException)
            {
                return StatusCode((int)HttpStatusCode.ServiceUnavailable);
            }
        }
    }
}