SetupWizard.cs File Reference

Go to the source code of this file.

Classes
class	Tgstation.Server.Host.Setup.SetupWizard

Namespaces
namespace	Tgstation
namespace	Tgstation.Server
namespace	Tgstation.Server.Host
namespace	Tgstation.Server.Host.Setup

Functions
	Tgstation.Server.Host.Setup.while (true)
async ValueTask< GeneralConfiguration >	ConfigureGeneral (CancellationToken cancellationToken)
	Prompts the user to create a GeneralConfiguration. More...
async ValueTask< FileLoggingConfiguration >	ConfigureLogging (CancellationToken cancellationToken)
	Prompts the user to create a FileLoggingConfiguration. More...
async ValueTask< ElasticsearchConfiguration >	ConfigureElasticsearch (CancellationToken cancellationToken)
	Prompts the user to create a ElasticsearchConfiguration. More...
async ValueTask< ControlPanelConfiguration >	ConfigureControlPanel (CancellationToken cancellationToken)
	Prompts the user to create a ControlPanelConfiguration. More...
async ValueTask< SwarmConfiguration?>	ConfigureSwarm (CancellationToken cancellationToken)
	Prompts the user to create a SwarmConfiguration. More...
async ValueTask	SaveConfiguration (string userConfigFileName, ushort? hostingPort, DatabaseConfiguration databaseConfiguration, GeneralConfiguration newGeneralConfiguration, FileLoggingConfiguration? fileLoggingConfiguration, ElasticsearchConfiguration? elasticsearchConfiguration, ControlPanelConfiguration controlPanelConfiguration, SwarmConfiguration? swarmConfiguration, CancellationToken cancellationToken)
	Saves a given Configuration set to userConfigFileName . More...
async ValueTask	RunWizard (string userConfigFileName, CancellationToken cancellationToken)
	Runs the SetupWizard. More...
async ValueTask	CheckRunWizard (CancellationToken cancellationToken)
	Check if it should and run the SetupWizard if necessary. More...

Function Documentation

CheckRunWizard()

async ValueTask CheckRunWizard

(

CancellationToken

cancellationToken

)

Check if it should and run the SetupWizard if necessary.

Parameters

cancellationToken

The CancellationToken for the operation.

Returns

A ValueTask representing the running operation.

Definition at line 1078 of file SetupWizard.cs.

        {
            var setupWizardMode = generalConfiguration.SetupWizardMode;
            if (setupWizardMode == SetupWizardMode.Never)
                return;
 
            var forceRun = setupWizardMode == SetupWizardMode.Force || setupWizardMode == SetupWizardMode.Only;
            if (!console.Available)
            {
                if (forceRun)
                    throw new InvalidOperationException("Asked to run setup wizard with no console avaliable!");
                return;
            }
 
            var userConfigFileName = ioManager.ConcatPath(
                internalConfiguration.AppSettingsBasePath,
                $"{ServerFactory.AppSettings}.{hostingEnvironment.EnvironmentName}.yml");
 
            async Task HandleSetupCancel()
            {
                // DCTx2: Operation should always run
                await console.WriteAsync(String.Empty, true, default);
                await console.WriteAsync("Aborting setup!", true, default);
            }
 
            Task finalTask = Task.CompletedTask;
            string? originalConsoleTitle = null;
            void SetConsoleTitle()
            {
                if (originalConsoleTitle != null)
                    return;
 
                originalConsoleTitle = console.Title;
                console.SetTitle($"{assemblyInformationProvider.VersionString} Setup Wizard");
            }
 
            // Link passed cancellationToken with cancel key press
            using (var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, console.CancelKeyPress))
            using ((cancellationToken = cts.Token).Register(() => finalTask = HandleSetupCancel()))
                try
                {
                    var exists = await ioManager.FileExists(userConfigFileName, cancellationToken);
                    if (!exists)
                    {
                        var legacyJsonFileName = $"appsettings.{hostingEnvironment.EnvironmentName}.json";
                        exists = await ioManager.FileExists(legacyJsonFileName, cancellationToken);
                        if (exists)
                            userConfigFileName = legacyJsonFileName;
                    }
 
                    bool shouldRunBasedOnAutodetect;
                    if (exists)
                    {
                        var bytes = await ioManager.ReadAllBytes(userConfigFileName, cancellationToken);
                        var contents = Encoding.UTF8.GetString(bytes);
                        var lines = contents.Split('\n', StringSplitOptions.RemoveEmptyEntries);
                        var existingConfigIsEmpty = lines
                            .Select(line => line.Trim())
                            .All(line => line[0] == '#' || line == "{}" || line.Length == 0);
                        shouldRunBasedOnAutodetect = existingConfigIsEmpty;
                    }
                    else
                        shouldRunBasedOnAutodetect = true;
 
                    if (!shouldRunBasedOnAutodetect)
                    {
                        if (forceRun)
                        {
                            SetConsoleTitle();
                            await console.WriteAsync(String.Format(CultureInfo.InvariantCulture, "The configuration settings are requesting the setup wizard be run, but you already appear to have a configuration file ({0})!", userConfigFileName), true, cancellationToken);
 
                            forceRun = await PromptYesNo("Continue running setup wizard?", false, cancellationToken);
                        }
 
                        if (!forceRun)
                            return;
                    }
 
                    SetConsoleTitle();
 
                    if (!String.IsNullOrEmpty(internalConfiguration.MariaDBDefaultRootPassword))
                    {
                        // we can generate the whole thing.
                        var csb = new MySqlConnectionStringBuilder
                        {
                            Server = "127.0.0.1",
                            UserID = "root",
                            Password = internalConfiguration.MariaDBDefaultRootPassword,
                            Database = "tgs",
                        };
 
                        await SaveConfiguration(
                            userConfigFileName,
                            null,
                            new DatabaseConfiguration
                            {
                                ConnectionString = csb.ConnectionString,
                                DatabaseType = DatabaseType.MariaDB,
                                ServerVersion = MasterVersionsAttribute.Instance.RawMariaDBRedistVersion,
                            },
                            new GeneralConfiguration(),
                            null,
                            null,
                            new ControlPanelConfiguration
                            {
                                Enable = true,
                                AllowAnyOrigin = true,
                            },
                            null,
                            cancellationToken);
                    }
                    else
                    {
                        // flush the logs to prevent console conflicts
                        await asyncDelayer.Delay(TimeSpan.FromSeconds(1), cancellationToken);
 
                        await RunWizard(userConfigFileName, cancellationToken);
                    }
                }
                finally
                {
                    await finalTask;
                    if (originalConsoleTitle != null)
                        console.SetTitle(originalConsoleTitle);
                }
        }

References Tgstation.Server.Host.Configuration.DatabaseConfiguration.ConnectionString, Tgstation.Server.Host.Properties.MasterVersionsAttribute.Instance, Tgstation.Server.Host.Properties.MasterVersionsAttribute.RawMariaDBRedistVersion, RunWizard(), and SaveConfiguration().

Referenced by Tgstation.Server.Host.Setup.SetupWizard.ExecuteAsync().

Here is the call graph for this function:

Here is the caller graph for this function:

ConfigureControlPanel()

async ValueTask< ControlPanelConfiguration > ConfigureControlPanel

(

CancellationToken

cancellationToken

)

Prompts the user to create a ControlPanelConfiguration.

Parameters

cancellationToken

The CancellationToken for the operation.

Returns

A ValueTask<TResult> resulting in the new ControlPanelConfiguration.

Definition at line 861 of file SetupWizard.cs.

        {
            var config = new ControlPanelConfiguration
            {
                Enable = await PromptYesNo("Enable the web control panel?", true, cancellationToken),
                AllowAnyOrigin = await PromptYesNo(
                    "Allow web control panels hosted elsewhere to access the server? (Access-Control-Allow-Origin: *)",
                    true,
                    cancellationToken),
            };
 
            if (!config.AllowAnyOrigin)
            {
                await console.WriteAsync("Enter a comma seperated list of CORS allowed origins (optional): ", false, cancellationToken);
                var commaSeperatedOrigins = await console.ReadLineAsync(false, cancellationToken);
                if (!String.IsNullOrWhiteSpace(commaSeperatedOrigins))
                {
                    var splits = commaSeperatedOrigins.Split(',');
                    config.AllowedOrigins = new List<string>(splits.Select(x => x.Trim()));
                }
            }
 
            return config;
        }

Referenced by RunWizard().

Here is the caller graph for this function:

ConfigureElasticsearch()

async ValueTask< ElasticsearchConfiguration > ConfigureElasticsearch

(

CancellationToken

cancellationToken

)

Prompts the user to create a ElasticsearchConfiguration.

Parameters

cancellationToken

The CancellationToken for the operation.

Returns

A ValueTask<TResult> resulting in the new ElasticsearchConfiguration.

Definition at line 809 of file SetupWizard.cs.

        {
            var elasticsearchConfiguration = new ElasticsearchConfiguration();
            await console.WriteAsync(null, true, cancellationToken);
            elasticsearchConfiguration.Enable = await PromptYesNo("Enable logging to an external ElasticSearch server?", false, cancellationToken);
 
            if (elasticsearchConfiguration.Enable)
            {
                do
                {
                    await console.WriteAsync("ElasticSearch server endpoint (Include protocol and port, leave blank for http://127.0.0.1:9200): ", false, cancellationToken);
                    var hostString = await console.ReadLineAsync(false, cancellationToken);
                    if (String.IsNullOrWhiteSpace(hostString))
                        hostString = "http://127.0.0.1:9200";
 
                    if (Uri.TryCreate(hostString, UriKind.Absolute, out var host))
                    {
                        elasticsearchConfiguration.Host = host;
                        break;
                    }
 
                    await console.WriteAsync("Invalid URI!", true, cancellationToken);
                }
                while (true);
 
                do
                {
                    await console.WriteAsync("Enter Elasticsearch username: ", false, cancellationToken);
                    elasticsearchConfiguration.Username = await console.ReadLineAsync(false, cancellationToken);
                    if (!String.IsNullOrWhiteSpace(elasticsearchConfiguration.Username))
                        break;
                }
                while (true);
 
                do
                {
                    await console.WriteAsync("Enter password: ", false, cancellationToken);
                    elasticsearchConfiguration.Password = await console.ReadLineAsync(true, cancellationToken);
                    if (!String.IsNullOrWhiteSpace(elasticsearchConfiguration.Username))
                        break;
                }
                while (true);
            }
 
            return elasticsearchConfiguration;
        }

Referenced by RunWizard().

Here is the caller graph for this function:

ConfigureGeneral()

async ValueTask< GeneralConfiguration > ConfigureGeneral

(

CancellationToken

cancellationToken

)

Prompts the user to create a GeneralConfiguration.

Parameters

cancellationToken

The CancellationToken for the operation.

Returns

A ValueTask<TResult> resulting in the new GeneralConfiguration.

Definition at line 666 of file SetupWizard.cs.

        {
            var newGeneralConfiguration = new GeneralConfiguration
            {
                SetupWizardMode = SetupWizardMode.Never,
            };
 
            do
            {
                await console.WriteAsync(null, true, cancellationToken);
                await console.WriteAsync(String.Format(CultureInfo.InvariantCulture, "Minimum database user password length (leave blank for default of {0}): ", newGeneralConfiguration.MinimumPasswordLength), false, cancellationToken);
                var passwordLengthString = await console.ReadLineAsync(false, cancellationToken);
                if (String.IsNullOrWhiteSpace(passwordLengthString))
                    break;
                if (UInt32.TryParse(passwordLengthString, out var passwordLength) && passwordLength >= 0)
                {
                    newGeneralConfiguration.MinimumPasswordLength = passwordLength;
                    break;
                }
 
                await console.WriteAsync("Please enter a positive integer!", true, cancellationToken);
            }
            while (true);
 
            do
            {
                await console.WriteAsync(null, true, cancellationToken);
                await console.WriteAsync(String.Format(CultureInfo.InvariantCulture, "Default timeout for sending and receiving BYOND topics (ms, 0 for infinite, leave blank for default of {0}): ", newGeneralConfiguration.ByondTopicTimeout), false, cancellationToken);
                var topicTimeoutString = await console.ReadLineAsync(false, cancellationToken);
                if (String.IsNullOrWhiteSpace(topicTimeoutString))
                    break;
                if (UInt32.TryParse(topicTimeoutString, out var topicTimeout) && topicTimeout >= 0)
                {
                    newGeneralConfiguration.ByondTopicTimeout = topicTimeout;
                    break;
                }
 
                await console.WriteAsync("Please enter a positive integer!", true, cancellationToken);
            }
            while (true);
 
            await console.WriteAsync(null, true, cancellationToken);
            await console.WriteAsync("Enter a GitHub personal access token to bypass some rate limits (this is optional and does not require any scopes)", true, cancellationToken);
            await console.WriteAsync("GitHub personal access token: ", false, cancellationToken);
            newGeneralConfiguration.GitHubAccessToken = await console.ReadLineAsync(true, cancellationToken);
            if (String.IsNullOrWhiteSpace(newGeneralConfiguration.GitHubAccessToken))
                newGeneralConfiguration.GitHubAccessToken = null;
 
            newGeneralConfiguration.HostApiDocumentation = await PromptYesNo("Host API Documentation?", false, cancellationToken);
 
            return newGeneralConfiguration;
        }

Referenced by RunWizard().

Here is the caller graph for this function:

ConfigureLogging()

async ValueTask< FileLoggingConfiguration > ConfigureLogging

(

CancellationToken

cancellationToken

)

Prompts the user to create a FileLoggingConfiguration.

Parameters

cancellationToken

The CancellationToken for the operation.

Returns

A ValueTask<TResult> resulting in the new FileLoggingConfiguration.

Definition at line 724 of file SetupWizard.cs.

        {
            var fileLoggingConfiguration = new FileLoggingConfiguration();
            await console.WriteAsync(null, true, cancellationToken);
            fileLoggingConfiguration.Disable = !await PromptYesNo("Enable file logging?", true, cancellationToken);
 
            if (!fileLoggingConfiguration.Disable)
            {
                do
                {
                    await console.WriteAsync("Log file directory path (leave blank for default): ", false, cancellationToken);
                    fileLoggingConfiguration.Directory = await console.ReadLineAsync(false, cancellationToken);
                    if (String.IsNullOrWhiteSpace(fileLoggingConfiguration.Directory))
                    {
                        fileLoggingConfiguration.Directory = null;
                        break;
                    }
 
                    // test a write of it
                    await console.WriteAsync(null, true, cancellationToken);
                    await console.WriteAsync("Testing directory access...", true, cancellationToken);
                    try
                    {
                        await ioManager.CreateDirectory(fileLoggingConfiguration.Directory, cancellationToken);
                        var testFile = ioManager.ConcatPath(fileLoggingConfiguration.Directory, String.Format(CultureInfo.InvariantCulture, "WizardAccesTest.{0}.deleteme", Guid.NewGuid()));
                        await ioManager.WriteAllBytes(testFile, Array.Empty<byte>(), cancellationToken);
                        try
                        {
                            await ioManager.DeleteFile(testFile, cancellationToken);
                        }
                        catch (OperationCanceledException)
                        {
                            throw;
                        }
                        catch (Exception e)
                        {
                            await console.WriteAsync(String.Format(CultureInfo.InvariantCulture, "Error deleting test log file: {0}", testFile), true, cancellationToken);
                            await console.WriteAsync(e.Message, true, cancellationToken);
                            await console.WriteAsync(null, true, cancellationToken);
                        }
 
                        break;
                    }
                    catch (OperationCanceledException)
                    {
                        throw;
                    }
                    catch (Exception e)
                    {
                        await console.WriteAsync(e.Message, true, cancellationToken);
                        await console.WriteAsync(null, true, cancellationToken);
                        await console.WriteAsync("Please verify the path is valid and you have access to it!", true, cancellationToken);
                    }
                }
                while (true);
 
                async ValueTask<LogLevel?> PromptLogLevel(string question)
                {
                    do
                    {
                        await console.WriteAsync(null, true, cancellationToken);
                        await console.WriteAsync(question, true, cancellationToken);
                        await console.WriteAsync(String.Format(CultureInfo.InvariantCulture, "Enter one of {0}/{1}/{2}/{3}/{4}/{5} (leave blank for default): ", nameof(LogLevel.Trace), nameof(LogLevel.Debug), nameof(LogLevel.Information), nameof(LogLevel.Warning), nameof(LogLevel.Error), nameof(LogLevel.Critical)), false, cancellationToken);
                        var responseString = await console.ReadLineAsync(false, cancellationToken);
                        if (String.IsNullOrWhiteSpace(responseString))
                            return null;
                        if (Enum.TryParse<LogLevel>(responseString, out var logLevel) && logLevel != LogLevel.None)
                            return logLevel;
                        await console.WriteAsync("Invalid log level!", true, cancellationToken);
                    }
                    while (true);
                }
 
                fileLoggingConfiguration.LogLevel = await PromptLogLevel(String.Format(CultureInfo.InvariantCulture, "Enter the level limit for normal logs (default {0}).", fileLoggingConfiguration.LogLevel)) ?? fileLoggingConfiguration.LogLevel;
                fileLoggingConfiguration.MicrosoftLogLevel = await PromptLogLevel(String.Format(CultureInfo.InvariantCulture, "Enter the level limit for Microsoft logs (VERY verbose, default {0}).", fileLoggingConfiguration.MicrosoftLogLevel)) ?? fileLoggingConfiguration.MicrosoftLogLevel;
            }
 
            return fileLoggingConfiguration;
        }

Referenced by RunWizard().

Here is the caller graph for this function:

ConfigureSwarm()

async ValueTask< SwarmConfiguration?> ConfigureSwarm

(

CancellationToken

cancellationToken

)

Prompts the user to create a SwarmConfiguration.

Parameters

cancellationToken

The CancellationToken for the operation.

Returns

A ValueTask<TResult> resulting in the new SwarmConfiguration.

Definition at line 891 of file SetupWizard.cs.

        {
            var enable = await PromptYesNo("Enable swarm mode?", false, cancellationToken);
            if (!enable)
                return null;
 
            string identifer;
            do
            {
                await console.WriteAsync("Enter this server's identifer: ", false, cancellationToken);
                identifer = await console.ReadLineAsync(false, cancellationToken);
            }
            while (String.IsNullOrWhiteSpace(identifer));
 
            async ValueTask<Uri> ParseAddress(string question)
            {
                var first = true;
                Uri? address;
                do
                {
                    if (first)
                        first = false;
                    else
                        await console.WriteAsync("Invalid address!", true, cancellationToken);
 
                    await console.WriteAsync(question, false, cancellationToken);
                    var addressString = await console.ReadLineAsync(false, cancellationToken);
                    if (Uri.TryCreate(addressString, UriKind.Absolute, out address)
                        && address.Scheme != Uri.UriSchemeHttp
                        && address.Scheme != Uri.UriSchemeHttps)
                        address = null;
                }
                while (address == null);
 
                return address;
            }
 
            var address = await ParseAddress("Enter this server's INTERNAL http(s) address: ");
            var publicAddress = await ParseAddress("Enter this server's PUBLIC https(s) address: ");
            string privateKey;
            do
            {
                await console.WriteAsync("Enter the swarm private key: ", false, cancellationToken);
                privateKey = await console.ReadLineAsync(false, cancellationToken);
            }
            while (String.IsNullOrWhiteSpace(privateKey));
 
            var controller = await PromptYesNo("Is this server the swarm's controller? (y/n): ", null, cancellationToken);
            Uri? controllerAddress = null;
            if (!controller)
                controllerAddress = await ParseAddress("Enter the swarm controller's HTTP(S) address: ");
 
            return new SwarmConfiguration
            {
                Address = address,
                PublicAddress = publicAddress,
                ControllerAddress = controllerAddress,
                Identifier = identifer,
                PrivateKey = privateKey,
            };
        }

Referenced by RunWizard().

Here is the caller graph for this function:

RunWizard()

async ValueTask RunWizard	(	string	userConfigFileName,
		CancellationToken	cancellationToken
	)

Runs the SetupWizard.

Parameters

userConfigFileName	The path to the settings json to build.
cancellationToken	The CancellationToken for the operation.

Returns

A ValueTask representing the running operation.

Definition at line 1038 of file SetupWizard.cs.

        {
            // welcome message
            await console.WriteAsync($"Welcome to {Constants.CanonicalPackageName}!", true, cancellationToken);
            await console.WriteAsync("This wizard will help you configure your server.", true, cancellationToken);
 
            var hostingPort = await PromptForHostingPort(cancellationToken);
 
            var databaseConfiguration = await ConfigureDatabase(cancellationToken);
 
            var newGeneralConfiguration = await ConfigureGeneral(cancellationToken);
 
            var fileLoggingConfiguration = await ConfigureLogging(cancellationToken);
 
            var elasticSearchConfiguration = await ConfigureElasticsearch(cancellationToken);
 
            var controlPanelConfiguration = await ConfigureControlPanel(cancellationToken);
 
            var swarmConfiguration = await ConfigureSwarm(cancellationToken);
 
            await console.WriteAsync(null, true, cancellationToken);
            await console.WriteAsync(String.Format(CultureInfo.InvariantCulture, "Configuration complete! Saving to {0}", userConfigFileName), true, cancellationToken);
 
            await SaveConfiguration(
                userConfigFileName,
                hostingPort,
                databaseConfiguration,
                newGeneralConfiguration,
                fileLoggingConfiguration,
                elasticSearchConfiguration,
                controlPanelConfiguration,
                swarmConfiguration,
                cancellationToken);
        }

References ConfigureControlPanel(), ConfigureElasticsearch(), ConfigureGeneral(), ConfigureLogging(), ConfigureSwarm(), and SaveConfiguration().

Referenced by CheckRunWizard().

Here is the call graph for this function:

Here is the caller graph for this function:

SaveConfiguration()

async ValueTask SaveConfiguration	(	string	userConfigFileName,
		ushort?	hostingPort,
		DatabaseConfiguration	databaseConfiguration,
		GeneralConfiguration	newGeneralConfiguration,
		FileLoggingConfiguration?	fileLoggingConfiguration,
		ElasticsearchConfiguration?	elasticsearchConfiguration,
		ControlPanelConfiguration	controlPanelConfiguration,
		SwarmConfiguration?	swarmConfiguration,
		CancellationToken	cancellationToken
	)

Saves a given Configuration set to userConfigFileName .

Parameters

userConfigFileName	The file to save the Configuration to.
hostingPort	The hosting port to save.
databaseConfiguration	The DatabaseConfiguration to save.
newGeneralConfiguration	The GeneralConfiguration to save.
fileLoggingConfiguration	The FileLoggingConfiguration to save.
elasticsearchConfiguration	The ElasticsearchConfiguration to save.
controlPanelConfiguration	The ControlPanelConfiguration to save.
swarmConfiguration	The SwarmConfiguration to save.
cancellationToken	The CancellationToken for the operation.

Returns

A ValueTask representing the running operation.

Definition at line 966 of file SetupWizard.cs.

        {
            newGeneralConfiguration.ApiPort = hostingPort ?? GeneralConfiguration.DefaultApiPort;
            newGeneralConfiguration.ConfigVersion = GeneralConfiguration.CurrentConfigVersion;
            var map = new Dictionary<string, object?>()
            {
                { DatabaseConfiguration.Section, databaseConfiguration },
                { GeneralConfiguration.Section, newGeneralConfiguration },
                { FileLoggingConfiguration.Section, fileLoggingConfiguration },
                { ElasticsearchConfiguration.Section, elasticsearchConfiguration },
                { ControlPanelConfiguration.Section, controlPanelConfiguration },
                { SwarmConfiguration.Section, swarmConfiguration },
            };
 
            var versionConverter = new VersionConverter();
            var builder = new SerializerBuilder()
                .WithTypeConverter(versionConverter);
 
            if (userConfigFileName.EndsWith(".json", StringComparison.OrdinalIgnoreCase))
                builder.JsonCompatible();
 
            var serializer = new SerializerBuilder()
                .WithTypeConverter(versionConverter)
                .Build();
 
            var serializedYaml = serializer.Serialize(map);
 
            // big hack, but, prevent the default control panel channel from being overridden
            serializedYaml = serializedYaml.Replace(
                $"\n  {nameof(ControlPanelConfiguration.Channel)}: ",
                String.Empty,
                StringComparison.Ordinal)
                .Replace("\r", String.Empty, StringComparison.Ordinal);
 
            var configBytes = Encoding.UTF8.GetBytes(serializedYaml);
 
            try
            {
                await ioManager.WriteAllBytes(
                    userConfigFileName,
                    configBytes,
                    cancellationToken);
            }
            catch (Exception e) when (e is not OperationCanceledException)
            {
                await console.WriteAsync(e.Message, true, cancellationToken);
                await console.WriteAsync(null, true, cancellationToken);
                await console.WriteAsync("For your convienence, here's the yaml we tried to write out:", true, cancellationToken);
                await console.WriteAsync(null, true, cancellationToken);
                await console.WriteAsync(serializedYaml, true, cancellationToken);
                await console.WriteAsync(null, true, cancellationToken);
                await console.WriteAsync("Press any key to exit...", true, cancellationToken);
                await console.PressAnyKeyAsync(cancellationToken);
                throw new OperationCanceledException();
            }
        }

References Tgstation.Server.Host.Configuration.GeneralConfiguration.CurrentConfigVersion, Tgstation.Server.Host.Configuration.GeneralConfiguration.DefaultApiPort, Tgstation.Server.Host.Configuration.ControlPanelConfiguration.Section, Tgstation.Server.Host.Configuration.DatabaseConfiguration.Section, Tgstation.Server.Host.Configuration.ElasticsearchConfiguration.Section, Tgstation.Server.Host.Configuration.FileLoggingConfiguration.Section, Tgstation.Server.Host.Configuration.GeneralConfiguration.Section, and Tgstation.Server.Host.Configuration.SwarmConfiguration.Section.

Referenced by CheckRunWizard(), and RunWizard().

Here is the caller graph for this function: