moved source directories into `/src` (#264)

* moved source directories into `/src`
* updated bundle.lua for new `src` path
* moved some docs, icon
* removed old test trees

1 files changed, 0 insertions, 902 deletions

diff --git a/zenserver/config.cpp b/zenserver/config.cpp
deleted file mode 100644
index cff93d67b..000000000
--- a/zenserver/config.cpp
+++ /dev/null
@@ -1,902 +0,0 @@
-// 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;
-	}
-}
-
-ZenObjectStoreConfig
-ParseBucketConfigs(std::span<std::string> Buckets)
-{
-	using namespace std::literals;
-
-	ZenObjectStoreConfig Cfg;
-
-	// split bucket args in the form of "{BucketName};{LocalPath}"
-	for (std::string_view Bucket : Buckets)
-	{
-		ZenObjectStoreConfig::BucketConfig NewBucket;
-
-		if (auto Idx = Bucket.find_first_of(";"); Idx != std::string_view::npos)
-		{
-			NewBucket.Name		= Bucket.substr(0, Idx);
-			NewBucket.Directory = Bucket.substr(Idx + 1);
-		}
-		else
-		{
-			NewBucket.Name = Bucket;
-		}
-
-		Cfg.Buckets.push_back(std::move(NewBucket));
-	}
-
-	return Cfg;
-}
-
-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),
-					   "");
-
-	std::string OpenIdProviderName;
-	options.add_option("security",
-					   "",
-					   "openid-provider-name",
-					   "Open ID provider name",
-					   cxxopts::value<std::string>(OpenIdProviderName),
-					   "Default");
-
-	std::string OpenIdProviderUrl;
-	options.add_option("security", "", "openid-provider-url", "Open ID provider URL", cxxopts::value<std::string>(OpenIdProviderUrl), "");
-
-	std::string OpenIdClientId;
-	options.add_option("security", "", "openid-client-id", "Open ID client ID", cxxopts::value<std::string>(OpenIdClientId), "");
-
-	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_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 of small objects 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 3600 (1 hour).",
-					   cxxopts::value<int32_t>(ServerOptions.GcConfig.IntervalSeconds)->default_value("3600"),
-					   "");
-
-	options.add_option("gc",
-					   "",
-					   "gc-cache-duration-seconds",
-					   "Max duration in seconds before Z$ entries get evicted. Default set to 1209600 (2 weeks)",
-					   cxxopts::value<int32_t>(ServerOptions.GcConfig.Cache.MaxDurationSeconds)->default_value("1209600"),
-					   "");
-
-	options.add_option("gc",
-					   "",
-					   "disk-reserve-size",
-					   "Size of gc disk reserve in bytes. Default set to 268435456 (256 Mb).",
-					   cxxopts::value<uint64_t>(ServerOptions.GcConfig.DiskReserveSize)->default_value("268435456"),
-					   "");
-
-	options.add_option("gc",
-					   "",
-					   "gc-monitor-interval-seconds",
-					   "Garbage collection monitoring interval in seconds. Default set to 30 (30 seconds)",
-					   cxxopts::value<int32_t>(ServerOptions.GcConfig.MonitorIntervalSeconds)->default_value("30"),
-					   "");
-
-	options.add_option("gc",
-					   "",
-					   "gc-disksize-softlimit",
-					   "Garbage collection disk usage soft limit. Default set to 0 (Off).",
-					   cxxopts::value<uint64_t>(ServerOptions.GcConfig.Cache.DiskSizeSoftLimit)->default_value("0"),
-					   "");
-
-	options.add_option("objectstore",
-					   "",
-					   "objectstore-enabled",
-					   "Whether the object store is enabled or not.",
-					   cxxopts::value<bool>(ServerOptions.ObjectStoreEnabled)->default_value("false"),
-					   "");
-
-	std::vector<std::string> BucketConfigs;
-	options.add_option("objectstore",
-					   "",
-					   "objectstore-bucket",
-					   "Object store bucket mappings.",
-					   cxxopts::value<std::vector<std::string>>(BucketConfigs),
-					   "");
-
-	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 (OpenIdProviderUrl.empty() == false)
-		{
-			if (OpenIdClientId.empty())
-			{
-				throw cxxopts::OptionParseException("Invalid OpenID client ID");
-			}
-
-			ServerOptions.AuthConfig.OpenIdProviders.push_back(
-				{.Name = OpenIdProviderName, .Url = OpenIdProviderUrl, .ClientId = OpenIdClientId});
-		}
-
-		ServerOptions.ObjectStoreConfig = ParseBucketConfigs(BucketConfigs);
-
-		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);
-		}
-
-		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));
-				ServerOptions.GcConfig.Cache.DiskSizeSoftLimit	= CacheGcConfig.value().get_or("disksizesoftlimit", 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"])
-		{
-			if (sol::optional<sol::table> OpenIdProviders = SecurityConfig.value()["openidproviders"])
-			{
-				for (const auto& Kv : OpenIdProviders.value())
-				{
-					if (sol::optional<sol::table> OpenIdProvider = Kv.second.as<sol::table>())
-					{
-						std::string Name	 = OpenIdProvider.value().get_or("name", std::string("Default"));
-						std::string Url		 = OpenIdProvider.value().get_or("url", std::string());
-						std::string ClientId = OpenIdProvider.value().get_or("clientid", std::string());
-
-						ServerOptions.AuthConfig.OpenIdProviders.push_back(
-							{.Name = std::move(Name), .Url = std::move(Url), .ClientId = std::move(ClientId)});
-					}
-				}
-			}
-
-			ServerOptions.EncryptionKey = SecurityConfig.value().get_or("encryptionaeskey", std::string());
-			ServerOptions.EncryptionIV	= SecurityConfig.value().get_or("encryptionaesiv", std::string());
-		}
-	}
-}