add hub instance info (#869)

- Improvement: Hub module listing now includes per-instance process metrics (memory, CPU time, working set, pagefile usage)
- Improvement: Hub now monitors provisioned instance health in the background and refreshes process metrics periodically
- Improvement: Hub no longer exposes raw `StorageServerInstance` pointers to callers; instance state is returned as value snapshots (`Hub::InstanceInfo`)
- Improvement: Hub instance access is now guarded by RAII per-instance locks (`SharedLockedPtr`/`ExclusiveLockedPtr`), preventing concurrent modifications during provisioning and deprovisioning
- Improvement: Hub instance lifecycle is now tracked as a `HubInstanceState` enum covering transitional states (Provisioning, Deprovisioning, Hibernating, Waking); exposed as a string in the HTTP API and dashboard

1 files changed, 113 insertions, 16 deletions

diff --git a/src/zenserver/hub/storageserverinstance.h b/src/zenserver/hub/storageserverinstance.h
index 9b8aa7ac9..bf6fff8a0 100644
--- a/src/zenserver/hub/storageserverinstance.h
+++ b/src/zenserver/hub/storageserverinstance.h
@@ -2,6 +2,7 @@
 
 #pragma once
 
+#include "hubinstancestate.h"
 #include "resourcemetrics.h"
 
 #include <zenutil/zenserverprocess.h>
@@ -26,44 +27,137 @@ public:
 		uint16_t			  BasePort;
 		std::filesystem::path HydrationTempPath;
 		std::string			  HydrationTargetSpecification;
-		uint32_t			  HttpThreadCount = 0;	// Deduce from core count
-		int					  CoreLimit		  = 0;	// Use hardware core count
+		uint32_t			  HttpThreadCount = 0;	// Automatic
+		int					  CoreLimit		  = 0;	// Automatic
 		std::filesystem::path ConfigPath;
 	};
 
 	StorageServerInstance(ZenServerEnvironment& RunEnvironment, const Configuration& Config, std::string_view ModuleId);
 	~StorageServerInstance();
 
-	void Provision();
-	void Deprovision();
-
-	void Hibernate();
-	void Wake();
-
 	const ResourceMetrics& GetResourceMetrics() const { return m_ResourceMetrics; }
 
 	inline std::string_view GetModuleId() const { return m_ModuleId; }
-	inline bool				IsProvisioned() const { return m_IsProvisioned.load(); }
-
-	inline uint16_t GetBasePort() const { return m_ServerInstance.GetBasePort(); }
+	inline HubInstanceState GetState() const { return m_State.load(); }
+	inline uint16_t			GetBasePort() const { return m_Config.BasePort; };
+	void					GetProcessMetrics(ProcessMetrics& OutMetrics) const;
 
 #if ZEN_PLATFORM_WINDOWS
 	void SetJobObject(JobObject* InJobObject) { m_JobObject = InJobObject; }
 #endif
 
+	class SharedLockedPtr
+	{
+	public:
+		SharedLockedPtr(const SharedLockedPtr&) = delete;
+		SharedLockedPtr();
+
+		SharedLockedPtr(RwLock& Lock, StorageServerInstance* Instance, bool Wait);
+
+		SharedLockedPtr(SharedLockedPtr&& Rhs);
+		~SharedLockedPtr();
+
+		SharedLockedPtr& operator=(const SharedLockedPtr&) = delete;
+		SharedLockedPtr& operator						   =(SharedLockedPtr&& Rhs);
+
+		operator bool() const { return m_Instance != nullptr; }
+
+		std::string_view GetModuleId() const;
+		HubInstanceState GetState() const
+		{
+			ZEN_ASSERT(m_Instance);
+			return m_Instance->m_State.load();
+		}
+		bool IsRunning() const;
+
+		const ResourceMetrics& GetResourceMetrics() const
+		{
+			ZEN_ASSERT(m_Instance);
+			return m_Instance->m_ResourceMetrics;
+		}
+		void UpdateMetrics()
+		{
+			ZEN_ASSERT(m_Instance);
+			return m_Instance->UpdateMetricsLocked();
+		}
+
+	private:
+		RwLock*				   m_Lock	  = nullptr;
+		StorageServerInstance* m_Instance = nullptr;
+	};
+
+	[[nodiscard]] SharedLockedPtr LockShared(bool Wait) { return SharedLockedPtr(m_Lock, this, Wait); }
+
+	class ExclusiveLockedPtr
+	{
+	public:
+		ExclusiveLockedPtr(const ExclusiveLockedPtr&) = delete;
+		ExclusiveLockedPtr();
+
+		ExclusiveLockedPtr(RwLock& Lock, StorageServerInstance* Instance, bool Wait);
+
+		ExclusiveLockedPtr(ExclusiveLockedPtr&& Rhs);
+		~ExclusiveLockedPtr();
+
+		ExclusiveLockedPtr& operator=(const ExclusiveLockedPtr&) = delete;
+		ExclusiveLockedPtr& operator							 =(ExclusiveLockedPtr&& Rhs);
+
+		operator bool() const { return m_Instance != nullptr; }
+
+		std::string_view GetModuleId() const;
+		HubInstanceState GetState() const
+		{
+			ZEN_ASSERT(m_Instance);
+			return m_Instance->m_State.load();
+		}
+		bool IsRunning() const;
+
+		const ResourceMetrics& GetResourceMetrics() const
+		{
+			ZEN_ASSERT(m_Instance);
+			return m_Instance->m_ResourceMetrics;
+		}
+
+		void Provision();
+		void Deprovision();
+		void Hibernate();
+		bool Wake();
+
+	private:
+		RwLock*				   m_Lock	  = nullptr;
+		StorageServerInstance* m_Instance = nullptr;
+	};
+
+	[[nodiscard]] ExclusiveLockedPtr LockExclusive(bool Wait) { return ExclusiveLockedPtr(m_Lock, this, Wait); }
+
 private:
-	void				WakeLocked();
-	RwLock				m_Lock;
+	void ProvisionLocked();
+	void DeprovisionLocked();
+
+	void			   HibernateLocked();
+	[[nodiscard]] bool WakeLocked();
+
+	void UpdateMetricsLocked();
+
+	mutable RwLock		m_Lock;
 	const Configuration m_Config;
 	std::string			m_ModuleId;
 	ZenServerInstance	m_ServerInstance;
 
-	std::atomic<bool>	  m_IsProvisioned{false};
-	std::atomic<bool>	  m_IsHibernated{false};
-	std::filesystem::path m_BaseDir;
+	std::atomic<HubInstanceState> m_State{HubInstanceState::Unprovisioned};
+	std::filesystem::path		  m_BaseDir;
 
 	std::filesystem::path m_TempDir;
 	ResourceMetrics		  m_ResourceMetrics;
+
+	std::atomic<uint64_t> m_MemoryBytes		   = 0;
+	std::atomic<uint64_t> m_KernelTimeMs	   = 0;
+	std::atomic<uint64_t> m_UserTimeMs		   = 0;
+	std::atomic<uint64_t> m_WorkingSetSize	   = 0;
+	std::atomic<uint64_t> m_PeakWorkingSetSize = 0;
+	std::atomic<uint64_t> m_PagefileUsage	   = 0;
+	std::atomic<uint64_t> m_PeakPagefileUsage  = 0;
+
 #if ZEN_PLATFORM_WINDOWS
 	JobObject* m_JobObject = nullptr;
 #endif
@@ -72,6 +166,9 @@ private:
 
 	void Hydrate();
 	void Dehydrate();
+
+	friend class SharedLockedPtr;
+	friend class ExclusiveLockedPtr;
 };
 
 }  // namespace zen