cacherequests helpers test only (#551)

* don't use cacherequests utils in cache_cmd.cpp
* make zenutil/cacherequests code into test code helpers only

22 files changed, 460 insertions, 392 deletions

diff --git a/src/zen/cmds/cache_cmd.cpp b/src/zen/cmds/cache_cmd.cpp
index 5948a7f1d..85dcd7648 100644
--- a/src/zen/cmds/cache_cmd.cpp
+++ b/src/zen/cmds/cache_cmd.cpp
@@ -2,6 +2,7 @@
 
 #include "cache_cmd.h"
 
+#include <zencore/compactbinarybuilder.h>
 #include <zencore/compress.h>
 #include <zencore/except.h>
 #include <zencore/filesystem.h>
@@ -13,7 +14,7 @@
 #include <zenhttp/httpclient.h>
 #include <zenhttp/httpcommon.h>
 #include <zenhttp/packageformat.h>
-#include <zenutil/cache/cacherequests.h>
+#include <zenstore/cache/cachepolicy.h>
 
 #include <memory>
 #include <random>
@@ -432,32 +433,109 @@ CacheGenerateCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** a
 
 	HttpClient Http(m_HostName);
 
-	auto GeneratePutCacheValueRequest([this, &KeyDistribution, &Generator](std::span<std::uint64_t> BatchSizes, uint64_t RequestIndex) {
-		cacherequests::PutCacheValuesRequest Request({.AcceptMagic = kCbPkgMagic, .Namespace = m_Namespace});
-		for (std::uint64_t ValueSize : BatchSizes)
-		{
-			uint64_t	KeyBase	  = KeyDistribution(Generator);
-			std::string KeyString = fmt::format("{}-{}-{}", RequestIndex, KeyBase, ValueSize);
-			IoHash		ValueKey  = IoHash::HashBuffer(KeyString.c_str(), KeyString.length());
+	auto GeneratePutCacheValueRequest(
+		[this, &KeyDistribution, &Generator](std::span<std::uint64_t> BatchSizes, uint64_t RequestIndex) -> CbPackage {
+			CbPackage Package;
 
-			Request.Requests.emplace_back(cacherequests::PutCacheValueRequest{.Key	= {.Bucket = m_Bucket, .Hash = ValueKey},
-																			  .Body = CompressBlob(CreateRandomBlob(ValueSize))});
-		}
-		return Request;
-	});
+			CbObjectWriter Writer;
+			Writer << "Method"
+				   << "PutCacheValues";
+			Writer << "Accept" << kCbPkgMagic;
+
+			Writer.BeginObject("Params");
+			{
+				Writer << "DefaultPolicy" << WriteToString<128>(CachePolicy::Default);
+				Writer << "Namespace" << m_Namespace;
+
+				Writer.BeginArray("Requests");
+
+				for (std::uint64_t ValueSize : BatchSizes)
+				{
+					Writer.BeginObject();
+					{
+						uint64_t	KeyBase	  = KeyDistribution(Generator);
+						std::string KeyString = fmt::format("{}-{}-{}", RequestIndex, KeyBase, ValueSize);
+						IoHash		ValueKey  = IoHash::HashBuffer(KeyString.c_str(), KeyString.length());
+
+						Writer.BeginObject("Key");
+						{
+							Writer << "Bucket" << m_Bucket;
+							Writer << "Hash" << ValueKey;
+						}
+						Writer.EndObject();	 // Key
+
+						CompressedBuffer Payload = CompressBlob(CreateRandomBlob(ValueSize));
+						Writer.AddBinaryAttachment("RawHash", Payload.DecodeRawHash());
+						Package.AddAttachment(CbAttachment(Payload, Payload.DecodeRawHash()));
+					}
+					Writer.EndObject();
+				}
+				Writer.EndArray();	// Requests
+			}
+			Writer.EndObject();	 // Params
+
+			Package.SetObject(Writer.Save());
+
+			return Package;
+		});
 
 	auto GeneratePutCacheRecordRequest([this, &KeyDistribution, &Generator](std::span<std::uint64_t> BatchSizes, uint64_t RequestIndex) {
-		cacherequests::PutCacheRecordsRequest Request({.AcceptMagic = kCbPkgMagic, .Namespace = m_Namespace});
-		uint64_t							  KeyBase		  = KeyDistribution(Generator);
-		std::string							  RecordKeyString = fmt::format("{}-{}-{}", RequestIndex, KeyBase, BatchSizes.size());
-		IoHash								  RecordKey		  = IoHash::HashBuffer(RecordKeyString.c_str(), RecordKeyString.length());
+		CbPackage Package;
+
+		CbObjectWriter Writer;
+		Writer << "Method"
+			   << "PutCacheRecords";
+		Writer << "Accept" << kCbPkgMagic;
 
-		Request.Requests.emplace_back(cacherequests::PutCacheRecordRequest{.Key = {.Bucket = m_Bucket, .Hash = RecordKey}});
-		for (std::uint64_t ValueSize : BatchSizes)
+		Writer.BeginObject("Params");
 		{
-			Request.Requests.back().Values.push_back({.Id = Oid::NewOid(), .Body = CompressBlob(CreateRandomBlob(ValueSize))});
+			Writer << "DefaultPolicy" << WriteToString<128>(CachePolicy::Default);
+			Writer << "Namespace" << m_Namespace;
+
+			Writer.BeginArray("Requests");
+			{
+				Writer.BeginObject();
+				{
+					Writer.BeginObject("Record");
+					{
+						uint64_t	KeyBase			= KeyDistribution(Generator);
+						std::string RecordKeyString = fmt::format("{}-{}-{}", RequestIndex, KeyBase, BatchSizes.size());
+						IoHash		RecordKey		= IoHash::HashBuffer(RecordKeyString.c_str(), RecordKeyString.length());
+
+						Writer.BeginObject("Key");
+						{
+							Writer << "Bucket" << m_Bucket;
+							Writer << "Hash" << RecordKey;
+						}
+						Writer.EndObject();	 // Key
+
+						Writer.BeginArray("Values");
+						for (std::uint64_t ValueSize : BatchSizes)
+						{
+							Writer.BeginObject();
+							{
+								Writer.AddObjectId("Id", Oid::NewOid());
+
+								CompressedBuffer Payload = CompressBlob(CreateRandomBlob(ValueSize));
+								Writer.AddBinaryAttachment("RawHash", Payload.DecodeRawHash());
+								Package.AddAttachment(CbAttachment(Payload, Payload.DecodeRawHash()));
+								Writer.AddInteger("RawSize", Payload.DecodeRawSize());
+							}
+							Writer.EndObject();
+						}
+						Writer.EndArray();	// Values
+					}
+					Writer.EndObject();	 // Record
+				}
+				Writer.EndObject();
+			}
+			Writer.EndArray();	// Requests
 		}
-		return Request;
+		Writer.EndObject();	 // Params
+
+		Package.SetObject(Writer.Save());
+
+		return Package;
 	});
 
 	WorkerThreadPool WorkerPool(gsl::narrow<int>(Max((std::thread::hardware_concurrency() / 2u), 2u)));
@@ -480,13 +558,11 @@ CacheGenerateCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** a
 				CbPackage Package;
 				if (m_MaxAttachmentCount > 0 && SizeCount > 0)
 				{
-					auto Request = GeneratePutCacheRecordRequest(BatchSizes, RequestIndex);
-					ZEN_ASSERT(Request.Format(Package));
+					Package = GeneratePutCacheRecordRequest(BatchSizes, RequestIndex);
 				}
 				else
 				{
-					auto Request = GeneratePutCacheValueRequest(BatchSizes, RequestIndex);
-					ZEN_ASSERT(Request.Format(Package));
+					Package = GeneratePutCacheValueRequest(BatchSizes, RequestIndex);
 				}
 
 				if (HttpClient::Response Response = Http.Post("/z$/$rpc", Package, HttpClient::Accept(ZenContentType::kCbPackage));
diff --git a/src/zenserver-test/cache-tests.cpp b/src/zenserver-test/cache-tests.cpp
index da0ef6b1d..2a040936c 100644
--- a/src/zenserver-test/cache-tests.cpp
+++ b/src/zenserver-test/cache-tests.cpp
@@ -10,14 +10,15 @@
 #	include <zencore/compress.h>
 #	include <zencore/fmtutils.h>
 #	include <zenhttp/packageformat.h>
-#	include <zenutil/cache/cachepolicy.h>
-#	include <zenutil/cache/cacherequests.h>
+#	include <zenstore/cache/cachepolicy.h>
 #	include <zencore/filesystem.h>
 #	include <zencore/stream.h>
 #	include <zencore/string.h>
 #	include <zenutil/zenserverprocess.h>
 #	include <zenhttp/httpclient.h>
 
+#	include "cacherequests.h"
+
 #	include <random>
 
 namespace zen::tests {
diff --git a/src/zenutil/cache/cacherequests.cpp b/src/zenserver-test/cacherequests.cpp
index b8169182d..46339aebb 100644
--- a/src/zenutil/cache/cacherequests.cpp
+++ b/src/zenserver-test/cacherequests.cpp
@@ -1,6 +1,6 @@
 // Copyright Epic Games, Inc. All Rights Reserved.
 
-#include <zenutil/cache/cacherequests.h>
+#include "cacherequests.h"
 
 #include <zencore/compactbinary.h>
 #include <zencore/compactbinarybuilder.h>
@@ -8,6 +8,7 @@
 #include <zencore/fmtutils.h>
 #include <zencore/logging.h>
 #include <zencore/zencore.h>
+#include <zenstore/cache/cache.h>
 
 #include <string>
 #include <string_view>
@@ -17,124 +18,13 @@
 #	include <zencore/testing.h>
 #endif
 
-namespace zen {
-
-namespace cacherequests {
-
-	namespace {
-		constinit AsciiSet ValidNamespaceNameCharactersSet{"abcdefghijklmnopqrstuvwxyz0123456789-_.ABCDEFGHIJKLMNOPQRSTUVWXYZ"};
-		constinit AsciiSet ValidBucketNameCharactersSet{"abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"};
-	}  // namespace
-
-	std::optional<std::string> GetValidNamespaceName(std::string_view Name)
-	{
-		if (Name.empty())
-		{
-			ZEN_WARN("Namespace is invalid, empty namespace is not allowed");
-			return {};
-		}
-
-		if (Name.length() > 64)
-		{
-			ZEN_WARN("Namespace '{}' is invalid, length exceeds 64 characters", Name);
-			return {};
-		}
-
-		if (!AsciiSet::HasOnly(Name, ValidNamespaceNameCharactersSet))
-		{
-			ZEN_WARN("Namespace '{}' is invalid, invalid characters detected", Name);
-			return {};
-		}
-
-		return ToLower(Name);
-	}
-
-	std::optional<std::string> GetValidBucketName(std::string_view Name)
-	{
-		if (Name.empty())
-		{
-			ZEN_WARN("Bucket name is invalid, empty bucket name is not allowed");
-			return {};
-		}
-
-		if (!AsciiSet::HasOnly(Name, ValidBucketNameCharactersSet))
-		{
-			ZEN_WARN("Bucket name '{}' is invalid, invalid characters detected", Name);
-			return {};
-		}
-
-		return ToLower(Name);
-	}
-
-	std::optional<IoHash> GetValidIoHash(std::string_view Hash)
-	{
-		if (Hash.length() != IoHash::StringLength)
-		{
-			return {};
-		}
-
-		IoHash KeyHash;
-		if (!ParseHexBytes(Hash.data(), Hash.size(), KeyHash.Hash))
-		{
-			return {};
-		}
-		return KeyHash;
-	}
+namespace zen { namespace cacherequests {
 
 	std::optional<CacheRecordPolicy> Convert(const OptionalCacheRecordPolicy& Policy)
 	{
 		return Policy.IsValid() ? Policy.Get() : std::optional<CacheRecordPolicy>{};
 	};
 
-	std::optional<std::string> GetRequestNamespace(const CbObjectView& Params)
-	{
-		CbFieldView NamespaceField = Params["Namespace"];
-		if (!NamespaceField)
-		{
-			return std::string("!default!");  // ZenCacheStore::DefaultNamespace);
-		}
-
-		if (NamespaceField.HasError())
-		{
-			return {};
-		}
-		if (!NamespaceField.IsString())
-		{
-			return {};
-		}
-		return GetValidNamespaceName(NamespaceField.AsString());
-	}
-
-	bool GetRequestCacheKey(const CbObjectView& KeyView, CacheKey& Key)
-	{
-		CbFieldView BucketField = KeyView["Bucket"];
-		if (BucketField.HasError())
-		{
-			return false;
-		}
-		if (!BucketField.IsString())
-		{
-			return false;
-		}
-		std::optional<std::string> Bucket = GetValidBucketName(BucketField.AsString());
-		if (!Bucket.has_value())
-		{
-			return false;
-		}
-		CbFieldView HashField = KeyView["Hash"];
-		if (HashField.HasError())
-		{
-			return false;
-		}
-		if (!HashField.IsHash())
-		{
-			return false;
-		}
-		Key.Bucket = *Bucket;
-		Key.Hash   = HashField.AsHash();
-		return true;
-	}
-
 	void WriteCacheRequestKey(CbObjectWriter& Writer, const CacheKey& Value)
 	{
 		Writer.BeginObject("Key");
@@ -179,7 +69,7 @@ namespace cacherequests {
 		AcceptMagic = BatchObject["AcceptType"].AsUInt32(0);
 
 		CbObjectView			   Params			= BatchObject["Params"].AsObjectView();
-		std::optional<std::string> RequestNamespace = GetRequestNamespace(Params);
+		std::optional<std::string> RequestNamespace = GetCacheRequestNamespace(Params);
 		if (!RequestNamespace)
 		{
 			return false;
@@ -197,7 +87,7 @@ namespace cacherequests {
 
 			PutCacheRecordRequest& Request = Requests[RequestIndex++];
 
-			if (!GetRequestCacheKey(KeyView, Request.Key))
+			if (!GetCacheRequestCacheKey(KeyView, Request.Key))
 			{
 				return false;
 			}
@@ -357,7 +247,7 @@ namespace cacherequests {
 		ProcessPid	  = RpcRequest["Pid"].AsInt32(0);
 
 		CbObjectView			   Params			= RpcRequest["Params"].AsObjectView();
-		std::optional<std::string> RequestNamespace = GetRequestNamespace(Params);
+		std::optional<std::string> RequestNamespace = GetCacheRequestNamespace(Params);
 		if (!RequestNamespace)
 		{
 			return false;
@@ -375,7 +265,7 @@ namespace cacherequests {
 
 			GetCacheRecordRequest& Request = Requests.emplace_back();
 
-			if (!GetRequestCacheKey(KeyObject, Request.Key))
+			if (!GetCacheRequestCacheKey(KeyObject, Request.Key))
 			{
 				return false;
 			}
@@ -483,7 +373,7 @@ namespace cacherequests {
 			GetCacheRecordResult& Request	   = Results[ResultIndex].value();
 			CbObjectView		  RecordObject = RecordView.AsObjectView();
 			CbObjectView		  KeyObject	   = RecordObject["Key"].AsObjectView();
-			if (!GetRequestCacheKey(KeyObject, Request.Key))
+			if (!GetCacheRequestCacheKey(KeyObject, Request.Key))
 			{
 				return false;
 			}
@@ -560,7 +450,7 @@ namespace cacherequests {
 		AcceptMagic = BatchObject["AcceptType"].AsUInt32(0);
 
 		CbObjectView			   Params			= BatchObject["Params"].AsObjectView();
-		std::optional<std::string> RequestNamespace = cacherequests::GetRequestNamespace(Params);
+		std::optional<std::string> RequestNamespace = GetCacheRequestNamespace(Params);
 		if (!RequestNamespace)
 		{
 			return false;
@@ -578,7 +468,7 @@ namespace cacherequests {
 
 			PutCacheValueRequest& Request = Requests.emplace_back();
 
-			if (!GetRequestCacheKey(KeyObject, Request.Key))
+			if (!GetCacheRequestCacheKey(KeyObject, Request.Key))
 			{
 				return false;
 			}
@@ -691,7 +581,7 @@ namespace cacherequests {
 		ProcessPid	  = BatchObject["Pid"].AsInt32(0);
 
 		CbObjectView			   Params			= BatchObject["Params"].AsObjectView();
-		std::optional<std::string> RequestNamespace = cacherequests::GetRequestNamespace(Params);
+		std::optional<std::string> RequestNamespace = GetCacheRequestNamespace(Params);
 		if (!RequestNamespace)
 		{
 			return false;
@@ -709,7 +599,7 @@ namespace cacherequests {
 
 			GetCacheValueRequest& Request = Requests.emplace_back();
 
-			if (!GetRequestCacheKey(KeyObject, Request.Key))
+			if (!GetCacheRequestCacheKey(KeyObject, Request.Key))
 			{
 				return false;
 			}
@@ -865,7 +755,7 @@ namespace cacherequests {
 		ProcessPid	  = BatchObject["Pid"].AsInt32(0);
 
 		CbObjectView			   Params			= BatchObject["Params"].AsObjectView();
-		std::optional<std::string> RequestNamespace = cacherequests::GetRequestNamespace(Params);
+		std::optional<std::string> RequestNamespace = GetCacheRequestNamespace(Params);
 		if (!RequestNamespace)
 		{
 			return false;
@@ -883,7 +773,7 @@ namespace cacherequests {
 
 			GetCacheChunkRequest& Request = Requests.emplace_back();
 
-			if (!GetRequestCacheKey(KeyObject, Request.Key))
+			if (!GetCacheRequestCacheKey(KeyObject, Request.Key))
 			{
 				return false;
 			}
@@ -945,122 +835,11 @@ namespace cacherequests {
 		return true;
 	}
 
-	bool HttpRequestParseRelativeUri(std::string_view Key, std::string_view DefaultNamespace, HttpRequestData& Data)
-	{
-		std::vector<std::string_view> Tokens;
-		uint32_t					  TokenCount = ForEachStrTok(Key, '/', [&](const std::string_view& Token) {
-			 Tokens.push_back(Token);
-			 return true;
-		 });
-
-		switch (TokenCount)
-		{
-			case 0:
-				return true;
-			case 1:
-				Data.Namespace = GetValidNamespaceName(Tokens[0]);
-				return Data.Namespace.has_value();
-			case 2:
-				{
-					std::optional<IoHash> PossibleHashKey = GetValidIoHash(Tokens[1]);
-					if (PossibleHashKey.has_value())
-					{
-						// Legacy bucket/key request
-						Data.Bucket = GetValidBucketName(Tokens[0]);
-						if (!Data.Bucket.has_value())
-						{
-							return false;
-						}
-						Data.HashKey   = PossibleHashKey;
-						Data.Namespace = DefaultNamespace;
-						return true;
-					}
-					Data.Namespace = GetValidNamespaceName(Tokens[0]);
-					if (!Data.Namespace.has_value())
-					{
-						return false;
-					}
-					Data.Bucket = GetValidBucketName(Tokens[1]);
-					if (!Data.Bucket.has_value())
-					{
-						return false;
-					}
-					return true;
-				}
-			case 3:
-				{
-					std::optional<IoHash> PossibleHashKey = GetValidIoHash(Tokens[1]);
-					if (PossibleHashKey.has_value())
-					{
-						// Legacy bucket/key/valueid request
-						Data.Bucket = GetValidBucketName(Tokens[0]);
-						if (!Data.Bucket.has_value())
-						{
-							return false;
-						}
-						Data.HashKey		= PossibleHashKey;
-						Data.ValueContentId = GetValidIoHash(Tokens[2]);
-						if (!Data.ValueContentId.has_value())
-						{
-							return false;
-						}
-						Data.Namespace = DefaultNamespace;
-						return true;
-					}
-					Data.Namespace = GetValidNamespaceName(Tokens[0]);
-					if (!Data.Namespace.has_value())
-					{
-						return false;
-					}
-					Data.Bucket = GetValidBucketName(Tokens[1]);
-					if (!Data.Bucket.has_value())
-					{
-						return false;
-					}
-					Data.HashKey = GetValidIoHash(Tokens[2]);
-					if (!Data.HashKey)
-					{
-						return false;
-					}
-					return true;
-				}
-			case 4:
-				{
-					Data.Namespace = GetValidNamespaceName(Tokens[0]);
-					if (!Data.Namespace.has_value())
-					{
-						return false;
-					}
-
-					Data.Bucket = GetValidBucketName(Tokens[1]);
-					if (!Data.Bucket.has_value())
-					{
-						return false;
-					}
-
-					Data.HashKey = GetValidIoHash(Tokens[2]);
-					if (!Data.HashKey.has_value())
-					{
-						return false;
-					}
-
-					Data.ValueContentId = GetValidIoHash(Tokens[3]);
-					if (!Data.ValueContentId.has_value())
-					{
-						return false;
-					}
-					return true;
-				}
-			default:
-				return false;
-		}
-	}
-
 	//	bool CacheRecord::Parse(CbObjectView& Reader)
 	//	{
 	//		CbObjectView KeyView = Reader["Key"].AsObjectView();
 	//
-	//		if (!GetRequestCacheKey(KeyView, Key))
+	//		if (!GetCacheRequestCacheKey(KeyView, Key))
 	//		{
 	//			return false;
 	//		}
@@ -1582,80 +1361,80 @@ namespace cacherequests {
 	{
 		using namespace std::literals;
 
-		HttpRequestData RootRequest;
-		CHECK(HttpRequestParseRelativeUri("", "!default!", RootRequest));
+		HttpCacheRequestData RootRequest;
+		CHECK(HttpCacheRequestParseRelativeUri("", "!default!", RootRequest));
 		CHECK(!RootRequest.Namespace.has_value());
 		CHECK(!RootRequest.Bucket.has_value());
 		CHECK(!RootRequest.HashKey.has_value());
 		CHECK(!RootRequest.ValueContentId.has_value());
 
 		RootRequest = {};
-		CHECK(HttpRequestParseRelativeUri("/", "!default!", RootRequest));
+		CHECK(HttpCacheRequestParseRelativeUri("/", "!default!", RootRequest));
 		CHECK(!RootRequest.Namespace.has_value());
 		CHECK(!RootRequest.Bucket.has_value());
 		CHECK(!RootRequest.HashKey.has_value());
 		CHECK(!RootRequest.ValueContentId.has_value());
 
-		HttpRequestData LegacyBucketRequestBecomesNamespaceRequest;
-		CHECK(HttpRequestParseRelativeUri("test", "!default!", LegacyBucketRequestBecomesNamespaceRequest));
+		HttpCacheRequestData LegacyBucketRequestBecomesNamespaceRequest;
+		CHECK(HttpCacheRequestParseRelativeUri("test", "!default!", LegacyBucketRequestBecomesNamespaceRequest));
 		CHECK(LegacyBucketRequestBecomesNamespaceRequest.Namespace == "test"sv);
 		CHECK(!LegacyBucketRequestBecomesNamespaceRequest.Bucket.has_value());
 		CHECK(!LegacyBucketRequestBecomesNamespaceRequest.HashKey.has_value());
 		CHECK(!LegacyBucketRequestBecomesNamespaceRequest.ValueContentId.has_value());
 
-		HttpRequestData LegacyHashKeyRequest;
-		CHECK(HttpRequestParseRelativeUri("test/0123456789abcdef12340123456789abcdef1234", "!default!", LegacyHashKeyRequest));
+		HttpCacheRequestData LegacyHashKeyRequest;
+		CHECK(HttpCacheRequestParseRelativeUri("test/0123456789abcdef12340123456789abcdef1234", "!default!", LegacyHashKeyRequest));
 		CHECK(LegacyHashKeyRequest.Namespace == "!default!");
 		CHECK(LegacyHashKeyRequest.Bucket == "test"sv);
 		CHECK(LegacyHashKeyRequest.HashKey == IoHash::FromHexString("0123456789abcdef12340123456789abcdef1234"sv));
 		CHECK(!LegacyHashKeyRequest.ValueContentId.has_value());
 
-		HttpRequestData LegacyValueContentIdRequest;
-		CHECK(HttpRequestParseRelativeUri("test/0123456789abcdef12340123456789abcdef1234/56789abcdef12345678956789abcdef123456789",
-										  "!default!",
-										  LegacyValueContentIdRequest));
+		HttpCacheRequestData LegacyValueContentIdRequest;
+		CHECK(HttpCacheRequestParseRelativeUri("test/0123456789abcdef12340123456789abcdef1234/56789abcdef12345678956789abcdef123456789",
+											   "!default!",
+											   LegacyValueContentIdRequest));
 		CHECK(LegacyValueContentIdRequest.Namespace == "!default!");
 		CHECK(LegacyValueContentIdRequest.Bucket == "test"sv);
 		CHECK(LegacyValueContentIdRequest.HashKey == IoHash::FromHexString("0123456789abcdef12340123456789abcdef1234"sv));
 		CHECK(LegacyValueContentIdRequest.ValueContentId == IoHash::FromHexString("56789abcdef12345678956789abcdef123456789"sv));
 
-		HttpRequestData V2DefaultNamespaceRequest;
-		CHECK(HttpRequestParseRelativeUri("ue4.ddc", "!default!", V2DefaultNamespaceRequest));
+		HttpCacheRequestData V2DefaultNamespaceRequest;
+		CHECK(HttpCacheRequestParseRelativeUri("ue4.ddc", "!default!", V2DefaultNamespaceRequest));
 		CHECK(V2DefaultNamespaceRequest.Namespace == "ue4.ddc");
 		CHECK(!V2DefaultNamespaceRequest.Bucket.has_value());
 		CHECK(!V2DefaultNamespaceRequest.HashKey.has_value());
 		CHECK(!V2DefaultNamespaceRequest.ValueContentId.has_value());
 
-		HttpRequestData V2NamespaceRequest;
-		CHECK(HttpRequestParseRelativeUri("nicenamespace", "!default!", V2NamespaceRequest));
+		HttpCacheRequestData V2NamespaceRequest;
+		CHECK(HttpCacheRequestParseRelativeUri("nicenamespace", "!default!", V2NamespaceRequest));
 		CHECK(V2NamespaceRequest.Namespace == "nicenamespace"sv);
 		CHECK(!V2NamespaceRequest.Bucket.has_value());
 		CHECK(!V2NamespaceRequest.HashKey.has_value());
 		CHECK(!V2NamespaceRequest.ValueContentId.has_value());
 
-		HttpRequestData V2BucketRequestWithDefaultNamespace;
-		CHECK(HttpRequestParseRelativeUri("ue4.ddc/test", "!default!", V2BucketRequestWithDefaultNamespace));
+		HttpCacheRequestData V2BucketRequestWithDefaultNamespace;
+		CHECK(HttpCacheRequestParseRelativeUri("ue4.ddc/test", "!default!", V2BucketRequestWithDefaultNamespace));
 		CHECK(V2BucketRequestWithDefaultNamespace.Namespace == "ue4.ddc");
 		CHECK(V2BucketRequestWithDefaultNamespace.Bucket == "test"sv);
 		CHECK(!V2BucketRequestWithDefaultNamespace.HashKey.has_value());
 		CHECK(!V2BucketRequestWithDefaultNamespace.ValueContentId.has_value());
 
-		HttpRequestData V2BucketRequestWithNamespace;
-		CHECK(HttpRequestParseRelativeUri("nicenamespace/test", "!default!", V2BucketRequestWithNamespace));
+		HttpCacheRequestData V2BucketRequestWithNamespace;
+		CHECK(HttpCacheRequestParseRelativeUri("nicenamespace/test", "!default!", V2BucketRequestWithNamespace));
 		CHECK(V2BucketRequestWithNamespace.Namespace == "nicenamespace"sv);
 		CHECK(V2BucketRequestWithNamespace.Bucket == "test"sv);
 		CHECK(!V2BucketRequestWithNamespace.HashKey.has_value());
 		CHECK(!V2BucketRequestWithNamespace.ValueContentId.has_value());
 
-		HttpRequestData V2HashKeyRequest;
-		CHECK(HttpRequestParseRelativeUri("test/0123456789abcdef12340123456789abcdef1234", "!default!", V2HashKeyRequest));
+		HttpCacheRequestData V2HashKeyRequest;
+		CHECK(HttpCacheRequestParseRelativeUri("test/0123456789abcdef12340123456789abcdef1234", "!default!", V2HashKeyRequest));
 		CHECK(V2HashKeyRequest.Namespace == "!default!");
 		CHECK(V2HashKeyRequest.Bucket == "test");
 		CHECK(V2HashKeyRequest.HashKey == IoHash::FromHexString("0123456789abcdef12340123456789abcdef1234"sv));
 		CHECK(!V2HashKeyRequest.ValueContentId.has_value());
 
-		HttpRequestData V2ValueContentIdRequest;
-		CHECK(HttpRequestParseRelativeUri(
+		HttpCacheRequestData V2ValueContentIdRequest;
+		CHECK(HttpCacheRequestParseRelativeUri(
 			"nicenamespace/test/0123456789abcdef12340123456789abcdef1234/56789abcdef12345678956789abcdef123456789",
 			"!default!",
 			V2ValueContentIdRequest));
@@ -1664,26 +1443,20 @@ namespace cacherequests {
 		CHECK(V2ValueContentIdRequest.HashKey == IoHash::FromHexString("0123456789abcdef12340123456789abcdef1234"sv));
 		CHECK(V2ValueContentIdRequest.ValueContentId == IoHash::FromHexString("56789abcdef12345678956789abcdef123456789"sv));
 
-		HttpRequestData Invalid;
-		CHECK(!HttpRequestParseRelativeUri("bad\2_namespace", "!default!", Invalid));
-		CHECK(!HttpRequestParseRelativeUri("nice/\2\1bucket", "!default!", Invalid));
-		CHECK(!HttpRequestParseRelativeUri("namespace/bucket/0123456789a", "!default!", Invalid));
-		CHECK(!HttpRequestParseRelativeUri("namespace/bucket/0123456789abcdef12340123456789abcdef1234/56789abcdef1234",
-										   "!default!",
-										   Invalid));
-		CHECK(!HttpRequestParseRelativeUri("namespace/bucket/pppppppp89abcdef12340123456789abcdef1234", "!default!", Invalid));
-		CHECK(!HttpRequestParseRelativeUri("namespace/bucket/0123456789abcdef12340123456789abcdef1234/56789abcd", "!default!", Invalid));
-		CHECK(!HttpRequestParseRelativeUri(
+		HttpCacheRequestData Invalid;
+		CHECK(!HttpCacheRequestParseRelativeUri("bad\2_namespace", "!default!", Invalid));
+		CHECK(!HttpCacheRequestParseRelativeUri("nice/\2\1bucket", "!default!", Invalid));
+		CHECK(!HttpCacheRequestParseRelativeUri("namespace/bucket/0123456789a", "!default!", Invalid));
+		CHECK(!HttpCacheRequestParseRelativeUri("namespace/bucket/0123456789abcdef12340123456789abcdef1234/56789abcdef1234",
+												"!default!",
+												Invalid));
+		CHECK(!HttpCacheRequestParseRelativeUri("namespace/bucket/pppppppp89abcdef12340123456789abcdef1234", "!default!", Invalid));
+		CHECK(
+			!HttpCacheRequestParseRelativeUri("namespace/bucket/0123456789abcdef12340123456789abcdef1234/56789abcd", "!default!", Invalid));
+		CHECK(!HttpCacheRequestParseRelativeUri(
 			"namespace/bucket/0123456789abcdef12340123456789abcdef1234/ppppppppdef12345678956789abcdef123456789",
 			"!default!",
 			Invalid));
 	}
 #endif
-}  // namespace cacherequests
-
-void
-cacherequests_forcelink()
-{
-}
-
-}  // namespace zen
+}}	// namespace zen::cacherequests
diff --git a/src/zenutil/include/zenutil/cache/cacherequests.h b/src/zenserver-test/cacherequests.h
index 2842e29f0..5b7a53390 100644
--- a/src/zenutil/include/zenutil/cache/cacherequests.h
+++ b/src/zenserver-test/cacherequests.h
@@ -4,8 +4,8 @@
 
 #include <zencore/compress.h>
 
-#include "cachekey.h"
-#include "cachepolicy.h"
+#include <zenstore/cache/cachekey.h>
+#include <zenstore/cache/cachepolicy.h>
 
 #include <functional>
 
@@ -243,26 +243,6 @@ namespace cacherequests {
 
 	//////////////////////////////////////////////////////////////////////////
 
-	std::optional<std::string> GetValidNamespaceName(std::string_view Name);
-	std::optional<std::string> GetValidBucketName(std::string_view Name);
-	std::optional<IoHash>	   GetValidIoHash(std::string_view Hash);
-
-	struct HttpRequestData
-	{
-		std::optional<std::string> Namespace;
-		std::optional<std::string> Bucket;
-		std::optional<IoHash>	   HashKey;
-		std::optional<IoHash>	   ValueContentId;
-	};
-
-	bool HttpRequestParseRelativeUri(std::string_view Key, std::string_view DefaultNamespace, HttpRequestData& Data);
-
-	// Temporarily public
-	std::optional<std::string> GetRequestNamespace(const CbObjectView& Params);
-	bool					   GetRequestCacheKey(const CbObjectView& KeyView, CacheKey& Key);
-
-	//////////////////////////////////////////////////////////////////////////
-
 	//	struct CacheRecordValue
 	//	{
 	//		Oid		 Id		 = Oid::Zero;
@@ -281,6 +261,4 @@ namespace cacherequests {
 
 }  // namespace cacherequests
 
-void cacherequests_forcelink();	 // internal
-
 }  // namespace zen
diff --git a/src/zenserver-test/xmake.lua b/src/zenserver-test/xmake.lua
index 49891b27d..7832e1f72 100644
--- a/src/zenserver-test/xmake.lua
+++ b/src/zenserver-test/xmake.lua
@@ -6,7 +6,7 @@ target("zenserver-test")
     add_headerfiles("**.h")
     add_files("*.cpp")
     add_files("zenserver-test.cpp", {unity_ignored  = true })
-    add_deps("zencore", "zenremotestore", "zenutil", "zenhttp")
+    add_deps("zencore", "zenremotestore", "zenhttp")
     add_deps("zenserver", {inherit=false})
     add_packages("vcpkg::cpr", "vcpkg::http-parser", "vcpkg::mimalloc")
 
diff --git a/src/zenserver/cache/httpstructuredcache.cpp b/src/zenserver/cache/httpstructuredcache.cpp
index 884684eed..ab3f1b56c 100644
--- a/src/zenserver/cache/httpstructuredcache.cpp
+++ b/src/zenserver/cache/httpstructuredcache.cpp
@@ -22,10 +22,9 @@
 #include <zenhttp/httpstats.h>
 #include <zenhttp/packageformat.h>
 #include <zenremotestore/jupiter/jupiterclient.h>
+#include <zenstore/cache/cache.h>
 #include <zenstore/cache/structuredcachestore.h>
 #include <zenstore/gc.h>
-#include <zenutil/cache/cache.h>
-#include <zenutil/cache/cacherequests.h>
 #include <zenutil/cache/rpcrecording.h>
 #include <zenutil/workerpools.h>
 
@@ -71,15 +70,6 @@ namespace {
 	static constinit std::string_view HttpZCacheUtilStopRecording	= "exec$/stop-recording"sv;
 	static constinit std::string_view HttpZCacheUtilReplayRecording = "exec$/replay-recording"sv;
 	static constinit std::string_view HttpZCacheDetailsPrefix		= "details$"sv;
-
-	struct HttpRequestData
-	{
-		std::optional<std::string> Namespace;
-		std::optional<std::string> Bucket;
-		std::optional<IoHash>	   HashKey;
-		std::optional<IoHash>	   ValueContentId;
-	};
-
 }  // namespace
 
 //////////////////////////////////////////////////////////////////////////
@@ -459,8 +449,8 @@ HttpStructuredCacheService::HandleRequest(HttpServerRequest& Request)
 		return;
 	}
 
-	cacherequests::HttpRequestData RequestData;
-	if (!cacherequests::HttpRequestParseRelativeUri(Key, ZenCacheStore::DefaultNamespace, RequestData))
+	HttpCacheRequestData RequestData;
+	if (!HttpCacheRequestParseRelativeUri(Key, ZenCacheStore::DefaultNamespace, RequestData))
 	{
 		m_CacheStats.BadRequestCount++;
 		return Request.WriteResponse(HttpResponseCode::BadRequest);	 // invalid URL
diff --git a/src/zenserver/cache/httpstructuredcache.h b/src/zenserver/cache/httpstructuredcache.h
index cb822f117..a157148c9 100644
--- a/src/zenserver/cache/httpstructuredcache.h
+++ b/src/zenserver/cache/httpstructuredcache.h
@@ -6,8 +6,8 @@
 #include <zenhttp/httpserver.h>
 #include <zenhttp/httpstats.h>
 #include <zenhttp/httpstatus.h>
+#include <zenstore/cache/cache.h>
 #include <zenstore/cache/cacherpc.h>
-#include <zenutil/cache/cache.h>
 #include <zenutil/openprocesscache.h>
 
 #include <memory>
diff --git a/src/zenserver/upstream/upstreamcache.h b/src/zenserver/upstream/upstreamcache.h
index 26e5decac..d5d61c8d9 100644
--- a/src/zenserver/upstream/upstreamcache.h
+++ b/src/zenserver/upstream/upstreamcache.h
@@ -8,8 +8,8 @@
 #include <zencore/iohash.h>
 #include <zencore/stats.h>
 #include <zencore/zencore.h>
+#include <zenstore/cache/cache.h>
 #include <zenstore/cache/upstreamcacheclient.h>
-#include <zenutil/cache/cache.h>
 
 #include <atomic>
 #include <chrono>
diff --git a/src/zenstore/cache/cache.cpp b/src/zenstore/cache/cache.cpp
new file mode 100644
index 000000000..0436bfd7b
--- /dev/null
+++ b/src/zenstore/cache/cache.cpp
@@ -0,0 +1,235 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include <zenstore/cache/cache.h>
+
+#include <zencore/logging.h>
+
+namespace zen {
+
+namespace {
+	constinit AsciiSet ValidNamespaceNameCharactersSet{"abcdefghijklmnopqrstuvwxyz0123456789-_.ABCDEFGHIJKLMNOPQRSTUVWXYZ"};
+	constinit AsciiSet ValidBucketNameCharactersSet{"abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"};
+}  // namespace
+
+std::optional<std::string>
+GetValidNamespaceName(std::string_view Name)
+{
+	if (Name.empty())
+	{
+		ZEN_WARN("Namespace is invalid, empty namespace is not allowed");
+		return {};
+	}
+
+	if (Name.length() > 64)
+	{
+		ZEN_WARN("Namespace '{}' is invalid, length exceeds 64 characters", Name);
+		return {};
+	}
+
+	if (!AsciiSet::HasOnly(Name, ValidNamespaceNameCharactersSet))
+	{
+		ZEN_WARN("Namespace '{}' is invalid, invalid characters detected", Name);
+		return {};
+	}
+
+	return ToLower(Name);
+}
+
+std::optional<std::string>
+GetValidBucketName(std::string_view Name)
+{
+	if (Name.empty())
+	{
+		ZEN_WARN("Bucket name is invalid, empty bucket name is not allowed");
+		return {};
+	}
+
+	if (!AsciiSet::HasOnly(Name, ValidBucketNameCharactersSet))
+	{
+		ZEN_WARN("Bucket name '{}' is invalid, invalid characters detected", Name);
+		return {};
+	}
+
+	return ToLower(Name);
+}
+
+std::optional<IoHash>
+GetValidIoHash(std::string_view Hash)
+{
+	if (Hash.length() != IoHash::StringLength)
+	{
+		return {};
+	}
+
+	IoHash KeyHash;
+	if (!ParseHexBytes(Hash.data(), Hash.size(), KeyHash.Hash))
+	{
+		return {};
+	}
+	return KeyHash;
+}
+
+bool
+HttpCacheRequestParseRelativeUri(std::string_view Key, std::string_view DefaultNamespace, HttpCacheRequestData& Data)
+{
+	std::vector<std::string_view> Tokens;
+	uint32_t					  TokenCount = ForEachStrTok(Key, '/', [&](const std::string_view& Token) {
+		 Tokens.push_back(Token);
+		 return true;
+	 });
+
+	switch (TokenCount)
+	{
+		case 0:
+			return true;
+		case 1:
+			Data.Namespace = GetValidNamespaceName(Tokens[0]);
+			return Data.Namespace.has_value();
+		case 2:
+			{
+				std::optional<IoHash> PossibleHashKey = GetValidIoHash(Tokens[1]);
+				if (PossibleHashKey.has_value())
+				{
+					// Legacy bucket/key request
+					Data.Bucket = GetValidBucketName(Tokens[0]);
+					if (!Data.Bucket.has_value())
+					{
+						return false;
+					}
+					Data.HashKey   = PossibleHashKey;
+					Data.Namespace = DefaultNamespace;
+					return true;
+				}
+				Data.Namespace = GetValidNamespaceName(Tokens[0]);
+				if (!Data.Namespace.has_value())
+				{
+					return false;
+				}
+				Data.Bucket = GetValidBucketName(Tokens[1]);
+				if (!Data.Bucket.has_value())
+				{
+					return false;
+				}
+				return true;
+			}
+		case 3:
+			{
+				std::optional<IoHash> PossibleHashKey = GetValidIoHash(Tokens[1]);
+				if (PossibleHashKey.has_value())
+				{
+					// Legacy bucket/key/valueid request
+					Data.Bucket = GetValidBucketName(Tokens[0]);
+					if (!Data.Bucket.has_value())
+					{
+						return false;
+					}
+					Data.HashKey		= PossibleHashKey;
+					Data.ValueContentId = GetValidIoHash(Tokens[2]);
+					if (!Data.ValueContentId.has_value())
+					{
+						return false;
+					}
+					Data.Namespace = DefaultNamespace;
+					return true;
+				}
+				Data.Namespace = GetValidNamespaceName(Tokens[0]);
+				if (!Data.Namespace.has_value())
+				{
+					return false;
+				}
+				Data.Bucket = GetValidBucketName(Tokens[1]);
+				if (!Data.Bucket.has_value())
+				{
+					return false;
+				}
+				Data.HashKey = GetValidIoHash(Tokens[2]);
+				if (!Data.HashKey)
+				{
+					return false;
+				}
+				return true;
+			}
+		case 4:
+			{
+				Data.Namespace = GetValidNamespaceName(Tokens[0]);
+				if (!Data.Namespace.has_value())
+				{
+					return false;
+				}
+
+				Data.Bucket = GetValidBucketName(Tokens[1]);
+				if (!Data.Bucket.has_value())
+				{
+					return false;
+				}
+
+				Data.HashKey = GetValidIoHash(Tokens[2]);
+				if (!Data.HashKey.has_value())
+				{
+					return false;
+				}
+
+				Data.ValueContentId = GetValidIoHash(Tokens[3]);
+				if (!Data.ValueContentId.has_value())
+				{
+					return false;
+				}
+				return true;
+			}
+		default:
+			return false;
+	}
+}
+
+std::optional<std::string>
+GetCacheRequestNamespace(const CbObjectView& Params)
+{
+	CbFieldView NamespaceField = Params["Namespace"];
+	if (!NamespaceField)
+	{
+		return std::string("!default!");  // ZenCacheStore::DefaultNamespace);
+	}
+
+	if (NamespaceField.HasError())
+	{
+		return {};
+	}
+	if (!NamespaceField.IsString())
+	{
+		return {};
+	}
+	return GetValidNamespaceName(NamespaceField.AsString());
+}
+
+bool
+GetCacheRequestCacheKey(const CbObjectView& KeyView, CacheKey& Key)
+{
+	CbFieldView BucketField = KeyView["Bucket"];
+	if (BucketField.HasError())
+	{
+		return false;
+	}
+	if (!BucketField.IsString())
+	{
+		return false;
+	}
+	std::optional<std::string> Bucket = GetValidBucketName(BucketField.AsString());
+	if (!Bucket.has_value())
+	{
+		return false;
+	}
+	CbFieldView HashField = KeyView["Hash"];
+	if (HashField.HasError())
+	{
+		return false;
+	}
+	if (!HashField.IsHash())
+	{
+		return false;
+	}
+	Key.Bucket = *Bucket;
+	Key.Hash   = HashField.AsHash();
+	return true;
+}
+
+}  // namespace zen
diff --git a/src/zenutil/cache/cachekey.cpp b/src/zenstore/cache/cachekey.cpp
index 545b47f11..e5a5d0334 100644
--- a/src/zenutil/cache/cachekey.cpp
+++ b/src/zenstore/cache/cachekey.cpp
@@ -1,6 +1,6 @@
 // Copyright Epic Games, Inc. All Rights Reserved.
 
-#include <zenutil/cache/cachekey.h>
+#include <zenstore/cache/cachekey.h>
 
 namespace zen {
 
diff --git a/src/zenutil/cache/cachepolicy.cpp b/src/zenstore/cache/cachepolicy.cpp
index 0bdfd87ce..ca8a95ca1 100644
--- a/src/zenutil/cache/cachepolicy.cpp
+++ b/src/zenstore/cache/cachepolicy.cpp
@@ -1,6 +1,6 @@
 // Copyright Epic Games, Inc. All Rights Reserved.
 
-#include <zenutil/cache/cachepolicy.h>
+#include <zenstore/cache/cachepolicy.h>
 
 #include <zencore/compactbinary.h>
 #include <zencore/compactbinarybuilder.h>
diff --git a/src/zenstore/cache/cacherpc.cpp b/src/zenstore/cache/cacherpc.cpp
index fdee017e0..4c44f43ca 100644
--- a/src/zenstore/cache/cacherpc.cpp
+++ b/src/zenstore/cache/cacherpc.cpp
@@ -15,7 +15,6 @@
 #include <zenstore/cache/structuredcachestore.h>
 #include <zenstore/cache/upstreamcacheclient.h>
 #include <zenstore/cidstore.h>
-#include <zenutil/cache/cacherequests.h>
 #include <zenutil/workerpools.h>
 
 #include <zencore/memory/llm.h>
@@ -61,7 +60,7 @@ GetRpcRequestNamespace(const CbObjectView Params)
 	{
 		return {};
 	}
-	return cacherequests::GetValidNamespaceName(NamespaceField.AsString());
+	return GetValidNamespaceName(NamespaceField.AsString());
 }
 
 bool
@@ -76,7 +75,7 @@ GetRpcRequestCacheKey(const CbObjectView& KeyView, CacheKey& Key)
 	{
 		return false;
 	}
-	std::optional<std::string> Bucket = cacherequests::GetValidBucketName(BucketField.AsString());
+	std::optional<std::string> Bucket = GetValidBucketName(BucketField.AsString());
 	if (!Bucket.has_value())
 	{
 		return false;
diff --git a/src/zenstore/cache/structuredcachestore.cpp b/src/zenstore/cache/structuredcachestore.cpp
index b58f70ea7..fd54e6765 100644
--- a/src/zenstore/cache/structuredcachestore.cpp
+++ b/src/zenstore/cache/structuredcachestore.cpp
@@ -15,9 +15,8 @@
 #include <zencore/thread.h>
 #include <zencore/timer.h>
 #include <zencore/trace.h>
-#include <zencore/workthreadpool.h>
+#include <zenstore/cache/cache.h>
 #include <zenstore/scrubcontext.h>
-#include <zenutil/cache/cache.h>
 
 #include <future>
 #include <limits>
diff --git a/src/zenstore/include/zenstore/cache/cache.h b/src/zenstore/include/zenstore/cache/cache.h
new file mode 100644
index 000000000..4e72d1b05
--- /dev/null
+++ b/src/zenstore/include/zenstore/cache/cache.h
@@ -0,0 +1,52 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include <zenstore/cache/cachekey.h>
+#include <zenstore/cache/cachepolicy.h>
+
+ZEN_THIRD_PARTY_INCLUDES_START
+#include <fmt/format.h>
+ZEN_THIRD_PARTY_INCLUDES_END
+
+namespace zen {
+
+struct CacheRequestContext
+{
+	Oid		 SessionId{Oid::Zero};
+	uint32_t RequestId{0};
+};
+
+std::optional<std::string> GetValidNamespaceName(std::string_view Name);
+std::optional<std::string> GetValidBucketName(std::string_view Name);
+std::optional<IoHash>	   GetValidIoHash(std::string_view Hash);
+
+struct HttpCacheRequestData
+{
+	std::optional<std::string> Namespace;
+	std::optional<std::string> Bucket;
+	std::optional<IoHash>	   HashKey;
+	std::optional<IoHash>	   ValueContentId;
+};
+
+bool HttpCacheRequestParseRelativeUri(std::string_view Key, std::string_view DefaultNamespace, HttpCacheRequestData& Data);
+
+// Temporarily public
+std::optional<std::string> GetCacheRequestNamespace(const CbObjectView& Params);
+bool					   GetCacheRequestCacheKey(const CbObjectView& KeyView, CacheKey& Key);
+
+}  // namespace zen
+
+template<>
+struct fmt::formatter<zen::CacheRequestContext> : formatter<string_view>
+{
+	template<typename FormatContext>
+	auto format(const zen::CacheRequestContext& Context, FormatContext& ctx) const
+	{
+		zen::ExtendableStringBuilder<64> String;
+		Context.SessionId.ToString(String);
+		String << ".";
+		String << Context.RequestId;
+		return formatter<string_view>::format(String.ToView(), ctx);
+	}
+};
diff --git a/src/zenutil/include/zenutil/cache/cachekey.h b/src/zenstore/include/zenstore/cache/cachekey.h
index 0ab05f4f1..ae79f2a3d 100644
--- a/src/zenutil/include/zenutil/cache/cachekey.h
+++ b/src/zenstore/include/zenstore/cache/cachekey.h
@@ -6,7 +6,7 @@
 #include <zencore/string.h>
 #include <zencore/uid.h>
 
-#include <zenutil/cache/cachepolicy.h>
+#include <zenstore/cache/cachepolicy.h>
 
 namespace zen {
 
diff --git a/src/zenutil/include/zenutil/cache/cachepolicy.h b/src/zenstore/include/zenstore/cache/cachepolicy.h
index 7773cd3d1..7773cd3d1 100644
--- a/src/zenutil/include/zenutil/cache/cachepolicy.h
+++ b/src/zenstore/include/zenstore/cache/cachepolicy.h
diff --git a/src/zenstore/include/zenstore/cache/cacherpc.h b/src/zenstore/include/zenstore/cache/cacherpc.h
index e0c8738ca..eb40befa0 100644
--- a/src/zenstore/include/zenstore/cache/cacherpc.h
+++ b/src/zenstore/include/zenstore/cache/cacherpc.h
@@ -4,9 +4,9 @@
 
 #include <zencore/iobuffer.h>
 #include <zencore/logging.h>
+#include <zenstore/cache/cache.h>
 #include <zenstore/cache/cacheshared.h>
 #include <zenstore/cache/structuredcachestore.h>
-#include <zenutil/cache/cache.h>
 
 #include <atomic>
 #include <string_view>
diff --git a/src/zenstore/include/zenstore/cache/structuredcachestore.h b/src/zenstore/include/zenstore/cache/structuredcachestore.h
index c51d7312c..1ba469431 100644
--- a/src/zenstore/include/zenstore/cache/structuredcachestore.h
+++ b/src/zenstore/include/zenstore/cache/structuredcachestore.h
@@ -5,9 +5,9 @@
 #include <zencore/compactbinary.h>
 #include <zencore/iohash.h>
 #include <zencore/stats.h>
+#include <zenstore/cache/cache.h>
 #include <zenstore/cache/cachedisklayer.h>
 #include <zenstore/gc.h>
-#include <zenutil/cache/cache.h>
 #include <zenutil/statsreporter.h>
 
 #include <atomic>
diff --git a/src/zenstore/include/zenstore/cache/upstreamcacheclient.h b/src/zenstore/include/zenstore/cache/upstreamcacheclient.h
index 152031c3a..2f3b6b0d7 100644
--- a/src/zenstore/include/zenstore/cache/upstreamcacheclient.h
+++ b/src/zenstore/include/zenstore/cache/upstreamcacheclient.h
@@ -8,7 +8,7 @@
 #include <zencore/iohash.h>
 #include <zencore/stats.h>
 #include <zencore/zencore.h>
-#include <zenutil/cache/cache.h>
+#include <zenstore/cache/cache.h>
 
 #include <functional>
 #include <memory>
diff --git a/src/zenstore/zenstore.cpp b/src/zenstore/zenstore.cpp
index 85b50f03d..c563cc202 100644
--- a/src/zenstore/zenstore.cpp
+++ b/src/zenstore/zenstore.cpp
@@ -6,6 +6,7 @@
 
 #	include <zenstore/blockstore.h>
 #	include <zenstore/buildstore/buildstore.h>
+#	include <zenstore/cache/cachepolicy.h>
 #	include <zenstore/cache/structuredcachestore.h>
 #	include <zenstore/projectstore.h>
 #	include <zenstore/workspaces.h>
@@ -22,6 +23,7 @@ void
 zenstore_forcelinktests()
 {
 	buildstore_forcelink();
+	cachepolicy_forcelink();
 	CAS_forcelink();
 	filecas_forcelink();
 	blockstore_forcelink();
diff --git a/src/zenutil/include/zenutil/cache/cache.h b/src/zenutil/include/zenutil/cache/cache.h
deleted file mode 100644
index 20299a667..000000000
--- a/src/zenutil/include/zenutil/cache/cache.h
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright Epic Games, Inc. All Rights Reserved.
-
-#pragma once
-
-#include <zenutil/cache/cachekey.h>
-#include <zenutil/cache/cachepolicy.h>
-
-ZEN_THIRD_PARTY_INCLUDES_START
-#include <fmt/format.h>
-ZEN_THIRD_PARTY_INCLUDES_END
-
-namespace zen {
-
-struct CacheRequestContext
-{
-	Oid		 SessionId{Oid::Zero};
-	uint32_t RequestId{0};
-};
-
-}  // namespace zen
-
-template<>
-struct fmt::formatter<zen::CacheRequestContext> : formatter<string_view>
-{
-	template<typename FormatContext>
-	auto format(const zen::CacheRequestContext& Context, FormatContext& ctx) const
-	{
-		zen::ExtendableStringBuilder<64> String;
-		Context.SessionId.ToString(String);
-		String << ".";
-		String << Context.RequestId;
-		return formatter<string_view>::format(String.ToView(), ctx);
-	}
-};
diff --git a/src/zenutil/zenutil.cpp b/src/zenutil/zenutil.cpp
index 586fd1513..8e35e6223 100644
--- a/src/zenutil/zenutil.cpp
+++ b/src/zenutil/zenutil.cpp
@@ -4,7 +4,6 @@
 
 #if ZEN_WITH_TESTS
 
-#	include <zenutil/cache/cacherequests.h>
 #	include <zenutil/cache/rpcrecording.h>
 #	include <zenutil/commandlineoptions.h>
 #	include <zenutil/wildcard.h>
@@ -14,9 +13,7 @@ namespace zen {
 void
 zenutil_forcelinktests()
 {
-	cachepolicy_forcelink();
 	cache::rpcrecord_forcelink();
-	cacherequests_forcelink();
 	commandlineoptions_forcelink();
 	wildcard_forcelink();
 }