Merge pull request #355 from ue-foundation/di/plugins

Added a way to enable zenserver plugins via CLI/lua, added transport API versioning and logging support

3 files changed, 167 insertions, 106 deletions

diff --git a/src/zenhttp/httpserver.cpp b/src/zenhttp/httpserver.cpp
index 27a09f339..d12f89a92 100644
--- a/src/zenhttp/httpserver.cpp
+++ b/src/zenhttp/httpserver.cpp
@@ -787,120 +787,115 @@ HttpRpcHandler::AddRpc(std::string_view RpcId, std::function<void(CbObject& RpcA
 
 //////////////////////////////////////////////////////////////////////////
 
-enum class HttpServerClass
-{
-	kHttpAsio,
-	kHttpSys,
-	kHttpPlugin,
-	kHttpMulti,
-	kHttpNull
-};
-
 Ref<HttpServer>
-CreateHttpServerClass(HttpServerClass Class, const HttpServerConfig& Config)
+CreateHttpServerClass(const std::string_view ServerClass, const HttpServerConfig& Config)
 {
-	switch (Class)
+	if (ServerClass == "asio"sv)
 	{
-		default:
-		case HttpServerClass::kHttpAsio:
-			ZEN_INFO("using asio HTTP server implementation");
-			return CreateHttpAsioServer(Config.ForceLoopback, Config.ThreadCount);
-
-		case HttpServerClass::kHttpMulti:
-			{
-				ZEN_INFO("using multi HTTP server implementation");
-				Ref<HttpMultiServer> Server{new HttpMultiServer()};
-
-				// This is hardcoded for now, but should be configurable in the future
-				Server->AddServer(CreateHttpServerClass(HttpServerClass::kHttpSys, Config));
-				Server->AddServer(CreateHttpServerClass(HttpServerClass::kHttpPlugin, Config));
+		ZEN_INFO("using asio HTTP server implementation")
+		return CreateHttpAsioServer(Config.ForceLoopback, Config.ThreadCount);
+	}
+#if ZEN_WITH_HTTPSYS
+	else if (ServerClass == "httpsys"sv)
+	{
+		ZEN_INFO("using http.sys server implementation")
+		return Ref<HttpServer>(CreateHttpSysServer({.ThreadCount			 = Config.ThreadCount,
+													.AsyncWorkThreadCount	 = Config.HttpSys.AsyncWorkThreadCount,
+													.IsAsyncResponseEnabled	 = Config.HttpSys.IsAsyncResponseEnabled,
+													.IsRequestLoggingEnabled = Config.HttpSys.IsRequestLoggingEnabled,
+													.IsDedicatedServer		 = Config.IsDedicatedServer,
+													.ForceLoopback			 = Config.ForceLoopback}));
+	}
+#endif
+	else if (ServerClass == "null"sv)
+	{
+		ZEN_INFO("using null HTTP server implementation")
+		return Ref<HttpServer>(new HttpNullServer);
+	}
+	else
+	{
+		ZEN_WARN("unknown HTTP server implementation '{}', falling back to default", ServerClass)
 
-				return Server;
-			}
+#if ZEN_WITH_HTTPSYS
+		return CreateHttpServerClass("httpsys"sv, Config);
+#else
+		return CreateHttpServerClass("asio"sv, Config);
+#endif
+	}
+}
 
 #if ZEN_WITH_PLUGINS
-		case HttpServerClass::kHttpPlugin:
-			{
-				ZEN_INFO("using plugin HTTP server implementation");
-				Ref<HttpPluginServer> Server{CreateHttpPluginServer()};
-
-				// This is hardcoded for now, but should be configurable in the future
+Ref<HttpServer>
+CreateHttpServerPlugin(const HttpServerPluginConfig& PluginConfig)
+{
+	const std::string& PluginName = PluginConfig.PluginName;
 
-#	if 0
-				Ref<TransportPlugin> WinsockPlugin{CreateSocketTransportPlugin()};
-				WinsockPlugin->Configure("port", "8558");
-				Server->AddPlugin(WinsockPlugin);
-#	endif
+	ZEN_INFO("using '{}' plugin HTTP server implementation", PluginName)
+	Ref<HttpPluginServer> Server{CreateHttpPluginServer()};
 
+	if (PluginName.starts_with("builtin:"sv))
+	{
 #	if 0
-				Ref<TransportPlugin> AsioPlugin{CreateAsioTransportPlugin()};
-				AsioPlugin->Configure("port", "8558");
-				Server->AddPlugin(AsioPlugin);
-#	endif
-
-#	if 1
-				Ref<DllTransportPlugin> DllPlugin{CreateDllTransportPlugin()};
-				DllPlugin->LoadDll("winsock");
-				DllPlugin->ConfigureDll("winsock", "port", "8558");
-				Server->AddPlugin(DllPlugin);
-#	endif
+		Ref<TransportPlugin> Plugin = {};
+		if (PluginName == "builtin:winsock"sv)
+		{
+			Plugin = CreateSocketTransportPlugin();
+		}
+		else if (PluginName == "builtin:asio"sv)
+		{
+			Plugin = CreateAsioTransportPlugin();
+		}
 
-				return Server;
+		if (!Plugin.IsNull())
+		{
+			for (const std::pair<std::string, std::string>& Option : PluginConfig.PluginOptions)
+			{
+				Plugin->Configure(Option.first.c_str(), Option.second.c_str());
 			}
-#endif
-
-#if ZEN_WITH_HTTPSYS
-		case HttpServerClass::kHttpSys:
-			ZEN_INFO("using http.sys server implementation");
-			return Ref<HttpServer>(CreateHttpSysServer({.ThreadCount			 = Config.ThreadCount,
-														.AsyncWorkThreadCount	 = Config.HttpSys.AsyncWorkThreadCount,
-														.IsAsyncResponseEnabled	 = Config.HttpSys.IsAsyncResponseEnabled,
-														.IsRequestLoggingEnabled = Config.HttpSys.IsRequestLoggingEnabled,
-														.IsDedicatedServer		 = Config.IsDedicatedServer,
-														.ForceLoopback			 = Config.ForceLoopback}));
-#endif
-
-		case HttpServerClass::kHttpNull:
-			ZEN_INFO("using null HTTP server implementation");
-			return Ref<HttpServer>(new HttpNullServer);
+			Server->AddPlugin(Plugin);
+		}
+#	endif
 	}
+	else
+	{
+		Ref<DllTransportPlugin> DllPlugin{CreateDllTransportPlugin()};
+		DllPlugin->LoadDll(PluginName);
+		for (const std::pair<std::string, std::string>& Option : PluginConfig.PluginOptions)
+		{
+			DllPlugin->ConfigureDll(PluginName, Option.first.c_str(), Option.second.c_str());
+		}
+		Server->AddPlugin(DllPlugin);
+	}
+
+	return Server;
 }
+#endif
 
 Ref<HttpServer>
 CreateHttpServer(const HttpServerConfig& Config)
 {
 	using namespace std::literals;
 
-	HttpServerClass Class = HttpServerClass::kHttpNull;
-
-#if ZEN_WITH_HTTPSYS
-	Class = HttpServerClass::kHttpSys;
-#else
-	Class = HttpServerClass::kHttpAsio;
-#endif
-
-	if (Config.ServerClass == "asio"sv)
-	{
-		Class = HttpServerClass::kHttpAsio;
-	}
-	else if (Config.ServerClass == "httpsys"sv)
-	{
-		Class = HttpServerClass::kHttpSys;
-	}
-	else if (Config.ServerClass == "plugin"sv)
-	{
-		Class = HttpServerClass::kHttpPlugin;
-	}
-	else if (Config.ServerClass == "null"sv)
+#if ZEN_WITH_PLUGINS
+	if (Config.PluginConfigs.empty())
 	{
-		Class = HttpServerClass::kHttpNull;
+		return CreateHttpServerClass(Config.ServerClass, Config);
 	}
-	else if (Config.ServerClass == "multi"sv)
+	else
 	{
-		Class = HttpServerClass::kHttpMulti;
-	}
+		Ref<HttpMultiServer> Server{new HttpMultiServer()};
+		Server->AddServer(CreateHttpServerClass(Config.ServerClass, Config));
 
-	return CreateHttpServerClass(Class, Config);
+		for (const HttpServerPluginConfig& PluginConfig : Config.PluginConfigs)
+		{
+			Server->AddServer(CreateHttpServerPlugin(PluginConfig));
+		}
+
+		return Server;
+	}
+#else
+	return CreateHttpServerClass(Config.ServerClass, Config);
+#endif
 }
 
 //////////////////////////////////////////////////////////////////////////
diff --git a/src/zenhttp/include/zenhttp/httpserver.h b/src/zenhttp/include/zenhttp/httpserver.h
index 217455dba..03e547bf3 100644
--- a/src/zenhttp/include/zenhttp/httpserver.h
+++ b/src/zenhttp/include/zenhttp/httpserver.h
@@ -184,12 +184,19 @@ public:
 	virtual void Close()												 = 0;
 };
 
+struct HttpServerPluginConfig
+{
+	std::string										 PluginName;
+	std::vector<std::pair<std::string, std::string>> PluginOptions;
+};
+
 struct HttpServerConfig
 {
-	bool		 IsDedicatedServer = false;	 // Should be set to true for shared servers
-	std::string	 ServerClass;				 // Choice of HTTP server implementation
-	bool		 ForceLoopback = false;
-	unsigned int ThreadCount   = 0;
+	bool								IsDedicatedServer = false;	// Should be set to true for shared servers
+	std::string							ServerClass;				// Choice of HTTP server implementation
+	std::vector<HttpServerPluginConfig> PluginConfigs;
+	bool								ForceLoopback = false;
+	unsigned int						ThreadCount	  = 0;
 
 	struct
 	{
diff --git a/src/zenhttp/transports/dlltransport.cpp b/src/zenhttp/transports/dlltransport.cpp
index e09e62ec5..dd05f6f0c 100644
--- a/src/zenhttp/transports/dlltransport.cpp
+++ b/src/zenhttp/transports/dlltransport.cpp
@@ -21,18 +21,31 @@ namespace zen {
 
 //////////////////////////////////////////////////////////////////////////
 
+class DllTransportLogger : public TransportLogger, public RefCounted
+{
+public:
+	DllTransportLogger(std::string_view PluginName);
+	virtual ~DllTransportLogger() = default;
+
+	void LogMessage(LogLevel Level, const char* Message) override;
+
+private:
+	std::string m_PluginName;
+};
+
 struct LoadedDll
 {
 	std::string			  Name;
 	std::filesystem::path LoadedFromPath;
+	DllTransportLogger*	  Logger = nullptr;
 	Ref<TransportPlugin>  Plugin;
 };
 
 class DllTransportPluginImpl : public DllTransportPlugin, RefCounted
 {
 public:
-	DllTransportPluginImpl();
-	~DllTransportPluginImpl();
+	DllTransportPluginImpl()  = default;
+	~DllTransportPluginImpl() = default;
 
 	virtual uint32_t	AddRef() const override;
 	virtual uint32_t	Release() const override;
@@ -51,12 +64,27 @@ private:
 	std::vector<LoadedDll> m_Transports;
 };
 
-DllTransportPluginImpl::DllTransportPluginImpl()
+DllTransportLogger::DllTransportLogger(std::string_view PluginName) : m_PluginName(PluginName)
 {
 }
 
-DllTransportPluginImpl::~DllTransportPluginImpl()
+void
+DllTransportLogger::LogMessage(LogLevel PluginLogLevel, const char* Message)
 {
+	logging::level::LogLevel Level;
+	// clang-format off
+	switch (PluginLogLevel)
+	{
+		case LogLevel::Trace:    Level = logging::level::Trace;    break;
+		case LogLevel::Debug:    Level = logging::level::Debug;    break;
+		case LogLevel::Info:     Level = logging::level::Info;     break;
+		case LogLevel::Warn:     Level = logging::level::Warn;     break;
+		case LogLevel::Err:      Level = logging::level::Err;      break;
+		case LogLevel::Critical: Level = logging::level::Critical; break;
+		default:                 Level = logging::level::Off;      break;
+	}
+	// clang-format on
+	ZEN_LOG(Log(), Level, "[{}] {}", m_PluginName, Message)
 }
 
 uint32_t
@@ -109,6 +137,7 @@ DllTransportPluginImpl::Shutdown()
 		try
 		{
 			Transport.Plugin->Shutdown();
+			Transport.Logger->Release();
 		}
 		catch (const std::exception&)
 		{
@@ -148,8 +177,15 @@ DllTransportPluginImpl::LoadDll(std::string_view Name)
 {
 	RwLock::ExclusiveLockScope _(m_Lock);
 
-	ExtendableStringBuilder<128> DllPath;
-	DllPath << Name << ".dll";
+	ExtendableStringBuilder<1024> DllPath;
+	DllPath << Name;
+	if (!Name.ends_with(".dll"))
+	{
+		DllPath << ".dll";
+	}
+
+	std::string FileName = std::filesystem::path(DllPath.c_str()).filename().replace_extension().string();
+
 	HMODULE DllHandle = LoadLibraryA(DllPath.c_str());
 
 	if (!DllHandle)
@@ -159,24 +195,47 @@ DllTransportPluginImpl::LoadDll(std::string_view Name)
 		throw std::system_error(Ec, fmt::format("failed to load transport DLL from '{}'", DllPath));
 	}
 
-	TransportPlugin* CreateTransportPlugin();
+	PfnGetTransportPluginVersion GetVersion	  = (PfnGetTransportPluginVersion)GetProcAddress(DllHandle, "GetTransportPluginVersion");
+	PfnCreateTransportPlugin	 CreatePlugin = (PfnCreateTransportPlugin)GetProcAddress(DllHandle, "CreateTransportPlugin");
 
-	PfnCreateTransportPlugin CreatePlugin = (PfnCreateTransportPlugin)GetProcAddress(DllHandle, "CreateTransportPlugin");
+	uint32_t APIVersion	   = 0;
+	uint32_t PluginVersion = 0;
 
-	if (!CreatePlugin)
+	if (GetVersion)
+	{
+		GetVersion(&APIVersion, &PluginVersion);
+	}
+
+	const bool bValidApiVersion = APIVersion == kTransportApiVersion;
+
+	if (!GetVersion || !CreatePlugin || !bValidApiVersion)
 	{
 		std::error_code Ec = MakeErrorCodeFromLastError();
 
 		FreeLibrary(DllHandle);
 
-		throw std::system_error(Ec, fmt::format("API mismatch detected in transport DLL loaded from '{}'", DllPath));
+		if (GetVersion && !bValidApiVersion)
+		{
+			throw std::system_error(
+				Ec,
+				fmt::format("invalid API version '{}' detected in transport DLL loaded from '{}', supported API version '{}'",
+							APIVersion,
+							DllPath,
+							kTransportApiVersion));
+		}
+		else
+		{
+			throw std::system_error(Ec, fmt::format("API mismatch detected in transport DLL loaded from '{}'", DllPath));
+		}
 	}
 
 	LoadedDll NewDll;
 
 	NewDll.Name			  = Name;
 	NewDll.LoadedFromPath = DllPath.c_str();
-	NewDll.Plugin		  = CreatePlugin();
+	NewDll.Logger		  = new DllTransportLogger(FileName);
+	NewDll.Logger->AddRef();
+	NewDll.Plugin = CreatePlugin(NewDll.Logger);
 
 	m_Transports.emplace_back(std::move(NewDll));
 }