Merged main into linux-mac

1 files changed, 500 insertions, 33 deletions

diff --git a/zenserver-test/zenserver-test.cpp b/zenserver-test/zenserver-test.cpp
index 1a41a5541..794a5fe94 100644
--- a/zenserver-test/zenserver-test.cpp
+++ b/zenserver-test/zenserver-test.cpp
@@ -12,6 +12,7 @@
 #include <zencore/iohash.h>
 #include <zencore/logging.h>
 #include <zencore/memory.h>
+#include <zencore/refcount.h>
 #include <zencore/stream.h>
 #include <zencore/string.h>
 #include <zencore/thread.h>
@@ -19,9 +20,11 @@
 #include <zenhttp/httpclient.h>
 #include <zenhttp/httpshared.h>
 #include <zenhttp/zenhttp.h>
-#include <zenserverprocess.h>
+#include <zenutil/zenserverprocess.h>
 
-#include <mimalloc.h>
+#if ZEN_USE_MIMALLOC
+#	include <mimalloc.h>
+#endif
 
 #include <http_parser.h>
 
@@ -37,6 +40,7 @@
 #include <map>
 #include <random>
 #include <span>
+#include <unordered_map>
 
 #include <atlbase.h>
 #include <process.h>
@@ -49,9 +53,11 @@
 
 //////////////////////////////////////////////////////////////////////////
 
-#define DOCTEST_CONFIG_IMPLEMENT
-#include <doctest/doctest.h>
-#undef DOCTEST_CONFIG_IMPLEMENT
+#if ZEN_WITH_TESTS
+#	define DOCTEST_CONFIG_IMPLEMENT
+#	include <zencore/testing.h>
+#	undef DOCTEST_CONFIG_IMPLEMENT
+#endif
 
 using namespace fmt::literals;
 
@@ -80,7 +86,7 @@ class HttpClientConnection
 	static HttpClientConnection* This(http_parser* Parser) { return (HttpClientConnection*)Parser->data; };
 
 public:
-	HttpClientConnection(asio::io_context& IoContext, HttpConnectionPool& Pool, asio::ip::tcp::socket&& InSocket)
+	HttpClientConnection(asio::io_context& IoContext, zen::Ref<HttpConnectionPool> Pool, asio::ip::tcp::socket&& InSocket)
 	: m_IoContext(IoContext)
 	, m_Pool(Pool)
 	, m_Resolver(IoContext)
@@ -89,8 +95,8 @@ public:
 	}
 	~HttpClientConnection() {}
 
-	HttpConnectionPool& ConnectionPool() { return m_Pool; }
-	void				SetKeepAlive(bool NewState) { m_KeepAlive = NewState; }
+	zen::Ref<HttpConnectionPool> ConnectionPool() { return m_Pool; }
+	void						 SetKeepAlive(bool NewState) { m_KeepAlive = NewState; }
 
 	void Get(const std::string_view Server, int Port, const std::string_view Path)
 	{
@@ -227,16 +233,16 @@ private:
 	}
 
 private:
-	asio::io_context&		m_IoContext;
-	HttpConnectionPool&		m_Pool;
-	asio::ip::tcp::resolver m_Resolver;
-	asio::ip::tcp::socket	m_Socket;
-	std::string				m_Uri;
-	std::string				m_RequestBody;	// Initial request data
-	http_parser				m_HttpParser{};
-	http_parser_settings	m_HttpParserSettings{};
-	uint8_t					m_ResponseIoBuffer[4096];
-	asio::mutable_buffer	m_ResponseBuffer{m_ResponseIoBuffer, sizeof m_ResponseIoBuffer};
+	asio::io_context&			 m_IoContext;
+	zen::Ref<HttpConnectionPool> m_Pool;
+	asio::ip::tcp::resolver		 m_Resolver;
+	asio::ip::tcp::socket		 m_Socket;
+	std::string					 m_Uri;
+	std::string					 m_RequestBody;	 // Initial request data
+	http_parser					 m_HttpParser{};
+	http_parser_settings		 m_HttpParserSettings{};
+	uint8_t						 m_ResponseIoBuffer[4096];
+	asio::mutable_buffer		 m_ResponseBuffer{m_ResponseIoBuffer, sizeof m_ResponseIoBuffer};
 
 	enum class RequestState
 	{
@@ -259,7 +265,7 @@ private:
 
 //////////////////////////////////////////////////////////////////////////
 
-class HttpConnectionPool
+class HttpConnectionPool : public zen::RefCounted
 {
 public:
 	HttpConnectionPool(asio::io_context& Context, std::string_view HostName, uint16_t Port);
@@ -322,7 +328,7 @@ HttpConnectionPool::GetConnection()
 			return nullptr;
 		}
 
-		return std::make_unique<HttpClientConnection>(m_Context, *this, std::move(Socket));
+		return std::make_unique<HttpClientConnection>(m_Context, this, std::move(Socket));
 	}
 
 	std::unique_ptr<HttpClientConnection> Connection{m_AvailableConnections.back()};
@@ -347,15 +353,15 @@ public:
 
 	std::unique_ptr<HttpClientConnection> GetConnection(std::string_view HostName, uint16_t Port)
 	{
-		return ConnectionPool(HostName, Port).GetConnection();
+		return ConnectionPool(HostName, Port)->GetConnection();
 	}
 
 	void ReturnConnection(std::unique_ptr<HttpClientConnection> Connection)
 	{
-		Connection->ConnectionPool().ReturnConnection(std::move(Connection));
+		Connection->ConnectionPool()->ReturnConnection(std::move(Connection));
 	}
 
-	HttpConnectionPool& ConnectionPool(std::string_view HostName, uint16_t Port)
+	zen::Ref<HttpConnectionPool> ConnectionPool(std::string_view HostName, uint16_t Port)
 	{
 		zen::RwLock::ExclusiveLockScope _(m_Lock);
 		ConnectionId					ConnId{std::string(HostName), Port};
@@ -364,7 +370,7 @@ public:
 		{
 			// Not found - create new entry
 
-			auto In = m_ConnectionPools.insert({ConnId, std::move(HttpConnectionPool(m_Context, HostName, Port))});
+			auto In = m_ConnectionPools.emplace(ConnId, new HttpConnectionPool(m_Context, HostName, Port));
 
 			return In.first->second;
 		}
@@ -393,8 +399,8 @@ private:
 		uint16_t	Port;
 	};
 
-	zen::RwLock								   m_Lock;
-	std::map<ConnectionId, HttpConnectionPool> m_ConnectionPools;
+	zen::RwLock											 m_Lock;
+	std::map<ConnectionId, zen::Ref<HttpConnectionPool>> m_ConnectionPools;
 };
 
 //////////////////////////////////////////////////////////////////////////
@@ -655,22 +661,24 @@ main()
 		[](auto req) { return req->create_response().set_body("Hello, World!").done(); }));
 	return 0;
 }
-#else
+#elif ZEN_WITH_TESTS
 
-ZenServerEnvironment TestEnv;
+zen::ZenServerEnvironment TestEnv;
 
 int
 main(int argc, char** argv)
 {
+#	if ZEN_USE_MIMALLOC
 	mi_version();
+#	endif
 
-	zencore_forcelinktests();
+	zen::zencore_forcelinktests();
 	zen::zenhttp_forcelinktests();
 
 	zen::logging::InitializeLogging();
 
 	spdlog::set_level(spdlog::level::debug);
-	spdlog::set_formatter(std::make_unique<logging::full_formatter>("test", std::chrono::system_clock::now()));
+	spdlog::set_formatter(std::make_unique<::logging::full_formatter>("test", std::chrono::system_clock::now()));
 
 	std::filesystem::path ProgramBaseDir = std::filesystem::path(argv[0]).parent_path();
 	std::filesystem::path TestBaseDir	 = ProgramBaseDir.parent_path().parent_path() / ".test";
@@ -681,6 +689,8 @@ main(int argc, char** argv)
 	return doctest::Context(argc, argv).run();
 }
 
+namespace zen::tests {
+
 #	if 1
 TEST_CASE("asio.http")
 {
@@ -1400,6 +1410,395 @@ TEST_CASE("zcache.cbpackage")
 	}
 }
 
+TEST_CASE("zcache.policy")
+{
+	using namespace std::literals;
+
+	struct ZenConfig
+	{
+		std::filesystem::path DataDir;
+		uint16_t			  Port;
+		std::string			  BaseUri;
+		std::string			  Args;
+
+		static ZenConfig New(uint16_t Port = 13337, std::string Args = "")
+		{
+			return ZenConfig{.DataDir = TestEnv.CreateNewTestDir(),
+							 .Port	  = Port,
+							 .BaseUri = "http://localhost:{}/z$"_format(Port),
+							 .Args	  = std::move(Args)};
+		}
+
+		static ZenConfig NewWithUpstream(uint16_t UpstreamPort)
+		{
+			return New(13337, "--upstream-thread-count=0 --upstream-zen-url=http://localhost:{}"_format(UpstreamPort));
+		}
+
+		void Spawn(ZenServerInstance& Inst)
+		{
+			Inst.SetTestDir(DataDir);
+			Inst.SpawnServer(Port, Args);
+			Inst.WaitUntilReady();
+		}
+	};
+
+	auto GenerateData = [](uint64_t Size, zen::IoHash& OutHash) -> zen::UniqueBuffer {
+		auto	 Buf  = zen::UniqueBuffer::Alloc(Size);
+		uint8_t* Data = reinterpret_cast<uint8_t*>(Buf.GetData());
+		for (uint64_t Idx = 0; Idx < Size; Idx++)
+		{
+			Data[Idx] = Idx % 256;
+		}
+		OutHash = zen::IoHash::HashBuffer(Data, Size);
+		return Buf;
+	};
+
+	auto GeneratePackage = [](zen::IoHash& OutAttachmentKey) -> zen::CbPackage {
+		auto Data			= zen::SharedBuffer::Clone(zen::MakeMemoryView<uint8_t>({1, 2, 3, 4, 5, 6, 7, 8, 9}));
+		auto CompressedData = zen::CompressedBuffer::Compress(Data);
+		OutAttachmentKey	= zen::IoHash::FromBLAKE3(CompressedData.GetRawHash());
+		zen::CbWriter Obj;
+		Obj.BeginObject("obj"sv);
+		Obj.AddBinaryAttachment("data", OutAttachmentKey);
+		Obj.EndObject();
+		zen::CbPackage Package;
+		Package.SetObject(Obj.Save().AsObject());
+		Package.AddAttachment(zen::CbAttachment(CompressedData));
+
+		return Package;
+	};
+
+	auto ToBuffer = [](zen::CbPackage Package) -> zen::IoBuffer {
+		zen::MemoryOutStream MemStream;
+		zen::BinaryWriter	 Writer(MemStream);
+		Package.Save(Writer);
+
+		return zen::IoBuffer(zen::IoBuffer::Clone, MemStream.Data(), MemStream.Size());
+	};
+
+	SUBCASE("query - 'local' does not query upstream (binary)")
+	{
+		ZenConfig		  UpstreamCfg = ZenConfig::New(13338);
+		ZenServerInstance UpstreamInst(TestEnv);
+		ZenConfig		  LocalCfg = ZenConfig::NewWithUpstream(13338);
+		ZenServerInstance LocalInst(TestEnv);
+		const auto		  Bucket = "legacy"sv;
+
+		UpstreamCfg.Spawn(UpstreamInst);
+		LocalCfg.Spawn(LocalInst);
+
+		zen::IoHash Key;
+		auto		BinaryValue = GenerateData(1024, Key);
+
+		// Store binary cache value upstream
+		{
+			cpr::Response Result = cpr::Put(cpr::Url{"{}/{}/{}"_format(UpstreamCfg.BaseUri, Bucket, Key)},
+											cpr::Body{(const char*)BinaryValue.GetData(), BinaryValue.GetSize()},
+											cpr::Header{{"Content-Type", "application/octet-stream"}});
+			CHECK(Result.status_code == 201);
+		}
+
+		{
+			cpr::Response Result = cpr::Get(cpr::Url{"{}/{}/{}?query=local"_format(LocalCfg.BaseUri, Bucket, Key)},
+											cpr::Header{{"Accept", "application/octet-stream"}});
+			CHECK(Result.status_code == 404);
+		}
+
+		{
+			cpr::Response Result = cpr::Get(cpr::Url{"{}/{}/{}?query=local,remote"_format(LocalCfg.BaseUri, Bucket, Key)},
+											cpr::Header{{"Accept", "application/octet-stream"}});
+			CHECK(Result.status_code == 200);
+		}
+	}
+
+	SUBCASE("store - 'local' does not store upstream (binary)")
+	{
+		ZenConfig		  UpstreamCfg = ZenConfig::New(13338);
+		ZenServerInstance UpstreamInst(TestEnv);
+		ZenConfig		  LocalCfg = ZenConfig::NewWithUpstream(13338);
+		ZenServerInstance LocalInst(TestEnv);
+		const auto		  Bucket = "legacy"sv;
+
+		UpstreamCfg.Spawn(UpstreamInst);
+		LocalCfg.Spawn(LocalInst);
+
+		zen::IoHash Key;
+		auto		BinaryValue = GenerateData(1024, Key);
+
+		// Store binary cache value locally
+		{
+			cpr::Response Result = cpr::Put(cpr::Url{"{}/{}/{}?store=local"_format(LocalCfg.BaseUri, Bucket, Key)},
+											cpr::Body{(const char*)BinaryValue.GetData(), BinaryValue.GetSize()},
+											cpr::Header{{"Content-Type", "application/octet-stream"}});
+			CHECK(Result.status_code == 201);
+		}
+
+		{
+			cpr::Response Result = cpr::Get(cpr::Url{"{}/{}/{}"_format(UpstreamCfg.BaseUri, Bucket, Key)},
+											cpr::Header{{"Accept", "application/octet-stream"}});
+			CHECK(Result.status_code == 404);
+		}
+
+		{
+			cpr::Response Result =
+				cpr::Get(cpr::Url{"{}/{}/{}"_format(LocalCfg.BaseUri, Bucket, Key)}, cpr::Header{{"Accept", "application/octet-stream"}});
+			CHECK(Result.status_code == 200);
+		}
+	}
+
+	SUBCASE("store - 'local/remote' stores local and upstream (binary)")
+	{
+		ZenConfig		  UpstreamCfg = ZenConfig::New(13338);
+		ZenServerInstance UpstreamInst(TestEnv);
+		ZenConfig		  LocalCfg = ZenConfig::NewWithUpstream(13338);
+		ZenServerInstance LocalInst(TestEnv);
+		const auto		  Bucket = "legacy"sv;
+
+		UpstreamCfg.Spawn(UpstreamInst);
+		LocalCfg.Spawn(LocalInst);
+
+		zen::IoHash Key;
+		auto		BinaryValue = GenerateData(1024, Key);
+
+		// Store binary cache value locally and upstream
+		{
+			cpr::Response Result = cpr::Put(cpr::Url{"{}/{}/{}?store=local,remote"_format(LocalCfg.BaseUri, Bucket, Key)},
+											cpr::Body{(const char*)BinaryValue.GetData(), BinaryValue.GetSize()},
+											cpr::Header{{"Content-Type", "application/octet-stream"}});
+			CHECK(Result.status_code == 201);
+		}
+
+		{
+			cpr::Response Result = cpr::Get(cpr::Url{"{}/{}/{}"_format(UpstreamCfg.BaseUri, Bucket, Key)},
+											cpr::Header{{"Accept", "application/octet-stream"}});
+			CHECK(Result.status_code == 200);
+		}
+
+		{
+			cpr::Response Result =
+				cpr::Get(cpr::Url{"{}/{}/{}"_format(LocalCfg.BaseUri, Bucket, Key)}, cpr::Header{{"Accept", "application/octet-stream"}});
+			CHECK(Result.status_code == 200);
+		}
+	}
+
+	SUBCASE("query - 'local' does not query upstream (cppackage)")
+	{
+		ZenConfig		  UpstreamCfg = ZenConfig::New(13338);
+		ZenServerInstance UpstreamInst(TestEnv);
+		ZenConfig		  LocalCfg = ZenConfig::NewWithUpstream(13338);
+		ZenServerInstance LocalInst(TestEnv);
+		const auto		  Bucket = "legacy"sv;
+
+		UpstreamCfg.Spawn(UpstreamInst);
+		LocalCfg.Spawn(LocalInst);
+
+		zen::IoHash	   Key;
+		zen::CbPackage Package = GeneratePackage(Key);
+		auto		   Buf	   = ToBuffer(Package);
+
+		// Store package upstream
+		{
+			cpr::Response Result = cpr::Put(cpr::Url{"{}/{}/{}"_format(UpstreamCfg.BaseUri, Bucket, Key)},
+											cpr::Body{(const char*)Buf.GetData(), Buf.GetSize()},
+											cpr::Header{{"Content-Type", "application/x-ue-cbpkg"}});
+			CHECK(Result.status_code == 201);
+		}
+
+		{
+			cpr::Response Result = cpr::Get(cpr::Url{"{}/{}/{}?query=local"_format(LocalCfg.BaseUri, Bucket, Key)},
+											cpr::Header{{"Accept", "application/x-ue-cbpkg"}});
+			CHECK(Result.status_code == 404);
+		}
+
+		{
+			cpr::Response Result = cpr::Get(cpr::Url{"{}/{}/{}?query=local,remote"_format(LocalCfg.BaseUri, Bucket, Key)},
+											cpr::Header{{"Accept", "application/x-ue-cbpkg"}});
+			CHECK(Result.status_code == 200);
+		}
+	}
+
+	SUBCASE("store - 'local' does not store upstream (cbpackge)")
+	{
+		ZenConfig		  UpstreamCfg = ZenConfig::New(13338);
+		ZenServerInstance UpstreamInst(TestEnv);
+		ZenConfig		  LocalCfg = ZenConfig::NewWithUpstream(13338);
+		ZenServerInstance LocalInst(TestEnv);
+		const auto		  Bucket = "legacy"sv;
+
+		UpstreamCfg.Spawn(UpstreamInst);
+		LocalCfg.Spawn(LocalInst);
+
+		zen::IoHash	   Key;
+		zen::CbPackage Package = GeneratePackage(Key);
+		auto		   Buf	   = ToBuffer(Package);
+
+		// Store packge locally
+		{
+			cpr::Response Result = cpr::Put(cpr::Url{"{}/{}/{}?store=local"_format(LocalCfg.BaseUri, Bucket, Key)},
+											cpr::Body{(const char*)Buf.GetData(), Buf.GetSize()},
+											cpr::Header{{"Content-Type", "application/x-ue-cbpkg"}});
+			CHECK(Result.status_code == 201);
+		}
+
+		{
+			cpr::Response Result =
+				cpr::Get(cpr::Url{"{}/{}/{}"_format(UpstreamCfg.BaseUri, Bucket, Key)}, cpr::Header{{"Accept", "application/x-ue-cbpkg"}});
+			CHECK(Result.status_code == 404);
+		}
+
+		{
+			cpr::Response Result =
+				cpr::Get(cpr::Url{"{}/{}/{}"_format(LocalCfg.BaseUri, Bucket, Key)}, cpr::Header{{"Accept", "application/x-ue-cbpkg"}});
+			CHECK(Result.status_code == 200);
+		}
+	}
+
+	SUBCASE("store - 'local/remote' stores local and upstream (cbpackage)")
+	{
+		ZenConfig		  UpstreamCfg = ZenConfig::New(13338);
+		ZenServerInstance UpstreamInst(TestEnv);
+		ZenConfig		  LocalCfg = ZenConfig::NewWithUpstream(13338);
+		ZenServerInstance LocalInst(TestEnv);
+		const auto		  Bucket = "legacy"sv;
+
+		UpstreamCfg.Spawn(UpstreamInst);
+		LocalCfg.Spawn(LocalInst);
+
+		zen::IoHash	   Key;
+		zen::CbPackage Package = GeneratePackage(Key);
+		auto		   Buf	   = ToBuffer(Package);
+
+		// Store package locally and upstream
+		{
+			cpr::Response Result = cpr::Put(cpr::Url{"{}/{}/{}?store=local,remote"_format(LocalCfg.BaseUri, Bucket, Key)},
+											cpr::Body{(const char*)Buf.GetData(), Buf.GetSize()},
+											cpr::Header{{"Content-Type", "application/x-ue-cbpkg"}});
+			CHECK(Result.status_code == 201);
+		}
+
+		{
+			cpr::Response Result =
+				cpr::Get(cpr::Url{"{}/{}/{}"_format(UpstreamCfg.BaseUri, Bucket, Key)}, cpr::Header{{"Accept", "application/x-ue-cbpkg"}});
+			CHECK(Result.status_code == 200);
+		}
+
+		{
+			cpr::Response Result =
+				cpr::Get(cpr::Url{"{}/{}/{}"_format(LocalCfg.BaseUri, Bucket, Key)}, cpr::Header{{"Accept", "application/x-ue-cbpkg"}});
+			CHECK(Result.status_code == 200);
+		}
+	}
+
+	SUBCASE("skip - 'attachments' does not return attachments")
+	{
+		ZenConfig		  LocalCfg = ZenConfig::New();
+		ZenServerInstance LocalInst(TestEnv);
+		const auto		  Bucket = "texture"sv;
+
+		LocalCfg.Spawn(LocalInst);
+
+		zen::IoHash	   Key;
+		zen::CbPackage Package = GeneratePackage(Key);
+		auto		   Buf	   = ToBuffer(Package);
+
+		// Store package locally
+		{
+			CHECK(Package.GetAttachments().size() != 0);
+			cpr::Response Result = cpr::Put(cpr::Url{"{}/{}/{}"_format(LocalCfg.BaseUri, Bucket, Key)},
+											cpr::Body{(const char*)Buf.GetData(), Buf.GetSize()},
+											cpr::Header{{"Content-Type", "application/x-ue-cbpkg"}});
+			CHECK(Result.status_code == 201);
+		}
+
+		{
+			cpr::Response Result = cpr::Get(cpr::Url{"{}/{}/{}?skip=attachments"_format(LocalCfg.BaseUri, Bucket, Key)},
+											cpr::Header{{"Accept", "application/x-ue-cbpkg"}});
+			CHECK(Result.status_code == 200);
+
+			zen::IoBuffer  Body(zen::IoBuffer::Wrap, Result.text.data(), Result.text.size());
+			zen::CbPackage Package;
+			const bool	   Ok = Package.TryLoad(Body);
+
+			CbObject			CacheRecord = Package.GetObject();
+			std::vector<IoHash> AttachmentKeys;
+
+			CacheRecord.IterateAttachments(
+				[&AttachmentKeys](CbFieldView AttachmentKey) { AttachmentKeys.push_back(AttachmentKey.AsHash()); });
+
+			CHECK(AttachmentKeys.size() != 0);
+			CHECK(Package.GetAttachments().size() == 0);
+		}
+
+		{
+			cpr::Response Result =
+				cpr::Get(cpr::Url{"{}/{}/{}"_format(LocalCfg.BaseUri, Bucket, Key)}, cpr::Header{{"Accept", "application/x-ue-cbpkg"}});
+			CHECK(Result.status_code == 200);
+
+			zen::IoBuffer  Body(zen::IoBuffer::Wrap, Result.text.data(), Result.text.size());
+			zen::CbPackage Package;
+			const bool	   Ok = Package.TryLoad(Body);
+
+			CHECK(Package.GetAttachments().size() != 0);
+		}
+	}
+
+	SUBCASE("skip - 'attachments' does not return attachments when retrieved from upstream")
+	{
+		ZenConfig		  UpstreamCfg = ZenConfig::New(13338);
+		ZenServerInstance UpstreamInst(TestEnv);
+		ZenConfig		  LocalCfg = ZenConfig::NewWithUpstream(13338);
+		ZenServerInstance LocalInst(TestEnv);
+		const auto		  Bucket = "texture"sv;
+
+		UpstreamCfg.Spawn(UpstreamInst);
+		LocalCfg.Spawn(LocalInst);
+
+		zen::IoHash	   Key;
+		zen::CbPackage Package = GeneratePackage(Key);
+		auto		   Buf	   = ToBuffer(Package);
+
+		// Store package upstream
+		{
+			CHECK(Package.GetAttachments().size() != 0);
+			cpr::Response Result = cpr::Put(cpr::Url{"{}/{}/{}"_format(UpstreamCfg.BaseUri, Bucket, Key)},
+											cpr::Body{(const char*)Buf.GetData(), Buf.GetSize()},
+											cpr::Header{{"Content-Type", "application/x-ue-cbpkg"}});
+			CHECK(Result.status_code == 201);
+		}
+
+		{
+			cpr::Response Result = cpr::Get(cpr::Url{"{}/{}/{}?skip=attachments"_format(LocalCfg.BaseUri, Bucket, Key)},
+											cpr::Header{{"Accept", "application/x-ue-cbpkg"}});
+			CHECK(Result.status_code == 200);
+
+			zen::IoBuffer  Body(zen::IoBuffer::Wrap, Result.text.data(), Result.text.size());
+			zen::CbPackage Package;
+			const bool	   Ok = Package.TryLoad(Body);
+
+			CbObject			CacheRecord = Package.GetObject();
+			std::vector<IoHash> AttachmentKeys;
+
+			CacheRecord.IterateAttachments(
+				[&AttachmentKeys](CbFieldView AttachmentKey) { AttachmentKeys.push_back(AttachmentKey.AsHash()); });
+
+			CHECK(AttachmentKeys.size() != 0);
+			CHECK(Package.GetAttachments().size() == 0);
+		}
+
+		{
+			cpr::Response Result =
+				cpr::Get(cpr::Url{"{}/{}/{}"_format(LocalCfg.BaseUri, Bucket, Key)}, cpr::Header{{"Accept", "application/x-ue-cbpkg"}});
+			CHECK(Result.status_code == 200);
+
+			zen::IoBuffer  Body(zen::IoBuffer::Wrap, Result.text.data(), Result.text.size());
+			zen::CbPackage Package;
+			const bool	   Ok = Package.TryLoad(Body);
+
+			CHECK(Package.GetAttachments().size() != 0);
+		}
+	}
+}
+
 struct RemoteExecutionRequest
 {
 	RemoteExecutionRequest(std::string_view Host, int Port, std::filesystem::path& TreePath)
@@ -1637,9 +2036,9 @@ public:
 	ZenServerInstance& GetInstance(int Index) { return *m_Instances[Index]; }
 
 private:
-	std::string										 m_HelperId;
-	int												 m_ServerCount = 0;
-	std::vector<std::unique_ptr<ZenServerInstance> > m_Instances;
+	std::string										m_HelperId;
+	int												m_ServerCount = 0;
+	std::vector<std::unique_ptr<ZenServerInstance>> m_Instances;
 };
 
 TEST_CASE("http.basics")
@@ -1709,4 +2108,72 @@ TEST_CASE("http.package")
 	CHECK_EQ(ResponsePackage, TestPackage);
 }
 
+#	if 0
+TEST_CASE("lifetime.owner")
+{
+	// This test is designed to verify that the hand-over of sponsor processes is handled
+	// correctly for the case when a second or third process is launched on the same port
+	//
+	// Due to the nature of it, it cannot be
+
+	const uint16_t PortNumber = 23456;
+
+	ZenServerInstance	  Zen1(TestEnv);
+	std::filesystem::path TestDir1 = TestEnv.CreateNewTestDir();
+	Zen1.SetTestDir(TestDir1);
+	Zen1.SpawnServer(PortNumber);
+	Zen1.WaitUntilReady();
+	Zen1.Detach();
+
+	ZenServerInstance	  Zen2(TestEnv);
+	std::filesystem::path TestDir2 = TestEnv.CreateNewTestDir();
+	Zen2.SetTestDir(TestDir2);
+	Zen2.SpawnServer(PortNumber);
+	Zen2.WaitUntilReady();
+	Zen2.Detach();
+}
+
+TEST_CASE("lifetime.owner.2")
+{
+	// This test is designed to verify that the hand-over of sponsor processes is handled
+	// correctly for the case when a second or third process is launched on the same port
+	//
+	// Due to the nature of it, it cannot be
+
+	const uint16_t PortNumber = 13456;
+
+	std::filesystem::path TestDir1 = TestEnv.CreateNewTestDir();
+	std::filesystem::path TestDir2 = TestEnv.CreateNewTestDir();
+
+	ZenServerInstance Zen1(TestEnv);
+	Zen1.SetTestDir(TestDir1);
+	Zen1.SpawnServer(PortNumber);
+	Zen1.WaitUntilReady();
+
+	ZenServerInstance Zen2(TestEnv);
+	Zen2.SetTestDir(TestDir2);
+	Zen2.SetOwnerPid(Zen1.GetPid());
+	Zen2.SpawnServer(PortNumber + 1);
+	Zen2.Detach();
+
+	ZenServerInstance Zen3(TestEnv);
+	Zen3.SetTestDir(TestDir2);
+	Zen3.SetOwnerPid(Zen1.GetPid());
+	Zen3.SpawnServer(PortNumber + 1);
+	Zen3.Detach();
+
+	ZenServerInstance Zen4(TestEnv);
+	Zen4.SetTestDir(TestDir2);
+	Zen4.SetOwnerPid(Zen1.GetPid());
+	Zen4.SpawnServer(PortNumber + 1);
+	Zen4.Detach();
+}
+#	endif
+
+}  // namespace zen::tests
+#else
+int
+main()
+{
+}
 #endif