Merged main.

1 files changed, 92 insertions, 24 deletions

diff --git a/zenserver/zenserver.cpp b/zenserver/zenserver.cpp
index e14f93f5b..49bb3004d 100644
--- a/zenserver/zenserver.cpp
+++ b/zenserver/zenserver.cpp
@@ -12,13 +12,17 @@
 #include <zencore/string.h>
 #include <zencore/thread.h>
 #include <zencore/timer.h>
-#include <zencore/windows.h>
+#include <zencore/trace.h>
 #include <zenhttp/httpserver.h>
 #include <zenstore/basicfile.h>
 #include <zenstore/cas.h>
 #include <zenstore/cidstore.h>
 #include <zenutil/zenserverprocess.h>
 
+#if ZEN_PLATFORM_WINDOWS
+#	include <zencore/windows.h>
+#endif
+
 #if ZEN_USE_MIMALLOC
 ZEN_THIRD_PARTY_INCLUDES_START
 #	include <mimalloc-new-delete.h>
@@ -138,7 +142,7 @@ namespace utils {
 
 		if (!ErrorCode)
 		{
-			for (const asio::ip::tcp::endpoint& Ep : Endpoints)
+			for (const asio::ip::tcp::endpoint Ep : Endpoints)
 			{
 				OutEndpoints.push_back("http://{}:{}"_format(Ep.address().to_string(), Ep.port()));
 			}
@@ -225,17 +229,23 @@ public:
 		m_LocalProjectService = zen::LocalProjectService::New(*m_CasStore, m_ProjectStore);
 #endif
 
-		ZEN_INFO("instantiating compute services");
-
 #if ZEN_USE_EXEC
 		std::filesystem::path SandboxDir = m_DataRoot / "exec" / "sandbox";
 		zen::CreateDirectories(SandboxDir);
 		m_HttpLaunchService = std::make_unique<zen::HttpLaunchService>(*m_CasStore, SandboxDir);
 #endif
 
+#if ZEN_WITH_COMPUTE_SERVICES
+		ZEN_INFO("instantiating compute services");
+
+		std::filesystem::path SandboxDir = m_DataRoot / "exec" / "sandbox";
+		zen::CreateDirectories(SandboxDir);
+		m_HttpLaunchService = std::make_unique<zen::HttpLaunchService>(*m_CasStore, SandboxDir);
+
 		std::filesystem::path ApplySandboxDir = m_DataRoot / "exec" / "apply";
 		zen::CreateDirectories(ApplySandboxDir);
 		m_HttpFunctionService = std::make_unique<zen::HttpFunctionService>(*m_CasStore, *m_CidStore, ApplySandboxDir);
+#endif	// ZEN_WITH_COMPUTE_SERVICES
 
 		if (ServerOptions.StructuredCacheEnabled)
 		{
@@ -273,17 +283,17 @@ public:
 			m_Http->RegisterService(*m_StructuredCacheService);
 		}
 
-#if ZEN_USE_EXEC
+#if ZEN_WITH_COMPUTE_SERVICES
 		if (m_HttpLaunchService)
 		{
 			m_Http->RegisterService(*m_HttpLaunchService);
 		}
-#endif
 
 		if (m_HttpFunctionService)
 		{
 			m_Http->RegisterService(*m_HttpFunctionService);
 		}
+#endif	// ZEN_WITH_COMPUTE_SERVICES
 
 		m_FrontendService = std::make_unique<HttpFrontendService>(m_ContentRoot);
 
@@ -343,7 +353,7 @@ public:
 
 		if (m_DebugOptionForcedCrash)
 		{
-			__debugbreak();
+			ZEN_DEBUG_BREAK();
 		}
 
 		const bool IsInteractiveMode = zen::IsInteractiveSession() && !m_TestMode;
@@ -404,7 +414,7 @@ public:
 
 		for (auto& PidEntry : m_ServerEntry->SponsorPids)
 		{
-			if (uint32_t ThisPid = PidEntry.load(std::memory_order::memory_order_relaxed))
+			if (uint32_t ThisPid = PidEntry.load(std::memory_order_relaxed))
 			{
 				if (PidEntry.compare_exchange_strong(ThisPid, 0))
 				{
@@ -523,13 +533,17 @@ private:
 	zen::HttpTestingService							 m_TestingService;
 	zen::HttpCasService								 m_CasService{*m_CasStore};
 	zen::RefPtr<zen::ProjectStore>					 m_ProjectStore;
+	zen::Ref<zen::LocalProjectService>				 m_LocalProjectService;
 	std::unique_ptr<zen::HttpProjectService>		 m_HttpProjectService;
 	std::unique_ptr<zen::HttpStructuredCacheService> m_StructuredCacheService;
 	zen::HttpAdminService							 m_AdminService{m_GcScheduler};
 	zen::HttpHealthService							 m_HealthService;
 	zen::Mesh										 m_ZenMesh{m_IoContext};
-	std::unique_ptr<zen::HttpFunctionService>		 m_HttpFunctionService;
-	std::unique_ptr<zen::HttpFrontendService>		 m_FrontendService;
+#if ZEN_WITH_COMPUTE_SERVICES
+	std::unique_ptr<zen::HttpLaunchService>	  m_HttpLaunchService;
+	std::unique_ptr<zen::HttpFunctionService> m_HttpFunctionService;
+#endif
+	std::unique_ptr<zen::HttpFrontendService> m_FrontendService;
 
 #if ZEN_USE_EXEC
 	std::unique_ptr<zen::HttpLaunchService> m_HttpLaunchService;
@@ -766,33 +780,34 @@ ZenServer::InitializeStructuredCache(const ZenServerOptions& ServerOptions)
 		new zen::HttpStructuredCacheService(*m_CacheStore, *m_CidStore, m_StatsService, m_StatusService, std::move(UpstreamCache)));
 }
 
-}  // namespace zen
+////////////////////////////////////////////////////////////////////////////////
 
-class ZenWindowsService : public WindowsService
+class ZenEntryPoint
 {
 public:
-	ZenWindowsService(ZenServerOptions& ServerOptions) : m_ServerOptions(ServerOptions) {}
-
-	ZenWindowsService(const ZenWindowsService&) = delete;
-	ZenWindowsService& operator=(const ZenWindowsService&) = delete;
-
-	virtual int Run() override;
+	ZenEntryPoint(ZenServerOptions& ServerOptions);
+	ZenEntryPoint(const ZenEntryPoint&) = delete;
+	ZenEntryPoint& operator=(const ZenEntryPoint&) = delete;
+	int			   Run();
 
 private:
 	ZenServerOptions& m_ServerOptions;
 	zen::LockFile	  m_LockFile;
 };
 
-int
-ZenWindowsService::Run()
+ZenEntryPoint::ZenEntryPoint(ZenServerOptions& ServerOptions) : m_ServerOptions(ServerOptions)
 {
-	using namespace zen;
+}
 
+int
+ZenEntryPoint::Run()
+{
 #if USE_SENTRY
 	// Initialize sentry.io client
 
 	sentry_options_t* SentryOptions = sentry_options_new();
 	sentry_options_set_dsn(SentryOptions, "https://[email protected]/5919284");
+	sentry_options_set_database_path(SentryOptions, PathToUtf8(m_ServerOptions.DataDir / ".sentry-native").c_str());
 	sentry_init(SentryOptions);
 
 	auto _ = zen::MakeGuard([] { sentry_close(); });
@@ -812,8 +827,8 @@ ZenWindowsService::Run()
 
 		auto MakeLockData = [&] {
 			CbObjectWriter Cbo;
-			Cbo << "pid" << _getpid() << "data" << ToUtf8(ServerOptions.DataDir) << "port" << ServerOptions.BasePort << "session_id"
-				<< GetSessionId() << "ready" << IsReady;
+			Cbo << "pid" << zen::GetCurrentProcessId() << "data" << PathToUtf8(ServerOptions.DataDir) << "port" << ServerOptions.BasePort
+				<< "session_id" << GetSessionId() << "ready" << IsReady;
 			return Cbo.Save();
 		};
 
@@ -880,6 +895,10 @@ ZenWindowsService::Run()
 				ZEN_INFO("shutdown signal received");
 				Server.RequestExit(0);
 			}
+			else
+			{
+				ZEN_INFO("shutdown signal wait() failed");
+			}
 		}});
 
 		// If we have a parent process, establish the mechanisms we need
@@ -913,6 +932,36 @@ ZenWindowsService::Run()
 	return 0;
 }
 
+}  // namespace zen
+
+////////////////////////////////////////////////////////////////////////////////
+
+#if ZEN_PLATFORM_WINDOWS
+
+class ZenWindowsService : public WindowsService
+{
+public:
+	ZenWindowsService(ZenServerOptions& ServerOptions) : m_EntryPoint(ServerOptions) {}
+
+	ZenWindowsService(const ZenWindowsService&) = delete;
+	ZenWindowsService& operator=(const ZenWindowsService&) = delete;
+
+	virtual int Run() override;
+
+private:
+	zen::ZenEntryPoint m_EntryPoint;
+};
+
+int
+ZenWindowsService::Run()
+{
+	return m_EntryPoint.Run();
+}
+
+#endif	// ZEN_PLATFORM_WINDOWS
+
+////////////////////////////////////////////////////////////////////////////////
+
 #if ZEN_WITH_TESTS
 int
 test_main(int argc, char** argv)
@@ -960,6 +1009,17 @@ main(int argc, char* argv[])
 			std::filesystem::create_directories(ServerOptions.DataDir);
 		}
 
+#if ZEN_WITH_TRACE
+		if (ServerOptions.TraceHost.size())
+		{
+			TraceInit(ServerOptions.TraceHost.c_str(), TraceType::Network);
+		}
+		else if (ServerOptions.TraceFile.size())
+		{
+			TraceInit(ServerOptions.TraceFile.c_str(), TraceType::File);
+		}
+#endif	// ZEN_WITH_TRACE
+
 #if ZEN_PLATFORM_WINDOWS
 		if (ServerOptions.InstallService)
 		{
@@ -974,10 +1034,18 @@ main(int argc, char* argv[])
 
 			std::exit(0);
 		}
-#endif
 
 		ZenWindowsService App(ServerOptions);
 		return App.ServiceMain();
+#else
+		if (ServerOptions.InstallService || ServerOptions.UninstallService)
+		{
+			throw std::runtime_error("Service mode is not supported on this platform");
+		}
+
+		ZenEntryPoint App(ServerOptions);
+		return App.Run();
+#endif	// ZEN_PLATFORM_WINDOWS
 	}
 	catch (std::exception& Ex)
 	{