DatabaseSeeder.cs

Go to the documentation of this file.

using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using System;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Tgstation.Server.Api.Rights;
using Tgstation.Server.Host.Configuration;
using Tgstation.Server.Host.Models;
using Tgstation.Server.Host.Security;
using Tgstation.Server.Host.System;
using Z.EntityFramework.Plus;

namespace Tgstation.Server.Host.Database
{
    sealed class DatabaseSeeder : IDatabaseSeeder
    {
        readonly ICryptographySuite cryptographySuite;

        readonly IPlatformIdentifier platformIdentifier;

        readonly ILogger<DatabaseContext> databaseLogger;

        readonly ILogger<DatabaseSeeder> logger;

        readonly GeneralConfiguration generalConfiguration;

        readonly DatabaseConfiguration databaseConfiguration;

        public DatabaseSeeder(
            ICryptographySuite cryptographySuite,
            IPlatformIdentifier platformIdentifier,
            IOptions<GeneralConfiguration> generalConfigurationOptions,
            IOptions<DatabaseConfiguration> databaseConfigurationOptions,
            ILogger<DatabaseContext> databaseLogger,
            ILogger<DatabaseSeeder> logger)
        {
            this.cryptographySuite = cryptographySuite ?? throw new ArgumentNullException(nameof(cryptographySuite));
            this.platformIdentifier = platformIdentifier ?? throw new ArgumentNullException(nameof(platformIdentifier));
            databaseConfiguration = databaseConfigurationOptions?.Value ?? throw new ArgumentNullException(nameof(databaseConfigurationOptions));
            generalConfiguration = generalConfigurationOptions?.Value ?? throw new ArgumentNullException(nameof(generalConfigurationOptions));
            this.databaseLogger = databaseLogger ?? throw new ArgumentNullException(nameof(databaseLogger));
            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
        }

        void SeedAdminUser(IDatabaseContext databaseContext)
        {
            var admin = new User
            {
                AdministrationRights = RightsHelper.AllRights<AdministrationRights>(),
                CreatedAt = DateTimeOffset.Now,
                InstanceManagerRights = RightsHelper.AllRights<InstanceManagerRights>(),
                Name = Api.Models.User.AdminName,
                CanonicalName = User.CanonicalizeName(Api.Models.User.AdminName),
                Enabled = true,
            };
            cryptographySuite.SetUserPassword(admin, Api.Models.User.DefaultAdminPassword, true);
            databaseContext.Users.Add(admin);
        }

        async Task SeedDatabase(IDatabaseContext databaseContext, CancellationToken cancellationToken)
        {
            SeedAdminUser(databaseContext);
            await databaseContext.Save(cancellationToken).ConfigureAwait(false);
        }

        async Task SanitizeDatabase(IDatabaseContext databaseContext, CancellationToken cancellationToken)
        {
            var admin = await GetAdminUser(databaseContext, cancellationToken).ConfigureAwait(false);
            if (admin != null)
            {
                // Fix the issue with ulong enums
                // https://github.com/tgstation/tgstation-server/commit/db341d43b3dab74fe3681f5172ca9bfeaafa6b6d#diff-09f06ec4584665cf89bb77b97f5ccfb9R36-R39
                // https://github.com/JamesNK/Newtonsoft.Json/issues/2301
                admin.AdministrationRights &= RightsHelper.AllRights<AdministrationRights>();
                admin.InstanceManagerRights &= RightsHelper.AllRights<InstanceManagerRights>();
            }

            if (platformIdentifier.IsWindows)
            {
                // normalize backslashes to forward slashes
                var allInstances = await databaseContext
                    .Instances
                    .AsQueryable()
                    .ToListAsync(cancellationToken)
                    .ConfigureAwait(false);
                foreach (var instance in allInstances)
                    instance.Path = instance.Path.Replace('\\', '/');
            }

            var ids = await databaseContext
                .DreamDaemonSettings
                .AsQueryable()
                .Where(x => x.TopicRequestTimeout == 0)
                .Select(x => x.Id)
                .ToListAsync(cancellationToken)
                .ConfigureAwait(false);

            var rowsUpdated = ids.Count;
            foreach (var id in ids)
            {
                var newDDSettings = new DreamDaemonSettings
                {
                    Id = id
                };

                databaseContext.DreamDaemonSettings.Attach(newDDSettings);
                newDDSettings.TopicRequestTimeout = generalConfiguration.ByondTopicTimeout;
            }

            if (rowsUpdated > 0)
                logger.LogInformation(
                    "Updated {0} instances to use database backed BYOND topic timeouts from configuration setting of {1}",
                    rowsUpdated,
                    generalConfiguration.ByondTopicTimeout);

            await databaseContext.Save(cancellationToken).ConfigureAwait(false);
        }

        async Task ResetAdminPassword(IDatabaseContext databaseContext, CancellationToken cancellationToken)
        {
            var admin = await GetAdminUser(databaseContext, cancellationToken).ConfigureAwait(false);
            if (admin != null)
            {
                admin.Enabled = true;
                cryptographySuite.SetUserPassword(admin, Api.Models.User.DefaultAdminPassword, false);
            }

            await databaseContext.Save(cancellationToken).ConfigureAwait(false);
        }

        async Task<User> GetAdminUser(IDatabaseContext databaseContext, CancellationToken cancellationToken)
        {
            var admin = await databaseContext
                .Users
                .AsQueryable()
                .Where(x => x.CanonicalName == User.CanonicalizeName(Api.Models.User.AdminName))
                .FirstOrDefaultAsync(cancellationToken)
                .ConfigureAwait(false);
            if (admin == default)
                SeedAdminUser(databaseContext);

            return admin;
        }

        public async Task Initialize(IDatabaseContext databaseContext, CancellationToken cancellationToken)
        {
            if (databaseContext == null)
                throw new ArgumentNullException(nameof(databaseContext));

            if (databaseConfiguration.DropDatabase)
            {
                logger.LogCritical("DropDatabase configuration option set! Dropping any existing database...");
                await databaseContext.Drop(cancellationToken).ConfigureAwait(false);
            }

            var wasEmpty = await databaseContext.Migrate(databaseLogger, cancellationToken).ConfigureAwait(false);
            if (wasEmpty)
            {
                logger.LogInformation("Seeding database...");
                await SeedDatabase(databaseContext, cancellationToken).ConfigureAwait(false);
            }
            else
            {
                if (databaseConfiguration.ResetAdminPassword)
                {
                    logger.LogWarning("Enabling and resetting admin password due to configuration!");
                    await ResetAdminPassword(databaseContext, cancellationToken).ConfigureAwait(false);
                }

                await SanitizeDatabase(databaseContext, cancellationToken).ConfigureAwait(false);
            }
        }

        public Task Downgrade(IDatabaseContext databaseContext, Version downgradeVersion, CancellationToken cancellationToken)
        {
            if (databaseContext == null)
                throw new ArgumentNullException(nameof(databaseContext));
            if (downgradeVersion == null)
                throw new ArgumentNullException(nameof(downgradeVersion));

            return databaseContext.SchemaDowngradeForServerVersion(databaseLogger, downgradeVersion, databaseConfiguration.DatabaseType, cancellationToken);
        }
    }
}