InstanceManager.cs

Go to the documentation of this file.

using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Tgstation.Server.Api.Models;
using Tgstation.Server.Host.Components.Interop;
using Tgstation.Server.Host.Components.Interop.Bridge;
using Tgstation.Server.Host.Configuration;
using Tgstation.Server.Host.Core;
using Tgstation.Server.Host.Database;
using Tgstation.Server.Host.IO;
using Tgstation.Server.Host.Jobs;
using Tgstation.Server.Host.Security;
using Tgstation.Server.Host.System;

namespace Tgstation.Server.Host.Components
{
    sealed class InstanceManager : IInstanceManager, IRestartHandler, IHostedService, IBridgeRegistrar, IDisposable
    {
        public Task Ready => readyTcs.Task;

        readonly IInstanceFactory instanceFactory;

        readonly IIOManager ioManager;

        readonly IDatabaseContextFactory databaseContextFactory;

        readonly IAssemblyInformationProvider assemblyInformationProvider;

        readonly IJobManager jobManager;

        readonly IServerControl serverControl;

        readonly ISystemIdentityFactory systemIdentityFactory;

        readonly IAsyncDelayer asyncDelayer;

        readonly ILogger<InstanceManager> logger;

        readonly IDictionary<long, IInstance> instances;

        readonly IDictionary<string, IBridgeHandler> bridgeHandlers;

        readonly GeneralConfiguration generalConfiguration;

        readonly TaskCompletionSource<object> readyTcs;

        Version downgradeVersion;

        bool disposed;

        public InstanceManager(
            IInstanceFactory instanceFactory,
            IIOManager ioManager,
            IDatabaseContextFactory databaseContextFactory,
            IAssemblyInformationProvider assemblyInformationProvider,
            IJobManager jobManager,
            IServerControl serverControl,
            ISystemIdentityFactory systemIdentityFactory,
            IAsyncDelayer asyncDelayer,
            IOptions<GeneralConfiguration> generalConfigurationOptions,
            ILogger<InstanceManager> logger)
        {
            this.instanceFactory = instanceFactory ?? throw new ArgumentNullException(nameof(instanceFactory));
            this.ioManager = ioManager ?? throw new ArgumentNullException(nameof(ioManager));
            this.databaseContextFactory = databaseContextFactory ?? throw new ArgumentNullException(nameof(databaseContextFactory));
            this.assemblyInformationProvider = assemblyInformationProvider ?? throw new ArgumentNullException(nameof(assemblyInformationProvider));
            this.jobManager = jobManager ?? throw new ArgumentNullException(nameof(jobManager));
            this.serverControl = serverControl ?? throw new ArgumentNullException(nameof(serverControl));
            this.systemIdentityFactory = systemIdentityFactory ?? throw new ArgumentNullException(nameof(systemIdentityFactory));
            this.asyncDelayer = asyncDelayer ?? throw new ArgumentNullException(nameof(asyncDelayer));
            generalConfiguration = generalConfigurationOptions?.Value ?? throw new ArgumentNullException(nameof(generalConfigurationOptions));
            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));

            serverControl.RegisterForRestart(this);

            instances = new Dictionary<long, IInstance>();
            bridgeHandlers = new Dictionary<string, IBridgeHandler>();
            readyTcs = new TaskCompletionSource<object>();
        }

        public void Dispose()
        {
            lock (instances)
            {
                if (disposed)
                    return;
                disposed = true;
            }

            foreach (var I in instances)
                I.Value.Dispose();
        }

        public IInstance GetInstance(Models.Instance metadata)
        {
            if (metadata == null)
                throw new ArgumentNullException(nameof(metadata));
            lock (instances)
            {
                if (!instances.TryGetValue(metadata.Id, out IInstance instance))
                    throw new InvalidOperationException("Instance not online!");
                return instance;
            }
        }

        public async Task MoveInstance(Models.Instance instance, string newPath, CancellationToken cancellationToken)
        {
            if (newPath == null)
                throw new ArgumentNullException(nameof(newPath));
            if (instance.Online.Value)
                throw new InvalidOperationException("Cannot move an online instance!");
            var oldPath = instance.Path;
            await ioManager.CopyDirectory(oldPath, newPath, null, cancellationToken).ConfigureAwait(false);
            await databaseContextFactory.UseContext(db =>
            {
                var targetInstance = new Models.Instance
                {
                    Id = instance.Id
                };
                db.Instances.Attach(targetInstance);
                targetInstance.Path = newPath;
                return db.Save(cancellationToken);
            }).ConfigureAwait(false);
            await ioManager.DeleteDirectory(oldPath, cancellationToken).ConfigureAwait(false);
        }

        public async Task OfflineInstance(Models.Instance metadata, Models.User user, CancellationToken cancellationToken)
        {
            if (metadata == null)
                throw new ArgumentNullException(nameof(metadata));
            logger.LogInformation("Offlining instance ID {0}", metadata.Id);
            IInstance instance;
            lock (instances)
            {
                if (!instances.TryGetValue(metadata.Id, out instance))
                    throw new InvalidOperationException("Instance not online!");
                instances.Remove(metadata.Id);
            }

            try
            {
                // we are the one responsible for cancelling his jobs
                var tasks = new List<Task>();
                await databaseContextFactory.UseContext(async db =>
                {
                    var jobs = db
                        .Jobs
                        .AsQueryable()
                        .Where(x => x.Instance.Id == metadata.Id)
                        .Select(x => new Models.Job
                        {
                            Id = x.Id
                        });
                    await jobs.ForEachAsync(job =>
                    {
                        lock (tasks)
                            tasks.Add(jobManager.CancelJob(job, user, true, cancellationToken));
                    }, cancellationToken).ConfigureAwait(false);
                }).ConfigureAwait(false);

                await Task.WhenAll(tasks).ConfigureAwait(false);

                await instance.StopAsync(cancellationToken).ConfigureAwait(false);
            }
            finally
            {
                instance.Dispose();
            }
        }

        public async Task OnlineInstance(Models.Instance metadata, CancellationToken cancellationToken)
        {
            if (metadata == null)
                throw new ArgumentNullException(nameof(metadata));
            logger.LogInformation("Onlining instance ID {0} ({1}) at {2}", metadata.Id, metadata.Name, metadata.Path);
            var instance = instanceFactory.CreateInstance(this, metadata);
            try
            {
                lock (instances)
                {
                    if (instances.ContainsKey(metadata.Id))
                        throw new InvalidOperationException("Instance already online!");
                    instances.Add(metadata.Id, instance);
                }
            }
            catch
            {
                instance.Dispose();
                throw;
            }

            await instance.StartAsync(cancellationToken).ConfigureAwait(false);
        }

        #pragma warning disable CA1506 // TODO: Decomplexify
        public Task StartAsync(CancellationToken cancellationToken) => databaseContextFactory.UseContext(async databaseContext =>
        {
            logger.LogInformation(assemblyInformationProvider.VersionString);

            try
            {
                CheckSystemCompatibility();
                var factoryStartup = instanceFactory.StartAsync(cancellationToken);
                await databaseContext.Initialize(cancellationToken).ConfigureAwait(false);
                await jobManager.StartAsync(cancellationToken).ConfigureAwait(false);
                var dbInstances = databaseContext
                    .Instances
                    .AsQueryable()
                    .Where(x => x.Online.Value)
                    .Include(x => x.RepositorySettings)
                    .Include(x => x.ChatSettings)
                    .ThenInclude(x => x.Channels)
                    .Include(x => x.DreamDaemonSettings)
                    .ToAsyncEnumerable();
                var tasks = new List<Task>();
                await factoryStartup.ConfigureAwait(false);
                await dbInstances.ForEachAsync(metadata => tasks.Add(metadata.Online.Value ? OnlineInstance(metadata, cancellationToken) : Task.CompletedTask), cancellationToken).ConfigureAwait(false);
                await Task.WhenAll(tasks).ConfigureAwait(false);
                logger.LogInformation("Server ready!");
                readyTcs.SetResult(null);
            }
            catch (OperationCanceledException)
            {
                logger.LogInformation("Cancelled instance manager initialization!");
            }
            catch (Exception e)
            {
                logger.LogCritical("Instance manager startup error! Exception: {0}", e);
                try
                {
                    await serverControl.Die(e).ConfigureAwait(false);
                    return;
                }
                catch (Exception e2)
                {
                    logger.LogCritical("Failed to kill server! Exception: {0}", e2);
                }

                throw;
            }
        });
        #pragma warning restore CA1506 // TODO: Decomplexify

        public async Task StopAsync(CancellationToken cancellationToken)
        {
            await jobManager.StopAsync(cancellationToken).ConfigureAwait(false);
            await Task.WhenAll(instances.Select(x => x.Value.StopAsync(cancellationToken))).ConfigureAwait(false);
            await instanceFactory.StopAsync(cancellationToken).ConfigureAwait(false);

            // downgrade the db if necessary
            if (downgradeVersion != null)
                await databaseContextFactory.UseContext(db => db.SchemaDowngradeForServerVersion(downgradeVersion, cancellationToken)).ConfigureAwait(false);
        }

        public Task HandleRestart(Version updateVersion, CancellationToken cancellationToken)
        {
            downgradeVersion = updateVersion != null && updateVersion < assemblyInformationProvider.Version ? updateVersion : null;
            return Task.CompletedTask;
        }

        private void CheckSystemCompatibility()
        {
            if (generalConfiguration.UseExperimentalWatchdog && !Debugger.IsAttached)
                throw new InvalidOperationException(
                    "The experimental watchdog is currently non-functional! Please disable the '{nameof(generalConfiguration.UseExperimentalWatchdog)}' option in your configuration!");

            using var systemIdentity = systemIdentityFactory.GetCurrent();
            if (!systemIdentity.CanCreateSymlinks)
                throw new InvalidOperationException("The user running tgstation-server cannot create symlinks! Please try running as an administrative user!");
        }

        public async Task<BridgeResponse> ProcessBridgeRequest(BridgeParameters parameters, CancellationToken cancellationToken)
        {
            if (parameters == null)
                throw new ArgumentNullException(nameof(parameters));

            IBridgeHandler bridgeHandler = null;
            for (var i = 0; bridgeHandler == null && i < 30; ++i)
            {
                // There's a miniscule time period where we could potentially receive a bridge request and not have the registration ready when we launch DD
                // This is a stopgap
                Task delayTask = Task.CompletedTask;
                lock (bridgeHandlers)
                    if (!bridgeHandlers.TryGetValue(parameters.AccessIdentifier, out bridgeHandler))
                        delayTask = asyncDelayer.Delay(TimeSpan.FromMilliseconds(100), cancellationToken);

                await delayTask.ConfigureAwait(false);
            }

            if (bridgeHandler == null)
                lock (bridgeHandlers)
                    if (!bridgeHandlers.TryGetValue(parameters.AccessIdentifier, out bridgeHandler))
                    {
                        logger.LogWarning("Recieved invalid bridge request with accees identifier: {0}", parameters.AccessIdentifier);
                        return null;
                    }

            return await bridgeHandler.ProcessBridgeRequest(parameters, cancellationToken).ConfigureAwait(false);
        }

        public IBridgeRegistration RegisterHandler(IBridgeHandler bridgeHandler)
        {
            if (bridgeHandler == null)
                throw new ArgumentNullException(nameof(bridgeHandler));

            var accessIdentifier = bridgeHandler.DMApiParameters.AccessIdentifier;
            lock (bridgeHandlers)
            {
                bridgeHandlers.Add(accessIdentifier, bridgeHandler);
                logger.LogTrace("Registered bridge handler: {0}", accessIdentifier);
            }

            return new BridgeRegistration(() =>
            {
                lock (bridgeHandlers)
                {
                    bridgeHandlers.Remove(accessIdentifier);
                    logger.LogTrace("Unregistered bridge handler: {0}", accessIdentifier);
                }
            });
        }
    }
}