1 files changed, 113 insertions, 25 deletions

diff --git a/src/zenserver/hub/storageserverinstance.h b/src/zenserver/hub/storageserverinstance.h
index 3b3cae385..c5917afc9 100644
--- a/src/zenserver/hub/storageserverinstance.h
+++ b/src/zenserver/hub/storageserverinstance.h
@@ -2,8 +2,9 @@
 
 #pragma once
 
-#include "resourcemetrics.h"
+#include "hydration.h"
 
+#include <zencore/compactbinary.h>
 #include <zenutil/zenserverprocess.h>
 
 #include <atomic>
@@ -11,6 +12,8 @@
 
 namespace zen {
 
+class WorkerThreadPool;
+
 /**
  * Storage Server Instance
  *
@@ -24,54 +27,139 @@ public:
 	struct Configuration
 	{
 		uint16_t			  BasePort;
-		std::filesystem::path HydrationTempPath;
-		std::filesystem::path FileHydrationPath;
-		uint32_t			  HttpThreadCount = 0;	// Deduce from core count
-		int					  CoreLimit		  = 0;	// Use hardware core count
+		std::filesystem::path StateDir;
+		std::filesystem::path TempDir;
+		uint32_t			  HttpThreadCount = 0;	// Automatic
+		int					  CoreLimit		  = 0;	// Automatic
 		std::filesystem::path ConfigPath;
+		std::string			  Malloc;
+		std::string			  Trace;
+		std::string			  TraceHost;
+		std::string			  TraceFile;
+
+		WorkerThreadPool* OptionalWorkerPool = nullptr;
 	};
 
-	StorageServerInstance(ZenServerEnvironment& RunEnvironment, const Configuration& Config, std::string_view ModuleId);
+	StorageServerInstance(ZenServerEnvironment& RunEnvironment,
+						  HydrationBase&		Hydration,
+						  const Configuration&	Config,
+						  std::string_view		ModuleId);
 	~StorageServerInstance();
 
-	void Provision();
-	void Deprovision();
+	inline std::string_view GetModuleId() const { return m_ModuleId; }
+	inline uint16_t			GetBasePort() const { return m_Config.BasePort; }
+	ProcessMetrics			GetProcessMetrics() const;
 
-	void Hibernate();
-	void Wake();
+#if ZEN_PLATFORM_WINDOWS
+	void SetJobObject(JobObject* InJobObject) { m_JobObject = InJobObject; }
+#endif
 
-	const ResourceMetrics& GetResourceMetrics() const { return m_ResourceMetrics; }
+	class SharedLockedPtr
+	{
+	public:
+		SharedLockedPtr(const SharedLockedPtr&) = delete;
+		SharedLockedPtr();
 
-	inline std::string_view GetModuleId() const { return m_ModuleId; }
-	inline bool				IsProvisioned() const { return m_IsProvisioned.load(); }
+		SharedLockedPtr(RwLock& Lock, StorageServerInstance* Instance, bool Wait);
 
-	inline uint16_t GetBasePort() const { return m_ServerInstance.GetBasePort(); }
+		SharedLockedPtr(SharedLockedPtr&& Rhs);
+		~SharedLockedPtr();
 
-#if ZEN_PLATFORM_WINDOWS
-	void SetJobObject(JobObject* InJobObject) { m_JobObject = InJobObject; }
+		SharedLockedPtr& operator=(const SharedLockedPtr&) = delete;
+		SharedLockedPtr& operator						   =(SharedLockedPtr&& Rhs);
+
+		operator bool() const { return m_Instance != nullptr; }
+
+		std::string_view GetModuleId() const;
+		uint16_t		 GetBasePort() const
+		{
+			ZEN_ASSERT(m_Instance);
+			return m_Instance->GetBasePort();
+		}
+		bool IsRunning() const;
+
+		ProcessMetrics GetProcessMetrics() const
+		{
+			ZEN_ASSERT(m_Instance);
+			return m_Instance->GetProcessMetrics();
+		}
+
+#if ZEN_WITH_TESTS
+		void TerminateForTesting() const;  // kills the child process to simulate a crash
 #endif
 
+	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;
+		uint16_t		 GetBasePort() const
+		{
+			ZEN_ASSERT(m_Instance);
+			return m_Instance->GetBasePort();
+		}
+		bool IsRunning() const;
+
+		void Provision();
+		void Deprovision();
+		void Obliterate();
+		void Hibernate();
+		void 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 ObliterateLocked();
+
+	void HibernateLocked();
+	void WakeLocked();
+
+	mutable RwLock		m_Lock;
+	HydrationBase&		m_Hydration;
 	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;
+	CbObject m_HydrationState;
 
-	std::filesystem::path m_TempDir;
-	ResourceMetrics		  m_ResourceMetrics;
 #if ZEN_PLATFORM_WINDOWS
 	JobObject* m_JobObject = nullptr;
 #endif
 
 	void SpawnServerProcess();
 
-	void Hydrate();
-	void Dehydrate();
+	void			Hydrate();
+	void			Dehydrate();
+	HydrationConfig MakeHydrationConfig(std::atomic<bool>& AbortFlag, std::atomic<bool>& PauseFlag);
+
+	friend class SharedLockedPtr;
+	friend class ExclusiveLockedPtr;
 };
 
 }  // namespace zen