path: root/zenserver/config.cpp

// Copyright Epic Games, Inc. All Rights Reserved.

#include "config.h"

#include "diag/logging.h"

#include <zencore/crypto.h>
#include <zencore/fmtutils.h>
#include <zencore/iobuffer.h>
#include <zencore/string.h>
#include <zenhttp/zenhttp.h>

ZEN_THIRD_PARTY_INCLUDES_START
#include <fmt/format.h>
#include <zencore/logging.h>
#include <cxxopts.hpp>
#include <sol/sol.hpp>
ZEN_THIRD_PARTY_INCLUDES_END

#if ZEN_PLATFORM_WINDOWS
#	include <conio.h>
#else
#	include <pwd.h>
#endif

#if ZEN_PLATFORM_WINDOWS

// Used for getting My Documents for default data directory
#	include <ShlObj.h>
#	pragma comment(lib, "shell32.lib")

std::filesystem::path
PickDefaultStateDirectory()
{
	// Pick sensible default
	PWSTR	programDataDir = nullptr;
	HRESULT hRes		   = SHGetKnownFolderPath(FOLDERID_ProgramData, 0, NULL, &programDataDir);

	if (SUCCEEDED(hRes))
	{
		std::filesystem::path finalPath(programDataDir);
		finalPath /= L"Epic\\Zen\\Data";
		::CoTaskMemFree(programDataDir);

		return finalPath;
	}

	return L"";
}

#else

std::filesystem::path
PickDefaultStateDirectory()
{
	int			  UserId = getuid();
	const passwd* Passwd = getpwuid(UserId);
	return std::filesystem::path(Passwd->pw_dir) / ".zen";
}

#endif

void
ValidateOptions(ZenServerOptions& ServerOptions)
{
	if (ServerOptions.EncryptionKey.empty() == false)
	{
		const auto Key = zen::AesKey256Bit::FromString(ServerOptions.EncryptionKey);

		if (Key.IsValid() == false)
		{
			throw cxxopts::OptionParseException("Invalid AES encryption key");
		}
	}

	if (ServerOptions.EncryptionIV.empty() == false)
	{
		const auto IV = zen::AesIV128Bit::FromString(ServerOptions.EncryptionIV);

		if (IV.IsValid() == false)
		{
			throw cxxopts::OptionParseException("Invalid AES initialization vector");
		}
	}
}

UpstreamCachePolicy
ParseUpstreamCachePolicy(std::string_view Options)
{
	if (Options == "readonly")
	{
		return UpstreamCachePolicy::Read;
	}
	else if (Options == "writeonly")
	{
		return UpstreamCachePolicy::Write;
	}
	else if (Options == "disabled")
	{
		return UpstreamCachePolicy::Disabled;
	}
	else
	{
		return UpstreamCachePolicy::ReadWrite;
	}
}

void ParseConfigFile(const std::filesystem::path& Path, ZenServerOptions& ServerOptions);

void
ParseCliOptions(int argc, char* argv[], ZenServerOptions& ServerOptions)
{
#if ZEN_WITH_HTTPSYS
	const char* DefaultHttp = "httpsys";
#else
	const char* DefaultHttp = "asio";
#endif

	// Note to those adding future options; std::filesystem::path-type options
	// must be read into a std::string first. As of cxxopts-3.0.0 it uses a >>
	// stream operator to convert argv value into the options type. std::fs::path
	// expects paths in streams to be quoted but argv paths are unquoted. By
	// going into a std::string first, paths with whitespace parse correctly.
	std::string DataDir;
	std::string ContentDir;
	std::string AbsLogFile;
	std::string ConfigFile;

	cxxopts::Options options("zenserver", "Zen Server");
	options.add_options()("dedicated",
						  "Enable dedicated server mode",
						  cxxopts::value<bool>(ServerOptions.IsDedicated)->default_value("false"));
	options.add_options()("d, debug", "Enable debugging", cxxopts::value<bool>(ServerOptions.IsDebug)->default_value("false"));
	options.add_options()("help", "Show command line help");
	options.add_options()("t, test", "Enable test mode", cxxopts::value<bool>(ServerOptions.IsTest)->default_value("false"));
	options.add_options()("log-id", "Specify id for adding context to log output", cxxopts::value<std::string>(ServerOptions.LogId));
	options.add_options()("data-dir", "Specify persistence root", cxxopts::value<std::string>(DataDir));
	options.add_options()("content-dir", "Frontend content directory", cxxopts::value<std::string>(ContentDir));
	options.add_options()("abslog", "Path to log file", cxxopts::value<std::string>(AbsLogFile));
	options.add_options()("config", "Path to Lua config file", cxxopts::value<std::string>(ConfigFile));
	options.add_options()("no-sentry",
						  "Disable Sentry crash handler",
						  cxxopts::value<bool>(ServerOptions.NoSentry)->default_value("false"));

	options.add_option("security",
					   "",
					   "encryption-aes-key",
					   "256 bit AES encryption key",
					   cxxopts::value<std::string>(ServerOptions.EncryptionKey),
					   "");

	options.add_option("security",
					   "",
					   "encryption-aes-iv",
					   "128 bit AES encryption initialization vector",
					   cxxopts::value<std::string>(ServerOptions.EncryptionIV),
					   "");
	options
		.add_option("lifetime", "", "owner-pid", "Specify owning process id", cxxopts::value<int>(ServerOptions.OwnerPid), "<identifier>");
	options.add_option("lifetime",
					   "",
					   "child-id",
					   "Specify id which can be used to signal parent",
					   cxxopts::value<std::string>(ServerOptions.ChildId),
					   "<identifier>");

#if ZEN_PLATFORM_WINDOWS
	options.add_option("lifetime",
					   "",
					   "install",
					   "Install zenserver as a Windows service",
					   cxxopts::value<bool>(ServerOptions.InstallService),
					   "");
	options.add_option("lifetime",
					   "",
					   "uninstall",
					   "Uninstall zenserver as a Windows service",
					   cxxopts::value<bool>(ServerOptions.UninstallService),
					   "");
#endif

	options.add_option("network",
					   "",
					   "http",
					   "Select HTTP server implementation (asio|httpsys|null)",
					   cxxopts::value<std::string>(ServerOptions.HttpServerClass)->default_value(DefaultHttp),
					   "<http class>");

	options.add_option("network",
					   "p",
					   "port",
					   "Select HTTP port",
					   cxxopts::value<int>(ServerOptions.BasePort)->default_value("1337"),
					   "<port number>");

	options.add_option("network",
					   "",
					   "websocket-port",
					   "Websocket server port",
					   cxxopts::value<int>(ServerOptions.WebSocketPort)->default_value("0"),
					   "<port number>");

	options.add_option("network",
					   "",
					   "websocket-threads",
					   "Number of websocket I/O thread(s) (0 == hardware concurrency)",
					   cxxopts::value<int>(ServerOptions.WebSocketThreads)->default_value("0"),
					   "");

#if ZEN_ENABLE_MESH
	options.add_option("network",
					   "m",
					   "mesh",
					   "Enable mesh network",
					   cxxopts::value<bool>(ServerOptions.MeshEnabled)->default_value("false"),
					   "");
#endif

#if ZEN_WITH_TRACE
	options.add_option("ue-trace",
					   "",
					   "tracehost",
					   "Hostname to send the trace to",
					   cxxopts::value<std::string>(ServerOptions.TraceHost)->default_value(""),
					   "");

	options.add_option("ue-trace",
					   "",
					   "tracefile",
					   "Path to write a trace to",
					   cxxopts::value<std::string>(ServerOptions.TraceFile)->default_value(""),
					   "");
#endif	// ZEN_WITH_TRACE

	options.add_option("diagnostics",
					   "",
					   "crash",
					   "Simulate a crash",
					   cxxopts::value<bool>(ServerOptions.ShouldCrash)->default_value("false"),
					   "");

	std::string UpstreamCachePolicyOptions;
	options.add_option("cache",
					   "",
					   "upstream-cache-policy",
					   "",
					   cxxopts::value<std::string>(UpstreamCachePolicyOptions)->default_value(""),
					   "Upstream cache policy (readwrite|readonly|writeonly|disabled)");

	options.add_option("cache",
					   "",
					   "upstream-jupiter-url",
					   "URL to a Jupiter instance",
					   cxxopts::value<std::string>(ServerOptions.UpstreamCacheConfig.JupiterConfig.Url)->default_value(""),
					   "");

	options.add_option("cache",
					   "",
					   "upstream-jupiter-oauth-url",
					   "URL to the OAuth provier",
					   cxxopts::value<std::string>(ServerOptions.UpstreamCacheConfig.JupiterConfig.OAuthUrl)->default_value(""),
					   "");

	options.add_option("cache",
					   "",
					   "upstream-jupiter-oauth-clientid",
					   "The OAuth client ID",
					   cxxopts::value<std::string>(ServerOptions.UpstreamCacheConfig.JupiterConfig.OAuthClientId)->default_value(""),
					   "");

	options.add_option("cache",
					   "",
					   "upstream-jupiter-oauth-clientsecret",
					   "The OAuth client secret",
					   cxxopts::value<std::string>(ServerOptions.UpstreamCacheConfig.JupiterConfig.OAuthClientSecret)->default_value(""),
					   "");

	options.add_option("cache",
					   "",
					   "upstream-jupiter-openid-provider",
					   "Name of a registered Open ID provider",
					   cxxopts::value<std::string>(ServerOptions.UpstreamCacheConfig.JupiterConfig.OpenIdProvider)->default_value(""),
					   "");

	options.add_option("cache",
					   "",
					   "upstream-jupiter-token",
					   "A static authentication token",
					   cxxopts::value<std::string>(ServerOptions.UpstreamCacheConfig.JupiterConfig.AccessToken)->default_value(""),
					   "");

	options.add_option("cache",
					   "",
					   "upstream-jupiter-namespace",
					   "The Common Blob Store API namespace",
					   cxxopts::value<std::string>(ServerOptions.UpstreamCacheConfig.JupiterConfig.Namespace)->default_value(""),
					   "");

	options.add_option("cache",
					   "",
					   "upstream-jupiter-namespace-ddc",
					   "The lecacy DDC namespace",
					   cxxopts::value<std::string>(ServerOptions.UpstreamCacheConfig.JupiterConfig.DdcNamespace)->default_value(""),
					   "");

	options.add_option("cache",
					   "",
					   "upstream-zen-url",
					   "URL to remote Zen server. Use a comma separated list to choose the one with the best latency.",
					   cxxopts::value<std::vector<std::string>>(ServerOptions.UpstreamCacheConfig.ZenConfig.Urls),
					   "");

	options.add_option("cache",
					   "",
					   "upstream-zen-dns",
					   "DNS that resolves to one or more Zen server instance(s)",
					   cxxopts::value<std::vector<std::string>>(ServerOptions.UpstreamCacheConfig.ZenConfig.Dns),
					   "");

	options.add_option("cache",
					   "",
					   "upstream-thread-count",
					   "Number of threads used for upstream procsssing",
					   cxxopts::value<int32_t>(ServerOptions.UpstreamCacheConfig.UpstreamThreadCount)->default_value("4"),
					   "");

	options.add_option("cache",
					   "",
					   "upstream-connect-timeout-ms",
					   "Connect timeout in millisecond(s). Default 5000 ms.",
					   cxxopts::value<int32_t>(ServerOptions.UpstreamCacheConfig.ConnectTimeoutMilliseconds)->default_value("5000"),
					   "");

	options.add_option("cache",
					   "",
					   "upstream-timeout-ms",
					   "Timeout in millisecond(s). Default 0 ms",
					   cxxopts::value<int32_t>(ServerOptions.UpstreamCacheConfig.TimeoutMilliseconds)->default_value("0"),
					   "");

	options.add_option("compute",
					   "",
					   "upstream-horde-url",
					   "URL to a Horde instance.",
					   cxxopts::value<std::string>(ServerOptions.UpstreamCacheConfig.HordeConfig.Url)->default_value(""),
					   "");

	options.add_option("compute",
					   "",
					   "upstream-horde-oauth-url",
					   "URL to the OAuth provier",
					   cxxopts::value<std::string>(ServerOptions.UpstreamCacheConfig.HordeConfig.OAuthUrl)->default_value(""),
					   "");

	options.add_option("compute",
					   "",
					   "upstream-horde-oauth-clientid",
					   "The OAuth client ID",
					   cxxopts::value<std::string>(ServerOptions.UpstreamCacheConfig.HordeConfig.OAuthClientId)->default_value(""),
					   "");

	options.add_option("compute",
					   "",
					   "upstream-horde-oauth-clientsecret",
					   "The OAuth client secret",
					   cxxopts::value<std::string>(ServerOptions.UpstreamCacheConfig.HordeConfig.OAuthClientSecret)->default_value(""),
					   "");

	options.add_option("compute",
					   "",
					   "upstream-horde-openid-provider",
					   "Name of a registered Open ID provider",
					   cxxopts::value<std::string>(ServerOptions.UpstreamCacheConfig.HordeConfig.OpenIdProvider)->default_value(""),
					   "");

	options.add_option("compute",
					   "",
					   "upstream-horde-token",
					   "A static authentication token",
					   cxxopts::value<std::string>(ServerOptions.UpstreamCacheConfig.HordeConfig.AccessToken)->default_value(""),
					   "");

	options.add_option("compute",
					   "",
					   "upstream-horde-storage-url",
					   "URL to a Horde Storage instance.",
					   cxxopts::value<std::string>(ServerOptions.UpstreamCacheConfig.HordeConfig.StorageUrl)->default_value(""),
					   "");

	options.add_option("compute",
					   "",
					   "upstream-horde-storage-oauth-url",
					   "URL to the OAuth provier",
					   cxxopts::value<std::string>(ServerOptions.UpstreamCacheConfig.HordeConfig.StorageOAuthUrl)->default_value(""),
					   "");

	options.add_option("compute",
					   "",
					   "upstream-horde-storage-oauth-clientid",
					   "The OAuth client ID",
					   cxxopts::value<std::string>(ServerOptions.UpstreamCacheConfig.HordeConfig.StorageOAuthClientId)->default_value(""),
					   "");

	options.add_option(
		"compute",
		"",
		"upstream-horde-storage-oauth-clientsecret",
		"The OAuth client secret",
		cxxopts::value<std::string>(ServerOptions.UpstreamCacheConfig.HordeConfig.StorageOAuthClientSecret)->default_value(""),
		"");

	options.add_option("compute",
					   "",
					   "upstream-horde-storage-openid-provider",
					   "Name of a registered Open ID provider",
					   cxxopts::value<std::string>(ServerOptions.UpstreamCacheConfig.HordeConfig.StorageOpenIdProvider)->default_value(""),
					   "");

	options.add_option("compute",
					   "",
					   "upstream-horde-storage-token",
					   "A static authentication token",
					   cxxopts::value<std::string>(ServerOptions.UpstreamCacheConfig.HordeConfig.StorageAccessToken)->default_value(""),
					   "");

	options.add_option("compute",
					   "",
					   "upstream-horde-cluster",
					   "The Horde compute cluster id",
					   cxxopts::value<std::string>(ServerOptions.UpstreamCacheConfig.HordeConfig.Cluster)->default_value(""),
					   "");

	options.add_option("compute",
					   "",
					   "upstream-horde-namespace",
					   "The Jupiter namespace to use with Horde compute",
					   cxxopts::value<std::string>(ServerOptions.UpstreamCacheConfig.HordeConfig.Namespace)->default_value(""),
					   "");

	options.add_option("gc",
					   "",
					   "gc-enabled",
					   "Whether garbage collection is enabled or not.",
					   cxxopts::value<bool>(ServerOptions.GcConfig.Enabled)->default_value("true"),
					   "");

	options.add_option("gc",
					   "",
					   "gc-small-objects",
					   "Whether garbage collection is enabled or not.",
					   cxxopts::value<bool>(ServerOptions.GcConfig.CollectSmallObjects)->default_value("true"),
					   "");

	options.add_option("gc",
					   "",
					   "gc-interval-seconds",
					   "Garbage collection interval in seconds. Default set to 0 (Off).",
					   cxxopts::value<int32_t>(ServerOptions.GcConfig.IntervalSeconds)->default_value("0"),
					   "");

	options.add_option("gc",
					   "",
					   "gc-cache-duration-seconds",
					   "Max duration in seconds before Z$ entries get evicted.",
					   cxxopts::value<int32_t>(ServerOptions.GcConfig.Cache.MaxDurationSeconds)->default_value("86400"),
					   "");

	options.add_option("gc",
					   "",
					   "disk-reserve-size",
					   "Size of gc disk reserve in bytes.",
					   cxxopts::value<uint64_t>(ServerOptions.GcConfig.DiskReserveSize)->default_value("268435456"),
					   "");

	options.add_option("gc",
					   "",
					   "gc-monitor-interval-seconds",
					   "Garbage collection monitoring interval in seconds.",
					   cxxopts::value<int32_t>(ServerOptions.GcConfig.MonitorIntervalSeconds)->default_value("30"),
					   "");
	try
	{
		auto result = options.parse(argc, argv);

		if (result.count("help"))
		{
			zen::logging::ConsoleLog().info("{}", options.help());
#if ZEN_PLATFORM_WINDOWS
			zen::logging::ConsoleLog().info("Press any key to exit!");
			_getch();
#else
			// Assume the user's in a terminal on all other platforms and that
			// they'll use less/more/etc. if need be.
#endif
			exit(0);
		}

		auto MakeSafePath = [](const std::string& Path) {
#if ZEN_PLATFORM_WINDOWS
			if (Path.empty())
			{
				return Path;
			}

			std::string FixedPath = Path;
			std::replace(FixedPath.begin(), FixedPath.end(), '/', '\\');
			if (!FixedPath.starts_with("\\\\?\\"))
			{
				FixedPath.insert(0, "\\\\?\\");
			}
			return FixedPath;
#else
			return Path;
#endif
		};

		ServerOptions.DataDir						  = MakeSafePath(DataDir);
		ServerOptions.ContentDir					  = MakeSafePath(ContentDir);
		ServerOptions.AbsLogFile					  = MakeSafePath(AbsLogFile);
		ServerOptions.ConfigFile					  = MakeSafePath(ConfigFile);
		ServerOptions.UpstreamCacheConfig.CachePolicy = ParseUpstreamCachePolicy(UpstreamCachePolicyOptions);

		if (!ServerOptions.ConfigFile.empty())
		{
			ParseConfigFile(ServerOptions.ConfigFile, ServerOptions);
		}
		else
		{
			ParseConfigFile(ServerOptions.DataDir / "zen_cfg.lua", ServerOptions);
		}

		ValidateOptions(ServerOptions);
	}
	catch (cxxopts::OptionParseException& e)
	{
		zen::logging::ConsoleLog().error("Error parsing zenserver arguments: {}\n\n{}", e.what(), options.help());

		throw;
	}

	if (ServerOptions.DataDir.empty())
	{
		ServerOptions.DataDir = PickDefaultStateDirectory();
	}

	if (ServerOptions.AbsLogFile.empty())
	{
		ServerOptions.AbsLogFile = ServerOptions.DataDir / "logs" / "zenserver.log";
	}
}

void
ParseConfigFile(const std::filesystem::path& Path, ZenServerOptions& ServerOptions)
{
	zen::IoBuffer LuaScript = zen::IoBufferBuilder::MakeFromFile(Path);

	if (LuaScript)
	{
		sol::state lua;

		lua.open_libraries(sol::lib::base);

		lua.set_function("getenv", [&](const std::string env) -> sol::object {
#if ZEN_PLATFORM_WINDOWS
			std::wstring EnvVarValue;
			size_t		 RequiredSize = 0;
			std::wstring EnvWide	  = zen::Utf8ToWide(env);
			_wgetenv_s(&RequiredSize, nullptr, 0, EnvWide.c_str());

			if (RequiredSize == 0)
				return sol::make_object(lua, sol::lua_nil);

			EnvVarValue.resize(RequiredSize);
			_wgetenv_s(&RequiredSize, EnvVarValue.data(), RequiredSize, EnvWide.c_str());
			return sol::make_object(lua, zen::WideToUtf8(EnvVarValue.c_str()));
#else
			ZEN_UNUSED(env);
			return sol::make_object(lua, sol::lua_nil);
#endif
		});

		try
		{
			sol::load_result config = lua.load(std::string_view((const char*)LuaScript.Data(), LuaScript.Size()), "zen_cfg");

			if (!config.valid())
			{
				sol::error err = config;

				std::string ErrorString = sol::to_string(config.status());

				throw std::runtime_error(fmt::format("{} error: {}", ErrorString, err.what()));
			}

			config();
		}
		catch (std::exception& e)
		{
			throw std::runtime_error(fmt::format("failed to load config script ('{}'): {}", Path, e.what()).c_str());
		}

		if (sol::optional<sol::table> ServerConfig = lua["server"])
		{
			if (ServerOptions.DataDir.empty())
			{
				if (sol::optional<std::string> Opt = ServerConfig.value()["datadir"])
				{
					ServerOptions.DataDir = Opt.value();
				}
			}

			if (ServerOptions.ContentDir.empty())
			{
				if (sol::optional<std::string> Opt = ServerConfig.value()["contentdir"])
				{
					ServerOptions.ContentDir = Opt.value();
				}
			}

			if (ServerOptions.AbsLogFile.empty())
			{
				if (sol::optional<std::string> Opt = ServerConfig.value()["abslog"])
				{
					ServerOptions.AbsLogFile = Opt.value();
				}
			}

			ServerOptions.IsDebug = ServerConfig->get_or("debug", ServerOptions.IsDebug);
		}

		if (sol::optional<sol::table> NetworkConfig = lua["network"])
		{
			if (sol::optional<std::string> Opt = NetworkConfig.value()["httpserverclass"])
			{
				ServerOptions.HttpServerClass = Opt.value();
			}

			ServerOptions.BasePort = NetworkConfig->get_or<int>("port", ServerOptions.BasePort);
#if ZEN_ENABLE_MESH
			ServerOptions.MeshEnabled = NetworkConfig->get_or<bool>("meshenabled", ServerOptions.MeshEnabled);
#endif
		}

		auto UpdateStringValueFromConfig = [](const sol::table& Table, std::string_view Key, std::string& OutValue) {
			// Update the specified config value unless it has been set, i.e. from command line
			if (auto MaybeValue = Table.get<sol::optional<std::string>>(Key); MaybeValue.has_value() && OutValue.empty())
			{
				OutValue = MaybeValue.value();
			}
		};

		if (sol::optional<sol::table> StructuredCacheConfig = lua["cache"])
		{
			ServerOptions.StructuredCacheEnabled = StructuredCacheConfig->get_or("enable", ServerOptions.StructuredCacheEnabled);

			if (auto UpstreamConfig = StructuredCacheConfig->get<sol::optional<sol::table>>("upstream"))
			{
				std::string Policy							  = UpstreamConfig->get_or("policy", std::string());
				ServerOptions.UpstreamCacheConfig.CachePolicy = ParseUpstreamCachePolicy(Policy);
				ServerOptions.UpstreamCacheConfig.UpstreamThreadCount =
					UpstreamConfig->get_or("upstreamthreadcount", ServerOptions.UpstreamCacheConfig.UpstreamThreadCount);

				if (auto JupiterConfig = UpstreamConfig->get<sol::optional<sol::table>>("jupiter"))
				{
					UpdateStringValueFromConfig(JupiterConfig.value(),
												std::string_view("name"),
												ServerOptions.UpstreamCacheConfig.JupiterConfig.Name);
					UpdateStringValueFromConfig(JupiterConfig.value(),
												std::string_view("url"),
												ServerOptions.UpstreamCacheConfig.JupiterConfig.Url);
					UpdateStringValueFromConfig(JupiterConfig.value(),
												std::string_view("oauthprovider"),
												ServerOptions.UpstreamCacheConfig.JupiterConfig.OAuthUrl);
					UpdateStringValueFromConfig(JupiterConfig.value(),
												std::string_view("oauthclientid"),
												ServerOptions.UpstreamCacheConfig.JupiterConfig.OAuthClientId);
					UpdateStringValueFromConfig(JupiterConfig.value(),
												std::string_view("oauthclientsecret"),
												ServerOptions.UpstreamCacheConfig.JupiterConfig.OAuthClientSecret);
					UpdateStringValueFromConfig(JupiterConfig.value(),
												std::string_view("openidprovider"),
												ServerOptions.UpstreamCacheConfig.JupiterConfig.OpenIdProvider);
					UpdateStringValueFromConfig(JupiterConfig.value(),
												std::string_view("token"),
												ServerOptions.UpstreamCacheConfig.JupiterConfig.AccessToken);
					UpdateStringValueFromConfig(JupiterConfig.value(),
												std::string_view("namespace"),
												ServerOptions.UpstreamCacheConfig.JupiterConfig.Namespace);
					UpdateStringValueFromConfig(JupiterConfig.value(),
												std::string_view("ddcnamespace"),
												ServerOptions.UpstreamCacheConfig.JupiterConfig.DdcNamespace);
				};

				if (auto ZenConfig = UpstreamConfig->get<sol::optional<sol::table>>("zen"))
				{
					ServerOptions.UpstreamCacheConfig.ZenConfig.Name = ZenConfig.value().get_or("name", std::string("Zen"));

					if (auto Url = ZenConfig.value().get<sol::optional<std::string>>("url"))
					{
						ServerOptions.UpstreamCacheConfig.ZenConfig.Urls.push_back(Url.value());
					}
					else if (auto Urls = ZenConfig.value().get<sol::optional<sol::table>>("url"))
					{
						for (const auto& Kv : Urls.value())
						{
							ServerOptions.UpstreamCacheConfig.ZenConfig.Urls.push_back(Kv.second.as<std::string>());
						}
					}

					if (auto Dns = ZenConfig.value().get<sol::optional<std::string>>("dns"))
					{
						ServerOptions.UpstreamCacheConfig.ZenConfig.Dns.push_back(Dns.value());
					}
					else if (auto DnsArray = ZenConfig.value().get<sol::optional<sol::table>>("dns"))
					{
						for (const auto& Kv : DnsArray.value())
						{
							ServerOptions.UpstreamCacheConfig.ZenConfig.Dns.push_back(Kv.second.as<std::string>());
						}
					}
				}
			}
		}

		if (sol::optional<sol::table> ExecConfig = lua["exec"])
		{
			ServerOptions.ExecServiceEnabled = ExecConfig->get_or("enable", ServerOptions.ExecServiceEnabled);
		}

		if (sol::optional<sol::table> ComputeConfig = lua["compute"])
		{
			ServerOptions.ComputeServiceEnabled = ComputeConfig->get_or("enable", ServerOptions.ComputeServiceEnabled);

			if (auto UpstreamConfig = ComputeConfig->get<sol::optional<sol::table>>("upstream"))
			{
				if (auto HordeConfig = UpstreamConfig->get<sol::optional<sol::table>>("horde"))
				{
					UpdateStringValueFromConfig(HordeConfig.value(),
												std::string_view("name"),
												ServerOptions.UpstreamCacheConfig.HordeConfig.Name);
					UpdateStringValueFromConfig(HordeConfig.value(),
												std::string_view("url"),
												ServerOptions.UpstreamCacheConfig.HordeConfig.Url);
					UpdateStringValueFromConfig(HordeConfig.value(),
												std::string_view("oauthprovider"),
												ServerOptions.UpstreamCacheConfig.HordeConfig.OAuthUrl);
					UpdateStringValueFromConfig(HordeConfig.value(),
												std::string_view("oauthclientid"),
												ServerOptions.UpstreamCacheConfig.HordeConfig.OAuthClientId);
					UpdateStringValueFromConfig(HordeConfig.value(),
												std::string_view("oauthclientsecret"),
												ServerOptions.UpstreamCacheConfig.HordeConfig.OAuthClientSecret);
					UpdateStringValueFromConfig(HordeConfig.value(),
												std::string_view("openidprovider"),
												ServerOptions.UpstreamCacheConfig.HordeConfig.OpenIdProvider);
					UpdateStringValueFromConfig(HordeConfig.value(),
												std::string_view("token"),
												ServerOptions.UpstreamCacheConfig.HordeConfig.AccessToken);
					UpdateStringValueFromConfig(HordeConfig.value(),
												std::string_view("cluster"),
												ServerOptions.UpstreamCacheConfig.HordeConfig.Cluster);
					UpdateStringValueFromConfig(HordeConfig.value(),
												std::string_view("namespace"),
												ServerOptions.UpstreamCacheConfig.HordeConfig.Namespace);
				};

				if (auto StorageConfig = UpstreamConfig->get<sol::optional<sol::table>>("storage"))
				{
					UpdateStringValueFromConfig(StorageConfig.value(),
												std::string_view("url"),
												ServerOptions.UpstreamCacheConfig.HordeConfig.StorageUrl);
					UpdateStringValueFromConfig(StorageConfig.value(),
												std::string_view("oauthprovider"),
												ServerOptions.UpstreamCacheConfig.HordeConfig.StorageOAuthUrl);
					UpdateStringValueFromConfig(StorageConfig.value(),
												std::string_view("oauthclientid"),
												ServerOptions.UpstreamCacheConfig.HordeConfig.StorageOAuthClientId);
					UpdateStringValueFromConfig(StorageConfig.value(),
												std::string_view("oauthclientsecret"),
												ServerOptions.UpstreamCacheConfig.HordeConfig.StorageOAuthClientSecret);
					UpdateStringValueFromConfig(StorageConfig.value(),
												std::string_view("openidprovider"),
												ServerOptions.UpstreamCacheConfig.HordeConfig.StorageOpenIdProvider);
					UpdateStringValueFromConfig(StorageConfig.value(),
												std::string_view("token"),
												ServerOptions.UpstreamCacheConfig.HordeConfig.StorageAccessToken);
				};
			}
		}

		if (sol::optional<sol::table> GcConfig = lua["gc"])
		{
			ServerOptions.GcConfig.MonitorIntervalSeconds = GcConfig.value().get_or("monitorintervalseconds", 30);
			ServerOptions.GcConfig.IntervalSeconds		  = GcConfig.value().get_or("intervalseconds", 0);
			ServerOptions.GcConfig.DiskReserveSize		  = GcConfig.value().get_or("diskreservesize", uint64_t(1u << 28));

			if (sol::optional<sol::table> CacheGcConfig = GcConfig.value()["cache"])
			{
				ServerOptions.GcConfig.Cache.MaxDurationSeconds = CacheGcConfig.value().get_or("maxdurationseconds", int32_t(0));
				ServerOptions.GcConfig.Cache.DiskSizeLimit		= CacheGcConfig.value().get_or("disksizelimit", ~uint64_t(0));
				ServerOptions.GcConfig.Cache.MemorySizeLimit	= CacheGcConfig.value().get_or("memorysizelimit", ~uint64_t(0));
			}

			if (sol::optional<sol::table> CasGcConfig = GcConfig.value()["cas"])
			{
				ServerOptions.GcConfig.Cas.LargeStrategySizeLimit = CasGcConfig.value().get_or("largestrategysizelimit", ~uint64_t(0));
				ServerOptions.GcConfig.Cas.SmallStrategySizeLimit = CasGcConfig.value().get_or("smallstrategysizelimit", ~uint64_t(0));
				ServerOptions.GcConfig.Cas.TinyStrategySizeLimit  = CasGcConfig.value().get_or("tinystrategysizelimit", ~uint64_t(0));
			}
		}

		if (sol::optional<sol::table> SecurityConfig = lua["security"])
		{
			ServerOptions.EncryptionKey = SecurityConfig.value().get_or("encryptionaeskey", std::string());
			ServerOptions.EncryptionIV	= SecurityConfig.value().get_or("encryptionaesiv", std::string());
		}
	}
}