mfgames-nitride-cil/src/Nitride/NitrideBuilder.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Autofac;
using Autofac.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Serilog;
using Zio;
using Zio.FileSystems;

namespace Nitride
{
    /// <summary>
    /// A class that implements a builder pattern for gathering all the
    /// components of a static website. Once everything is build, then calling
    /// `Build()` will generate the resulting website.
    /// </summary>
    public class NitrideBuilder
    {
        private readonly string[] arguments;

        private readonly List<Action<ContainerBuilder>>
            configureContainerCallbacks;

        /// <summary>
        /// An event that is called after the container is built but before
        /// the application runs.
        /// </summary>
        private readonly List<Action<NitrideBuilder, ILifetimeScope>>
            configureSiteCallbacks;

        private NitrideLoggingBuilder loggingBuilder;

        public NitrideBuilder(string[] arguments)
        {
            this.arguments = arguments;
            this.loggingBuilder = new NitrideLoggingBuilder();
            this.configureSiteCallbacks =
                new List<Action<NitrideBuilder, ILifetimeScope>>();
            this.configureContainerCallbacks =
                new List<Action<ContainerBuilder>>();
        }

        /// <summary>
        /// Gets or sets the builder used to set up logging.
        /// </summary>
        /// <exception cref="ArgumentNullException"></exception>
        public NitrideLoggingBuilder LoggingBuilder
        {
            get => this.loggingBuilder;
            set => this.loggingBuilder =
                value ?? throw new ArgumentNullException(nameof(value));
        }

        /// <summary>
        /// Gets or sets the input directory to automatically register as the
        /// source of the files. If this is not set, then no Zio.IFileSystem
        /// will be registered and it will have to be done manually.
        /// </summary>
        public DirectoryInfo? RootDirectory { get; set; }

        /// <summary>
        /// Generates or builds the resulting website based on the given
        /// command.
        /// </summary>
        /// <returns>The task once completed.</returns>
        public async Task<int> BuildAsync()
        {
            await Host
                .CreateDefaultBuilder(this.arguments)
                .UseSerilog()
                .UseServiceProviderFactory(new AutofacServiceProviderFactory())
                .ConfigureServices(this.ConfigureServices)
                .ConfigureContainer<ContainerBuilder>(this.ConfigureContainer)
                .RunConsoleAsync();

            return 0;
        }

        /// <summary>
        /// Allows for configuration of the Autofac container to register
        /// additional types, pipelines, and modules.
        /// </summary>
        /// <param name="callback">The callback to configure the container.</param>
        /// <returns>The builder to chain operations.</returns>
        public NitrideBuilder ConfigureContainer(
            Action<ContainerBuilder> callback)
        {
            this.configureContainerCallbacks.Add(callback);
            return this;
        }

        /// <summary>
        /// Overrides the logging configuration for customization.
        /// </summary>
        /// <param name="callback"></param>
        /// <returns>The builder to chain methods.</returns>
        public NitrideBuilder ConfigureLogging(
            Func<LoggerConfiguration, ILogger> callback)
        {
            this.loggingBuilder.Callback = callback;
            return this;
        }

        /// <summary>
        /// Registers a callback to be called after the container is built but
        /// before the application runs.
        /// </summary>
        /// <param name="callback">The callback to register.</param>
        /// <returns>The builder for chaining.</returns>
        public NitrideBuilder ConfigureSite(
            Action<NitrideBuilder, ILifetimeScope> callback)
        {
            this.configureSiteCallbacks.Add(callback);
            return this;
        }

        /// <summary>
        /// Sets the root directory to a common value by creating a
        /// IFileSystem (from Zio) of the root directory and registering it.
        /// This will be used for both input and output.
        /// </summary>
        /// <param name="directory">
        /// The path to the directory that represents "/" while
        /// building.
        /// </param>
        /// <returns>The builder to chain calls.</returns>
        public NitrideBuilder WithRootDirectory(DirectoryInfo directory)
        {
            this.RootDirectory = directory;
            return this;
        }

        private void ConfigureContainer(ContainerBuilder builder)
        {
            // We want to get logging up and running as soon as possible. We
            // also hook up the logging to the process exit in an attempt to
            // make sure the logger is properly flushed before exiting.
            ILogger logger = this.loggingBuilder
                .Setup(builder)
                .ForContext<NitrideBuilder>();

            AppDomain.CurrentDomain.ProcessExit +=
                (_, _) => Log.CloseAndFlush();

            // Hook up the rest of the modules.
            builder.RegisterModule<NitrideModule>();

            // Set up our file system.
            this.RegisterRootDirectory(logger, builder);

            // Finish up the registration by running our events.
            foreach (var callback in this.configureSiteCallbacks)
            {
                builder.RegisterBuildCallback(scope => callback(this, scope));
            }

            foreach (var configureContainer in this.configureContainerCallbacks)
            {
                configureContainer.Invoke(builder);
            }
        }

        private void ConfigureServices(IServiceCollection services)
        {
            services.AddAutofac();
            services.AddHostedService<NitrideService>();
        }

        private void RegisterRootDirectory(
            ILogger logger,
            ContainerBuilder builder)
        {
            if (this.RootDirectory == null)
            {
                logger.Verbose("No root directory is registered");
                return;
            }

            logger.Debug(
                "Setting root directory to {Path}",
                this.RootDirectory.FullName);

            var rootFileSystem = new PhysicalFileSystem();
            var subFileSystem = new SubFileSystem(
                rootFileSystem,
                this.RootDirectory.FullName);

            builder.RegisterInstance(subFileSystem)
                .As<IFileSystem>()
                .SingleInstance();
        }
    }
}