DatabaseContext.cs

Go to the documentation of this file.

using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Migrations;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using System;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Threading;
using System.Threading.Tasks;
using Tgstation.Server.Host.Configuration;
using Tgstation.Server.Host.Database.Migrations;
using Tgstation.Server.Host.Models;

namespace Tgstation.Server.Host.Database
{
#pragma warning disable CA1506 // TODO: Decomplexify
    public abstract class DatabaseContext : DbContext, IDatabaseContext
    {
        public DbSet<User> Users { get; set; }

        public DbSet<Instance> Instances { get; set; }

        public DbSet<CompileJob> CompileJobs { get; set; }

        public DbSet<RevisionInformation> RevisionInformations { get; set; }

        public DbSet<DreamMakerSettings> DreamMakerSettings { get; set; }

        public DbSet<ChatBot> ChatBots { get; set; }

        public DbSet<DreamDaemonSettings> DreamDaemonSettings { get; set; }

        public DbSet<RepositorySettings> RepositorySettings { get; set; }

        public DbSet<InstanceUser> InstanceUsers { get; set; }

        public DbSet<ChatChannel> ChatChannels { get; set; }

        public DbSet<Job> Jobs { get; set; }

        public DbSet<ReattachInformation> ReattachInformations { get; set; }

        public DbSet<TestMerge> TestMerges { get; set; }

        public DbSet<RevInfoTestMerge> RevInfoTestMerges { get; set; }

        protected virtual DeleteBehavior RevInfoCompileJobDeleteBehavior => DeleteBehavior.ClientNoAction;

        IDatabaseCollection<User> IDatabaseContext.Users => usersCollection;

        IDatabaseCollection<Instance> IDatabaseContext.Instances => instancesCollection;

        IDatabaseCollection<InstanceUser> IDatabaseContext.InstanceUsers => instanceUsersCollection;

        IDatabaseCollection<Job> IDatabaseContext.Jobs => jobsCollection;

        IDatabaseCollection<CompileJob> IDatabaseContext.CompileJobs => compileJobsCollection;

        IDatabaseCollection<RevisionInformation> IDatabaseContext.RevisionInformations => revisionInformationsCollection;

        IDatabaseCollection<DreamMakerSettings> IDatabaseContext.DreamMakerSettings => dreamMakerSettingsCollection;

        IDatabaseCollection<DreamDaemonSettings> IDatabaseContext.DreamDaemonSettings => dreamDaemonSettingsCollection;

        IDatabaseCollection<ChatBot> IDatabaseContext.ChatBots => chatBotsCollection;

        IDatabaseCollection<ChatChannel> IDatabaseContext.ChatChannels => chatChannelsCollection;

        IDatabaseCollection<RepositorySettings> IDatabaseContext.RepositorySettings => repositorySettingsCollection;

        IDatabaseCollection<ReattachInformation> IDatabaseContext.ReattachInformations => reattachInformationsCollection;

        readonly IDatabaseCollection<User> usersCollection;

        readonly IDatabaseCollection<Instance> instancesCollection;

        readonly IDatabaseCollection<CompileJob> compileJobsCollection;

        readonly IDatabaseCollection<InstanceUser> instanceUsersCollection;

        readonly IDatabaseCollection<Job> jobsCollection;

        readonly IDatabaseCollection<RevisionInformation> revisionInformationsCollection;

        readonly IDatabaseCollection<DreamMakerSettings> dreamMakerSettingsCollection;

        readonly IDatabaseCollection<DreamDaemonSettings> dreamDaemonSettingsCollection;

        readonly IDatabaseCollection<ChatBot> chatBotsCollection;

        readonly IDatabaseCollection<ChatChannel> chatChannelsCollection;

        readonly IDatabaseCollection<RepositorySettings> repositorySettingsCollection;

        readonly IDatabaseCollection<ReattachInformation> reattachInformationsCollection;

        public static Action<DbContextOptionsBuilder, DatabaseConfiguration> GetConfigureAction<TDatabaseContext>()
            where TDatabaseContext : DatabaseContext
        {
            // HACK HACK HACK HACK HACK
            const string ConfigureMethodName = nameof(SqlServerDatabaseContext.ConfigureWith);
            var configureFunction = typeof(TDatabaseContext).GetMethod(
                ConfigureMethodName,
                BindingFlags.Public | BindingFlags.Static);

            if (configureFunction == null)
                throw new InvalidOperationException($"Context type {typeof(TDatabaseContext).FullName} missing static {ConfigureMethodName} function!");

            return (optionsBuilder, config) => configureFunction.Invoke(null, new object[] { optionsBuilder, config });
        }

        public DatabaseContext(DbContextOptions dbContextOptions) : base(dbContextOptions)
        {
            usersCollection = new DatabaseCollection<User>(Users);
            instancesCollection = new DatabaseCollection<Instance>(Instances);
            instanceUsersCollection = new DatabaseCollection<InstanceUser>(InstanceUsers);
            compileJobsCollection = new DatabaseCollection<CompileJob>(CompileJobs);
            repositorySettingsCollection = new DatabaseCollection<RepositorySettings>(RepositorySettings);
            dreamMakerSettingsCollection = new DatabaseCollection<DreamMakerSettings>(DreamMakerSettings);
            dreamDaemonSettingsCollection = new DatabaseCollection<DreamDaemonSettings>(DreamDaemonSettings);
            chatBotsCollection = new DatabaseCollection<ChatBot>(ChatBots);
            chatChannelsCollection = new DatabaseCollection<ChatChannel>(ChatChannels);
            revisionInformationsCollection = new DatabaseCollection<RevisionInformation>(RevisionInformations);
            jobsCollection = new DatabaseCollection<Job>(Jobs);
            reattachInformationsCollection = new DatabaseCollection<ReattachInformation>(ReattachInformations);
        }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            if (modelBuilder == null)
                throw new ArgumentNullException(nameof(modelBuilder));

            base.OnModelCreating(modelBuilder);

            var userModel = modelBuilder.Entity<User>();
            userModel.HasIndex(x => x.CanonicalName).IsUnique();
            userModel.HasIndex(x => x.SystemIdentifier).IsUnique();
            userModel.HasMany(x => x.TestMerges).WithOne(x => x.MergedBy).OnDelete(DeleteBehavior.Restrict);

            modelBuilder.Entity<InstanceUser>().HasIndex(x => new { x.UserId, x.InstanceId }).IsUnique();

            var revInfo = modelBuilder.Entity<RevisionInformation>();
            revInfo.HasMany(x => x.ActiveTestMerges).WithOne(x => x.RevisionInformation).OnDelete(DeleteBehavior.Cascade);
            revInfo.HasOne(x => x.PrimaryTestMerge).WithOne(x => x.PrimaryRevisionInformation).OnDelete(DeleteBehavior.Cascade);
            revInfo.HasIndex(x => new { x.InstanceId, x.CommitSha }).IsUnique();

            // IMPORTANT: When an instance is deleted (detached) it cascades into the maze of revinfo/testmerge/ritm/compilejob/job/ri relations
            // This maze starts at revInfo and jobs
            // jobs takes care of deleting compile jobs and ris
            // rev info takes care of the rest
            // Break the link here so the db doesn't shit itself complaining about cascading deletes
            // EF will handle making the right query to destroy everything
            // UPDATE: I fuck with this constantly in hopes of eliminating FK issues on instance detack
            revInfo.HasMany(x => x.CompileJobs).WithOne(x => x.RevisionInformation).OnDelete(RevInfoCompileJobDeleteBehavior);

            // Also break the link between ritm and testmerge so it doesn't cycle in a triangle with rev info
            modelBuilder.Entity<TestMerge>().HasMany(x => x.RevisonInformations).WithOne(x => x.TestMerge).OnDelete(DeleteBehavior.ClientNoAction);

            var compileJob = modelBuilder.Entity<CompileJob>();
            compileJob.HasIndex(x => x.DirectoryName);
            compileJob.HasOne(x => x.Job).WithOne().OnDelete(DeleteBehavior.Cascade);

            modelBuilder.Entity<ReattachInformation>().HasOne(x => x.CompileJob).WithMany().OnDelete(DeleteBehavior.Cascade);

            var chatChannel = modelBuilder.Entity<ChatChannel>();
            chatChannel.HasIndex(x => new { x.ChatSettingsId, x.IrcChannel }).IsUnique();
            chatChannel.HasIndex(x => new { x.ChatSettingsId, x.DiscordChannelId }).IsUnique();
            chatChannel.HasOne(x => x.ChatSettings).WithMany(x => x.Channels).HasForeignKey(x => x.ChatSettingsId).OnDelete(DeleteBehavior.Cascade);

            modelBuilder.Entity<ChatBot>().HasIndex(x => new { x.InstanceId, x.Name }).IsUnique();

            var instanceModel = modelBuilder.Entity<Instance>();
            instanceModel.HasIndex(x => x.Path).IsUnique();
            instanceModel.HasMany(x => x.ChatSettings).WithOne(x => x.Instance).OnDelete(DeleteBehavior.Cascade);
            instanceModel.HasOne(x => x.DreamDaemonSettings).WithOne(x => x.Instance).OnDelete(DeleteBehavior.Cascade);
            instanceModel.HasOne(x => x.DreamMakerSettings).WithOne(x => x.Instance).OnDelete(DeleteBehavior.Cascade);
            instanceModel.HasOne(x => x.RepositorySettings).WithOne(x => x.Instance).OnDelete(DeleteBehavior.Cascade);
            instanceModel.HasMany(x => x.RevisionInformations).WithOne(x => x.Instance).OnDelete(DeleteBehavior.Cascade);
            instanceModel.HasMany(x => x.InstanceUsers).WithOne(x => x.Instance).OnDelete(DeleteBehavior.Cascade);
            instanceModel.HasMany(x => x.Jobs).WithOne(x => x.Instance).OnDelete(DeleteBehavior.Cascade);
        }

        public Task Save(CancellationToken cancellationToken) => SaveChangesAsync(cancellationToken);

        public Task Drop(CancellationToken cancellationToken) => Database.EnsureDeletedAsync(cancellationToken);

        public async Task<bool> Migrate(ILogger<DatabaseContext> logger, CancellationToken cancellationToken)
        {
            if (logger == null)
                throw new ArgumentNullException(nameof(logger));
            var migrations = await Database.GetAppliedMigrationsAsync(cancellationToken).ConfigureAwait(false);
            var wasEmpty = !migrations.Any();

            if (wasEmpty || (await Database.GetPendingMigrationsAsync(cancellationToken).ConfigureAwait(false)).Any())
            {
                logger.LogInformation("Migrating database...");
                await Database.MigrateAsync(cancellationToken).ConfigureAwait(false);
            }
            else
                logger.LogDebug("No migrations to apply");

            wasEmpty |= (await Users.AsQueryable().CountAsync(cancellationToken).ConfigureAwait(false)) == 0;

            return wasEmpty;
        }

        public async Task SchemaDowngradeForServerVersion(
            ILogger<DatabaseContext> logger,
            Version version,
            DatabaseType currentDatabaseType,
            CancellationToken cancellationToken)
        {
            if(logger == null)
                throw new ArgumentNullException(nameof(logger));
            if (version == null)
                throw new ArgumentNullException(nameof(version));
            if (version < new Version(4, 0))
                throw new ArgumentOutOfRangeException(nameof(version), version, "Not a valid V4 version!");

            // Update this with new migrations as they are made
            string targetMigration = null;

            if (currentDatabaseType == DatabaseType.PostgresSql && version < new Version(4, 3, 0))
                throw new NotSupportedException("Cannot migrate below version 4.3.0 with PostgresSql!");

            if (version < new Version(4, 1, 0))
                throw new NotSupportedException("Cannot migrate below version 4.1.0!");

            if(version < new Version(4, 4, 0))
                switch (currentDatabaseType)
                {
                    case DatabaseType.MariaDB:
                    case DatabaseType.MySql:
                        targetMigration = nameof(MYFixForeignKey);
                        break;
                    case DatabaseType.PostgresSql:
                        targetMigration = nameof(PGCreate);
                        break;
                    case DatabaseType.SqlServer:
                    case DatabaseType.Sqlite:
                        targetMigration = nameof(MSRemoveSoftColumns);
                        break;
                    default:
                        throw new ArgumentException($"Invalid DatabaseType: {currentDatabaseType}", nameof(currentDatabaseType));
                }

            if (version < new Version(4, 2, 0))
                targetMigration = currentDatabaseType == DatabaseType.Sqlite ? nameof(SLRebuild) : nameof(MSFixCascadingDelete);

            if (targetMigration == null)
            {
                logger.LogDebug("No down migration required.");
                return;
            }

            string migrationSubstitution;
            switch (currentDatabaseType)
            {
                case DatabaseType.SqlServer:
                    // already setup
                    migrationSubstitution = null;
                    break;
                case DatabaseType.MySql:
                case DatabaseType.MariaDB:
                    migrationSubstitution = "MY{0}";
                    break;
                case DatabaseType.Sqlite:
                    migrationSubstitution = "SL{0}";
                    break;
                case DatabaseType.PostgresSql:
                    migrationSubstitution = "PG{0}";
                    break;
                default:
                    throw new InvalidOperationException($"Invalid DatabaseType: {currentDatabaseType}");
            }

            if (migrationSubstitution != null)
                targetMigration = String.Format(CultureInfo.InvariantCulture, migrationSubstitution, targetMigration.Substring(2));

            // even though it clearly implements it in the DatabaseFacade definition this won't work without casting (╯ಠ益ಠ)╯︵ ┻━┻
            var dbServiceProvider = ((IInfrastructure<IServiceProvider>)Database).Instance;
            var migrator = dbServiceProvider.GetRequiredService<IMigrator>();

            logger.LogInformation("Migrating down to version {0}. Target: {1}", version, targetMigration);
            try
            {
                await migrator.MigrateAsync(targetMigration, cancellationToken).ConfigureAwait(false);
            }
            catch (Exception e)
            {
                logger.LogCritical("Failed to migrate! Exception: {0}", e);
            }
        }
    }
}