Merge branch 'main' into sb/no-networksb/no-network

3 files changed, 301 insertions, 4 deletions

diff --git a/src/zenutil/include/zenutil/zenserverprocess.h b/src/zenutil/include/zenutil/zenserverprocess.h
index 1b8750628..2f76f0d6c 100644
--- a/src/zenutil/include/zenutil/zenserverprocess.h
+++ b/src/zenutil/include/zenutil/zenserverprocess.h
@@ -224,8 +224,10 @@ public:
 
 		enum class FlagsEnum : uint16_t
 		{
-			kShutdownPlease = 1 << 0,
-			kIsReady		= 1 << 1,
+			kShutdownPlease	 = 1 << 0,
+			kIsReady		 = 1 << 1,
+			kHasInstanceInfo = 1 << 2,
+			kNoNetwork		 = 1 << 3,
 		};
 
 		FRIEND_ENUM_CLASS_FLAGS(FlagsEnum);
@@ -236,6 +238,10 @@ public:
 		bool IsShutdownRequested() const;
 		void SignalReady();
 		bool IsReady() const;
+		void SignalHasInstanceInfo();
+		bool HasInstanceInfo() const;
+		void SignalNoNetwork();
+		bool IsNoNetwork() const;
 		bool AddSponsorProcess(uint32_t Pid, uint64_t Timeout = 0);
 	};
 
@@ -258,6 +264,51 @@ private:
 	bool			m_IsReadOnly	= true;
 };
 
+/** Per-instance extended data published via a small shared memory section keyed by SessionId.
+
+	Servers create a writable section; clients open it read-only during Snapshot()
+	enumeration to discover fields that don't fit in the fixed-size ZenServerEntry
+	(e.g. Unix domain socket path).
+
+	SessionId is preferred over PID for naming because it is unique per server
+	instance lifetime, avoiding issues with PID reuse on crash/restart.
+ */
+
+struct InstanceInfoData
+{
+	std::filesystem::path UnixSocketPath;
+	// Extensible: add more per-instance fields here in the future
+};
+
+class ZenServerInstanceInfo
+{
+public:
+	ZenServerInstanceInfo();
+	~ZenServerInstanceInfo();
+
+	ZenServerInstanceInfo(const ZenServerInstanceInfo&) = delete;
+	ZenServerInstanceInfo& operator=(const ZenServerInstanceInfo&) = delete;
+
+	/// Server-side: create read-write, populate with data
+	void Create(const Oid& SessionId, const InstanceInfoData& Data);
+
+	/// Client-side: open read-only by SessionId, returns false if not found
+	[[nodiscard]] bool OpenReadOnly(const Oid& SessionId);
+
+	/// Read the data (valid after Create or successful OpenReadOnly)
+	[[nodiscard]] InstanceInfoData Read() const;
+
+	bool IsValid() const { return m_Data != nullptr; }
+
+private:
+	static std::string MakeName(const Oid& SessionId);
+
+	void*	 m_hMapFile = nullptr;
+	uint8_t* m_Data		= nullptr;
+	bool	 m_IsOwner	= false;
+	Oid		 m_SessionId;  // for POSIX cleanup (shm_unlink)
+};
+
 struct LockFileInfo
 {
 	int32_t				  Pid;
@@ -266,6 +317,7 @@ struct LockFileInfo
 	bool				  Ready;
 	std::filesystem::path DataDir;
 	std::filesystem::path ExecutablePath;
+	std::filesystem::path UnixSocketPath;
 };
 
 CbObject	 MakeLockFilePayload(const LockFileInfo& Info);
diff --git a/src/zenutil/workerpools.cpp b/src/zenutil/workerpools.cpp
index 1bab39b2a..25f961f77 100644
--- a/src/zenutil/workerpools.cpp
+++ b/src/zenutil/workerpools.cpp
@@ -25,9 +25,9 @@ namespace {
 
 		struct WorkerPool
 		{
-			std::unique_ptr<WorkerThreadPool> Pool;
 			const int						  TreadCount;
 			const std::string_view			  Name;
+			std::unique_ptr<WorkerThreadPool> Pool;
 		};
 
 		WorkerPool BurstLargeWorkerPool		 = {.TreadCount = LargeWorkerThreadPoolTreadCount, .Name = "large"};
diff --git a/src/zenutil/zenserverprocess.cpp b/src/zenutil/zenserverprocess.cpp
index b9c50be4f..ac614f779 100644
--- a/src/zenutil/zenserverprocess.cpp
+++ b/src/zenutil/zenserverprocess.cpp
@@ -449,6 +449,30 @@ ZenServerState::ZenServerEntry::IsReady() const
 	return (Flags.load() & static_cast<uint16_t>(FlagsEnum::kIsReady)) != 0;
 }
 
+void
+ZenServerState::ZenServerEntry::SignalHasInstanceInfo()
+{
+	Flags |= uint16_t(FlagsEnum::kHasInstanceInfo);
+}
+
+bool
+ZenServerState::ZenServerEntry::HasInstanceInfo() const
+{
+	return (Flags.load() & static_cast<uint16_t>(FlagsEnum::kHasInstanceInfo)) != 0;
+}
+
+void
+ZenServerState::ZenServerEntry::SignalNoNetwork()
+{
+	Flags |= uint16_t(FlagsEnum::kNoNetwork);
+}
+
+bool
+ZenServerState::ZenServerEntry::IsNoNetwork() const
+{
+	return (Flags.load() & static_cast<uint16_t>(FlagsEnum::kNoNetwork)) != 0;
+}
+
 bool
 ZenServerState::ZenServerEntry::AddSponsorProcess(uint32_t PidToAdd, uint64_t Timeout)
 {
@@ -492,6 +516,222 @@ ZenServerState::ZenServerEntry::AddSponsorProcess(uint32_t PidToAdd, uint64_t Ti
 }
 
 //////////////////////////////////////////////////////////////////////////
+// ZenServerInstanceInfo
+//////////////////////////////////////////////////////////////////////////
+
+static constexpr size_t kInstanceInfoSize = 4096;
+
+ZenServerInstanceInfo::ZenServerInstanceInfo() = default;
+
+ZenServerInstanceInfo::~ZenServerInstanceInfo()
+{
+#if ZEN_PLATFORM_WINDOWS
+	if (m_Data)
+	{
+		UnmapViewOfFile(m_Data);
+	}
+	if (m_hMapFile)
+	{
+		CloseHandle(m_hMapFile);
+	}
+#else
+	if (m_Data != nullptr)
+	{
+		munmap(m_Data, kInstanceInfoSize);
+	}
+	if (m_hMapFile != nullptr)
+	{
+		int Fd = int(intptr_t(m_hMapFile));
+		close(Fd);
+	}
+	if (m_IsOwner)
+	{
+		std::string Name = MakeName(m_SessionId);
+		shm_unlink(Name.c_str());
+	}
+#endif
+	m_Data = nullptr;
+}
+
+std::string
+ZenServerInstanceInfo::MakeName(const Oid& SessionId)
+{
+#if ZEN_PLATFORM_WINDOWS
+	return fmt::format("Global\\ZenInstance_{}", SessionId);
+#else
+	// macOS limits shm_open names to ~31 chars (PSHMNAMLEN), so keep this short.
+	// "/ZenI_" (6) + 24 hex = 30 chars, within the limit.
+	return fmt::format("/ZenI_{}", SessionId);
+#endif
+}
+
+void
+ZenServerInstanceInfo::Create(const Oid& SessionId, const InstanceInfoData& Data)
+{
+	m_SessionId = SessionId;
+	m_IsOwner	= true;
+
+	// Serialize the data to compact binary
+	CbObjectWriter Cbo;
+	if (!Data.UnixSocketPath.empty())
+	{
+		Cbo << "unix_socket" << PathToUtf8(Data.UnixSocketPath);
+	}
+	CbObject Payload = Cbo.Save();
+
+	MemoryView PayloadView = Payload.GetView();
+	uint32_t   PayloadSize = gsl::narrow<uint32_t>(PayloadView.GetSize());
+
+	std::string Name = MakeName(SessionId);
+
+#if ZEN_PLATFORM_WINDOWS
+	zenutil::AnyUserSecurityAttributes Attrs;
+
+	std::wstring WideName(Name.begin(), Name.end());
+
+	HANDLE hMap =
+		CreateFileMappingW(INVALID_HANDLE_VALUE, Attrs.Attributes(), PAGE_READWRITE, 0, DWORD(kInstanceInfoSize), WideName.c_str());
+
+	if (hMap == NULL)
+	{
+		// Fall back to Local namespace
+		std::string	 LocalName = fmt::format("Local\\ZenInstance_{}", SessionId);
+		std::wstring WideLocalName(LocalName.begin(), LocalName.end());
+		hMap = CreateFileMappingW(INVALID_HANDLE_VALUE,
+								  Attrs.Attributes(),
+								  PAGE_READWRITE,
+								  0,
+								  DWORD(kInstanceInfoSize),
+								  WideLocalName.c_str());
+	}
+
+	if (hMap == NULL)
+	{
+		ThrowLastError("Could not create instance info shared memory");
+	}
+
+	void* pBuf = MapViewOfFile(hMap, FILE_MAP_ALL_ACCESS, 0, 0, DWORD(kInstanceInfoSize));
+	if (pBuf == NULL)
+	{
+		CloseHandle(hMap);
+		ThrowLastError("Could not map instance info shared memory");
+	}
+#else
+	int Fd = shm_open(Name.c_str(), O_RDWR | O_CREAT | O_TRUNC | O_CLOEXEC, 0666);
+	if (Fd < 0)
+	{
+		ThrowLastError("Could not create instance info shared memory");
+	}
+	fchmod(Fd, 0666);
+
+	if (ftruncate(Fd, kInstanceInfoSize) < 0)
+	{
+		close(Fd);
+		shm_unlink(Name.c_str());
+		ThrowLastError("Could not resize instance info shared memory");
+	}
+
+	void* pBuf = mmap(nullptr, kInstanceInfoSize, PROT_READ | PROT_WRITE, MAP_SHARED, Fd, 0);
+	if (pBuf == MAP_FAILED)
+	{
+		close(Fd);
+		shm_unlink(Name.c_str());
+		ThrowLastError("Could not map instance info shared memory");
+	}
+
+	void* hMap = reinterpret_cast<void*>(intptr_t(Fd));
+#endif
+
+	m_hMapFile = hMap;
+	m_Data	   = reinterpret_cast<uint8_t*>(pBuf);
+
+	// Write payload: [uint32_t size][compact binary bytes]
+	memcpy(m_Data, &PayloadSize, sizeof PayloadSize);
+	if (PayloadSize > 0)
+	{
+		memcpy(m_Data + sizeof(uint32_t), PayloadView.GetData(), PayloadSize);
+	}
+}
+
+bool
+ZenServerInstanceInfo::OpenReadOnly(const Oid& SessionId)
+{
+	m_SessionId = SessionId;
+
+	std::string Name = MakeName(SessionId);
+
+#if ZEN_PLATFORM_WINDOWS
+	std::wstring WideName(Name.begin(), Name.end());
+
+	HANDLE hMap = OpenFileMappingW(FILE_MAP_READ, FALSE, WideName.c_str());
+	if (hMap == NULL)
+	{
+		// Fall back to Local namespace
+		std::string	 LocalName = fmt::format("Local\\ZenInstance_{}", SessionId);
+		std::wstring WideLocalName(LocalName.begin(), LocalName.end());
+		hMap = OpenFileMappingW(FILE_MAP_READ, FALSE, WideLocalName.c_str());
+	}
+
+	if (hMap == NULL)
+	{
+		return false;
+	}
+
+	void* pBuf = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, DWORD(kInstanceInfoSize));
+	if (pBuf == NULL)
+	{
+		CloseHandle(hMap);
+		return false;
+	}
+#else
+	int	  Fd   = shm_open(Name.c_str(), O_RDONLY | O_CLOEXEC, 0666);
+	if (Fd < 0)
+	{
+		return false;
+	}
+
+	void* pBuf = mmap(nullptr, kInstanceInfoSize, PROT_READ, MAP_SHARED, Fd, 0);
+	if (pBuf == MAP_FAILED)
+	{
+		close(Fd);
+		return false;
+	}
+
+	void* hMap = reinterpret_cast<void*>(intptr_t(Fd));
+#endif
+
+	m_hMapFile = hMap;
+	m_Data	   = reinterpret_cast<uint8_t*>(pBuf);
+	m_IsOwner  = false;
+
+	return true;
+}
+
+InstanceInfoData
+ZenServerInstanceInfo::Read() const
+{
+	InstanceInfoData Result;
+
+	if (m_Data == nullptr)
+	{
+		return Result;
+	}
+
+	uint32_t PayloadSize = 0;
+	memcpy(&PayloadSize, m_Data, sizeof PayloadSize);
+
+	if (PayloadSize == 0 || PayloadSize > kInstanceInfoSize - sizeof(uint32_t))
+	{
+		return Result;
+	}
+
+	CbObject Payload	  = CbObject::Clone(m_Data + sizeof(uint32_t));
+	Result.UnixSocketPath = Payload["unix_socket"].AsU8String();
+
+	return Result;
+}
+
+//////////////////////////////////////////////////////////////////////////
 
 std::atomic<int> ZenServerTestCounter{0};
 
@@ -1234,6 +1474,10 @@ MakeLockFilePayload(const LockFileInfo& Info)
 	CbObjectWriter Cbo;
 	Cbo << "pid" << Info.Pid << "data" << PathToUtf8(Info.DataDir) << "port" << Info.EffectiveListenPort << "session_id" << Info.SessionId
 		<< "ready" << Info.Ready << "executable" << PathToUtf8(Info.ExecutablePath);
+	if (!Info.UnixSocketPath.empty())
+	{
+		Cbo << "unix_socket" << PathToUtf8(Info.UnixSocketPath);
+	}
 	return Cbo.Save();
 }
 LockFileInfo
@@ -1246,6 +1490,7 @@ ReadLockFilePayload(const CbObject& Payload)
 	Info.Ready				 = Payload["ready"].AsBool();
 	Info.DataDir			 = Payload["data"].AsU8String();
 	Info.ExecutablePath		 = Payload["executable"].AsU8String();
+	Info.UnixSocketPath		 = Payload["unix_socket"].AsU8String();
 	return Info;
 }
 
@@ -1275,7 +1520,7 @@ ValidateLockFileInfo(const LockFileInfo& Info, std::string& OutReason)
 		OutReason = fmt::format("session id ({}) is not valid", Info.SessionId);
 		return false;
 	}
-	if (Info.EffectiveListenPort == 0)
+	if (Info.EffectiveListenPort == 0 && Info.UnixSocketPath.empty())
 	{
 		OutReason = fmt::format("listen port ({}) is not valid", Info.EffectiveListenPort);
 		return false;