ConfigurationController.cs

Go to the documentation of this file.

using System;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
 
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
 
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.Components;
using Tgstation.Server.Host.Controllers.Results;
using Tgstation.Server.Host.Database;
using Tgstation.Server.Host.Extensions;
using Tgstation.Server.Host.IO;
using Tgstation.Server.Host.Models;
using Tgstation.Server.Host.Security;
using Tgstation.Server.Host.Utils;
 
namespace Tgstation.Server.Host.Controllers
{
    [Route(Routes.Configuration)]
    public sealed class ConfigurationController : InstanceRequiredController
    {
        readonly IIOManager ioManager;
 
        public ConfigurationController(
            IDatabaseContext databaseContext,
            IAuthenticationContext authenticationContext,
            ILogger<ConfigurationController> logger,
            IInstanceManager instanceManager,
            IIOManager ioManager,
            IApiHeadersProvider apiHeaders)
            : base(
                  databaseContext,
                  authenticationContext,
                  logger,
                  instanceManager,
                  apiHeaders)
        {
            this.ioManager = ioManager ?? throw new ArgumentNullException(nameof(ioManager));
        }
 
        [HttpPost]
        [TgsAuthorize(ConfigurationRights.Write)]
        [ProducesResponseType(typeof(ConfigurationFileResponse), 200)]
        [ProducesResponseType(typeof(ConfigurationFileResponse), 202)]
        public async ValueTask<IActionResult> Update([FromBody] ConfigurationFileRequest model, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(model);
            if (ForbidDueToModeConflicts(model.Path!, out var systemIdentity))
                return Forbid();
 
            try
            {
                return await WithComponentInstance(
                    async instance =>
                    {
                        var newFile = await instance
                            .Configuration
                            .Write(
                                model.Path!,
                                systemIdentity,
                                model.LastReadHash,
                                cancellationToken);
 
                        if (newFile == null)
                            return Conflict(new ErrorMessageResponse(ErrorCode.ConfigurationContendedAccess));
 
                        return model.LastReadHash == null ? Accepted(newFile) : Json(newFile);
                    });
            }
            catch (IOException e)
            {
                Logger.LogInformation(e, "IOException while updating file {path}!", model.Path);
                return Conflict(new ErrorMessageResponse(ErrorCode.IOError)
                {
                    AdditionalData = e.Message,
                });
            }
        }
 
        [HttpGet(Routes.File + "/{*filePath}")]
        [TgsAuthorize(ConfigurationRights.Read)]
        [ProducesResponseType(typeof(ConfigurationFileResponse), 200)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 409)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 410)]
        public async ValueTask<IActionResult> File(string filePath, CancellationToken cancellationToken)
        {
            if (ForbidDueToModeConflicts(filePath, out var systemIdentity))
                return Forbid();
 
            try
            {
                return await WithComponentInstance(
                    async instance =>
                    {
                        var result = await instance
                            .Configuration
                            .Read(filePath, systemIdentity, cancellationToken);
 
                        if (result == null)
                            return Conflict(new ErrorMessageResponse(ErrorCode.ConfigurationContendedAccess));
 
                        return Json(result);
                    });
            }
            catch (IOException e)
            {
                Logger.LogInformation(e, "IOException while reading file {path}!", filePath);
                return Conflict(new ErrorMessageResponse(ErrorCode.IOError)
                {
                    AdditionalData = e.Message,
                });
            }
        }
 
        [HttpGet(Routes.List + "/{*directoryPath}")]
        [TgsAuthorize(ConfigurationRights.List)]
        [ProducesResponseType(typeof(PaginatedResponse<ConfigurationFileResponse>), 200)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 409)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 410)]
        public ValueTask<IActionResult> Directory(
            string? directoryPath,
            [FromQuery] int? page,
            [FromQuery] int? pageSize,
            CancellationToken cancellationToken)
            => WithComponentInstance(
                instance => Paginated(
                    async () =>
                    {
                        if (ForbidDueToModeConflicts(directoryPath, out var systemIdentity))
                            return new PaginatableResult<ConfigurationFileResponse>(
                                Forbid());
 
                        try
                        {
                            var result = await instance
                                .Configuration
                                .ListDirectory(directoryPath, systemIdentity, cancellationToken);
 
                            if (result == null)
                                return new PaginatableResult<ConfigurationFileResponse>(
                                    Conflict(new ErrorMessageResponse(ErrorCode.ConfigurationContendedAccess)));
 
                            return new PaginatableResult<ConfigurationFileResponse>(result);
                        }
                        catch (UnauthorizedAccessException)
                        {
                            return new PaginatableResult<ConfigurationFileResponse>(
                                Forbid());
                        }
                        catch (IOException ex)
                        {
                            Logger.LogInformation(ex, "IOException while enumerating directory!");
                            return new PaginatableResult<ConfigurationFileResponse>(
                                Conflict(new ErrorMessageResponse(ErrorCode.IOError)
                                {
                                    AdditionalData = ex.Message,
                                }));
                        }
                    },
                    null,
                    page,
                    pageSize,
                    cancellationToken));
 
        [HttpGet(Routes.List)]
        [TgsAuthorize(ConfigurationRights.List)]
        [ProducesResponseType(typeof(PaginatedResponse<ConfigurationFileResponse>), 200)]
        public ValueTask<IActionResult> List(
            [FromQuery] int? page,
            [FromQuery] int? pageSize,
            CancellationToken cancellationToken) => Directory(null, page, pageSize, cancellationToken);
 
        [HttpPut]
        [TgsAuthorize(ConfigurationRights.Write)]
        [ProducesResponseType(typeof(ConfigurationFileResponse), 200)]
        [ProducesResponseType(typeof(ConfigurationFileResponse), 201)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 409)]
        public async ValueTask<IActionResult> CreateDirectory([FromBody] ConfigurationFileRequest model, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(model);
 
            if (model.Path == null)
                return BadRequest(new ErrorMessageResponse(ErrorCode.ModelValidationFailure));
 
            if (ForbidDueToModeConflicts(model.Path, out var systemIdentity))
                return Forbid();
 
            try
            {
                var resultModel = new ConfigurationFileResponse
                {
                    IsDirectory = true,
                    Path = model.Path,
                };
 
                return await WithComponentInstance(
                    async instance =>
                    {
                        var result = await instance
                            .Configuration
                            .CreateDirectory(model.Path, systemIdentity, cancellationToken);
 
                        if (!result.HasValue)
                            return Conflict(new ErrorMessageResponse(ErrorCode.ConfigurationContendedAccess));
 
                        return result.Value
                            ? Json(resultModel)
                            : this.Created(resultModel);
                    });
            }
            catch (IOException e)
            {
                Logger.LogInformation(e, "IOException while creating directory {path}!", model.Path);
                return Conflict(new ErrorMessageResponse(ErrorCode.IOError)
                {
                    Message = e.Message,
                });
            }
            catch (UnauthorizedAccessException)
            {
                return Forbid();
            }
        }
 
        [HttpDelete]
        [TgsAuthorize(ConfigurationRights.Delete)]
        [ProducesResponseType(204)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 409)]
        public async ValueTask<IActionResult> DeleteDirectory([FromBody] ConfigurationFileRequest directory, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(directory);
 
            if (directory.Path == null)
                return BadRequest(new ErrorMessageResponse(ErrorCode.ModelValidationFailure));
 
            if (ForbidDueToModeConflicts(directory.Path, out var systemIdentity))
                return Forbid();
 
            try
            {
                return await WithComponentInstance(
                    async instance =>
                    {
                        var result = await instance
                            .Configuration
                            .DeleteDirectory(directory.Path, systemIdentity, cancellationToken);
 
                        if (!result.HasValue)
                            return Conflict(new ErrorMessageResponse(ErrorCode.ConfigurationContendedAccess));
 
                        return result.Value
                            ? NoContent()
                            : Conflict(new ErrorMessageResponse(ErrorCode.ConfigurationDirectoryNotEmpty));
                    });
            }
            catch (UnauthorizedAccessException)
            {
                return Forbid();
            }
            catch (IOException ex)
            {
                Logger.LogInformation(ex, "IOException while deleting directory!");
                return Conflict(new ErrorMessageResponse(ErrorCode.IOError)
                {
                    Message = ex.Message,
                });
            }
        }
 
        bool ForbidDueToModeConflicts(string? path, out ISystemIdentity? systemIdentityToUse)
        {
            if (Instance.ConfigurationType == ConfigurationType.Disallowed
                || (Instance.ConfigurationType == ConfigurationType.SystemIdentityWrite && AuthenticationContext.SystemIdentity == null)
                || (path != null && ioManager.PathContainsParentAccess(path)))
            {
                systemIdentityToUse = null;
                return true;
            }
 
            systemIdentityToUse = Instance.ConfigurationType == ConfigurationType.SystemIdentityWrite ? AuthenticationContext.SystemIdentity : null;
            return false;
        }
    }
}