ApiRootController.cs

Go to the documentation of this file.

using System;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
 
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Microsoft.Extensions.Primitives;
using Microsoft.Net.Http.Headers;
 
using Octokit;
 
using Tgstation.Server.Api;
using Tgstation.Server.Api.Models.Response;
using Tgstation.Server.Host.Authority;
using Tgstation.Server.Host.Components.Interop;
using Tgstation.Server.Host.Configuration;
using Tgstation.Server.Host.Core;
using Tgstation.Server.Host.Database;
using Tgstation.Server.Host.GraphQL.Mutations.Payloads;
using Tgstation.Server.Host.Models;
using Tgstation.Server.Host.Security;
using Tgstation.Server.Host.Security.OAuth;
using Tgstation.Server.Host.Swarm;
using Tgstation.Server.Host.System;
using Tgstation.Server.Host.Utils;
 
namespace Tgstation.Server.Host.Controllers
{
    [Route(Routes.ApiRoot)]
    public sealed class ApiRootController : ApiController
    {
        readonly IAssemblyInformationProvider assemblyInformationProvider;
 
        readonly IOAuthProviders oAuthProviders;
 
        readonly IPlatformIdentifier platformIdentifier;
 
        readonly ISwarmService swarmService;
 
        readonly IServerControl serverControl;
 
        readonly IRestAuthorityInvoker<ILoginAuthority> loginAuthority;
 
        readonly IOptionsSnapshot<GeneralConfiguration> generalConfigurationOptions;
 
        readonly IOptionsSnapshot<SecurityConfiguration> securityConfigurationOptions;
 
        public ApiRootController(
            IDatabaseContext databaseContext,
            IAuthenticationContext authenticationContext,
            IAssemblyInformationProvider assemblyInformationProvider,
            IOAuthProviders oAuthProviders,
            IPlatformIdentifier platformIdentifier,
            ISwarmService swarmService,
            IServerControl serverControl,
            IOptionsSnapshot<GeneralConfiguration> generalConfigurationOptions,
            IOptionsSnapshot<SecurityConfiguration> securityConfigurationOptions,
            ILogger<ApiRootController> logger,
            IApiHeadersProvider apiHeadersProvider,
            IRestAuthorityInvoker<ILoginAuthority> loginAuthority)
            : base(
                  databaseContext,
                  authenticationContext,
                  apiHeadersProvider,
                  logger,
                  false)
        {
            this.assemblyInformationProvider = assemblyInformationProvider ?? throw new ArgumentNullException(nameof(assemblyInformationProvider));
            this.platformIdentifier = platformIdentifier ?? throw new ArgumentNullException(nameof(platformIdentifier));
            this.oAuthProviders = oAuthProviders ?? throw new ArgumentNullException(nameof(oAuthProviders));
            this.swarmService = swarmService ?? throw new ArgumentNullException(nameof(swarmService));
            this.serverControl = serverControl ?? throw new ArgumentNullException(nameof(serverControl));
            this.generalConfigurationOptions = generalConfigurationOptions ?? throw new ArgumentNullException(nameof(generalConfigurationOptions));
            this.securityConfigurationOptions = securityConfigurationOptions ?? throw new ArgumentNullException(nameof(securityConfigurationOptions));
            this.loginAuthority = loginAuthority ?? throw new ArgumentNullException(nameof(loginAuthority));
        }
 
        [HttpGet]
        [ProducesResponseType(typeof(ServerInformationResponse), 200)]
        public IActionResult ServerInfo()
        {
            // if they tried to authenticate in any form and failed, let them know immediately
            bool failIfUnauthed;
            if (ApiHeaders == null)
            {
                try
                {
                    // we only allow authorization header issues
                    ApiHeadersProvider.CreateAuthlessHeaders();
                }
                catch (HeadersException ex)
                {
                    return HeadersIssue(ex);
                }
 
                failIfUnauthed = Request.Headers.Authorization.Count > 0;
            }
            else
                failIfUnauthed = ApiHeaders.Token != null;
 
            if (failIfUnauthed && !AuthenticationContext.Valid)
                return Unauthorized();
 
            return Json(new ServerInformationResponse
            {
                Version = assemblyInformationProvider.Version,
                ApiVersion = ApiHeaders.Version,
                DMApiVersion = DMApiConstants.InteropVersion,
                MinimumPasswordLength = generalConfigurationOptions.Value.MinimumPasswordLength,
                InstanceLimit = generalConfigurationOptions.Value.InstanceLimit,
                UserLimit = generalConfigurationOptions.Value.UserLimit,
                UserGroupLimit = generalConfigurationOptions.Value.UserGroupLimit,
                ValidInstancePaths = generalConfigurationOptions.Value.ValidInstancePaths,
                WindowsHost = platformIdentifier.IsWindows,
                SwarmServers = swarmService
                    .GetSwarmServers()
                    ?.Select(swarmServerInfo => new SwarmServerResponse(swarmServerInfo))
                    .ToList(),
                OAuthProviderInfos = oAuthProviders.ProviderInfos(),
                OidcProviderInfos = securityConfigurationOptions.Value.OidcProviderInfos().ToList(),
                UpdateInProgress = serverControl.UpdateInProgress,
                OidcStrictMode = securityConfigurationOptions.Value.OidcStrictMode,
            });
        }
 
        [HttpPost]
        [ProducesResponseType(typeof(TokenResponse), 200)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 429)]
        public ValueTask<IActionResult> CreateToken(CancellationToken cancellationToken)
        {
            if (ApiHeaders == null)
            {
                Response.Headers.Add(HeaderNames.WWWAuthenticate, new StringValues($"basic realm=\"Create TGS {ApiHeaders.BearerAuthenticationScheme} token\""));
                return ValueTask.FromResult(HeadersIssue(ApiHeadersProvider.HeadersException!));
            }
 
            return loginAuthority.InvokeTransformable<LoginResult, TokenResponse>(this, authority => authority.AttemptLogin(cancellationToken));
        }
 
        [HttpPost("oauth_gateway")]
        [ProducesResponseType(typeof(OAuthGatewayResponse), 200)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 429)]
        public ValueTask<IActionResult> CreateOAuthGatewayToken(CancellationToken cancellationToken)
            => loginAuthority.InvokeTransformable<OAuthGatewayLoginResult, OAuthGatewayResponse>(this, authority => authority.AttemptOAuthGatewayLogin(cancellationToken));
    }
}