Merged main into linux-mac

1 files changed, 260 insertions, 124 deletions

diff --git a/zenserver/cache/structuredcache.cpp b/zenserver/cache/structuredcache.cpp
index cf7deaa93..7f1fe7b44 100644
--- a/zenserver/cache/structuredcache.cpp
+++ b/zenserver/cache/structuredcache.cpp
@@ -9,6 +9,7 @@
 #include <zencore/stream.h>
 #include <zencore/timer.h>
 #include <zenhttp/httpserver.h>
+#include <zenstore/CAS.h>
 
 #include "structuredcache.h"
 #include "structuredcachestore.h"
@@ -25,17 +26,130 @@
 #include <queue>
 #include <thread>
 
+#include <gsl/gsl-lite.hpp>
+
 namespace zen {
 
 using namespace std::literals;
 
 //////////////////////////////////////////////////////////////////////////
 
-HttpStructuredCacheService::HttpStructuredCacheService(::ZenCacheStore&				  InCacheStore,
-													   zen::CasStore&				  InStore,
-													   zen::CidStore&				  InCidStore,
+namespace detail { namespace cacheopt {
+	constexpr std::string_view Local	   = "local"sv;
+	constexpr std::string_view Remote	   = "remote"sv;
+	constexpr std::string_view Data		   = "data"sv;
+	constexpr std::string_view Meta		   = "meta"sv;
+	constexpr std::string_view Value	   = "value"sv;
+	constexpr std::string_view Attachments = "attachments"sv;
+}}	// namespace detail::cacheopt
+
+//////////////////////////////////////////////////////////////////////////
+
+enum class CachePolicy : uint8_t
+{
+	None			= 0,
+	QueryLocal		= 1 << 0,
+	QueryRemote		= 1 << 1,
+	Query			= QueryLocal | QueryRemote,
+	StoreLocal		= 1 << 2,
+	StoreRemote		= 1 << 3,
+	Store			= StoreLocal | StoreRemote,
+	SkipMeta		= 1 << 4,
+	SkipValue		= 1 << 5,
+	SkipAttachments = 1 << 6,
+	SkipData		= SkipMeta | SkipValue | SkipAttachments,
+	SkipLocalCopy	= 1 << 7,
+	Local			= QueryLocal | StoreLocal,
+	Remote			= QueryRemote | StoreRemote,
+	Default			= Query | Store,
+	Disable			= None,
+};
+
+gsl_DEFINE_ENUM_BITMASK_OPERATORS(CachePolicy);
+
+CachePolicy
+ParseCachePolicy(const HttpServerRequest::QueryParams& QueryParams)
+{
+	CachePolicy QueryPolicy = CachePolicy::Query;
+
+	{
+		std::string_view Opts = QueryParams.GetValue("query"sv);
+		if (!Opts.empty())
+		{
+			QueryPolicy = CachePolicy::None;
+			ForEachStrTok(Opts, ',', [&QueryPolicy](const std::string_view& Opt) {
+				if (Opt == detail::cacheopt::Local)
+				{
+					QueryPolicy |= CachePolicy::QueryLocal;
+				}
+				if (Opt == detail::cacheopt::Remote)
+				{
+					QueryPolicy |= CachePolicy::QueryRemote;
+				}
+				return true;
+			});
+		}
+	}
+
+	CachePolicy StorePolicy = CachePolicy::Store;
+
+	{
+		std::string_view Opts = QueryParams.GetValue("store"sv);
+		if (!Opts.empty())
+		{
+			StorePolicy = CachePolicy::None;
+			ForEachStrTok(Opts, ',', [&StorePolicy](const std::string_view& Opt) {
+				if (Opt == detail::cacheopt::Local)
+				{
+					StorePolicy |= CachePolicy::StoreLocal;
+				}
+				if (Opt == detail::cacheopt::Remote)
+				{
+					StorePolicy |= CachePolicy::StoreRemote;
+				}
+				return true;
+			});
+		}
+	}
+
+	CachePolicy SkipPolicy = CachePolicy::None;
+
+	{
+		std::string_view Opts = QueryParams.GetValue("skip"sv);
+		if (!Opts.empty())
+		{
+			ForEachStrTok(Opts, ',', [&SkipPolicy](const std::string_view& Opt) {
+				if (Opt == detail::cacheopt::Meta)
+				{
+					SkipPolicy |= CachePolicy::SkipMeta;
+				}
+				if (Opt == detail::cacheopt::Value)
+				{
+					SkipPolicy |= CachePolicy::SkipValue;
+				}
+				if (Opt == detail::cacheopt::Attachments)
+				{
+					SkipPolicy |= CachePolicy::SkipAttachments;
+				}
+				if (Opt == detail::cacheopt::Data)
+				{
+					SkipPolicy |= CachePolicy::SkipData;
+				}
+				return true;
+			});
+		}
+	}
+
+	return QueryPolicy | StorePolicy | SkipPolicy;
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+HttpStructuredCacheService::HttpStructuredCacheService(ZenCacheStore&				  InCacheStore,
+													   CasStore&					  InStore,
+													   CidStore&					  InCidStore,
 													   std::unique_ptr<UpstreamCache> UpstreamCache)
-: m_Log(zen::logging::Get("cache"))
+: m_Log(logging::Get("cache"))
 , m_CacheStore(InCacheStore)
 , m_CasStore(InStore)
 , m_CidStore(InCidStore)
@@ -59,8 +173,14 @@ HttpStructuredCacheService::Flush()
 {
 }
 
+void 
+HttpStructuredCacheService::Scrub(ScrubContext& Ctx)
+{
+	ZEN_UNUSED(Ctx);
+}
+
 void
-HttpStructuredCacheService::HandleRequest(zen::HttpServerRequest& Request)
+HttpStructuredCacheService::HandleRequest(HttpServerRequest& Request)
 {
 	CacheRef Ref;
 
@@ -75,28 +195,31 @@ HttpStructuredCacheService::HandleRequest(zen::HttpServerRequest& Request)
 			return HandleCacheBucketRequest(Request, Key);
 		}
 
-		return Request.WriteResponse(zen::HttpResponseCode::BadRequest);  // invalid URL
+		return Request.WriteResponse(HttpResponseCode::BadRequest);	 // invalid URL
 	}
 
+	const auto	QueryParams = Request.GetQueryParams();
+	CachePolicy Policy		= ParseCachePolicy(QueryParams);
+
 	if (Ref.PayloadId == IoHash::Zero)
 	{
-		return HandleCacheRecordRequest(Request, Ref);
+		return HandleCacheRecordRequest(Request, Ref, Policy);
 	}
 	else
 	{
-		return HandleCachePayloadRequest(Request, Ref);
+		return HandleCachePayloadRequest(Request, Ref, Policy);
 	}
 
 	return;
 }
 
 void
-HttpStructuredCacheService::HandleCacheBucketRequest(zen::HttpServerRequest& Request, std::string_view Bucket)
+HttpStructuredCacheService::HandleCacheBucketRequest(HttpServerRequest& Request, std::string_view Bucket)
 {
 	ZEN_UNUSED(Request, Bucket);
 	switch (auto Verb = Request.RequestVerb())
 	{
-		using enum zen::HttpVerb;
+		using enum HttpVerb;
 
 		case kHead:
 		case kGet:
@@ -110,22 +233,22 @@ HttpStructuredCacheService::HandleCacheBucketRequest(zen::HttpServerRequest& Req
 
 			if (m_CacheStore.DropBucket(Bucket))
 			{
-				return Request.WriteResponse(zen::HttpResponseCode::OK);
+				return Request.WriteResponse(HttpResponseCode::OK);
 			}
 			else
 			{
-				return Request.WriteResponse(zen::HttpResponseCode::NotFound);
+				return Request.WriteResponse(HttpResponseCode::NotFound);
 			}
 			break;
 	}
 }
 
 void
-HttpStructuredCacheService::HandleCacheRecordRequest(zen::HttpServerRequest& Request, CacheRef& Ref)
+HttpStructuredCacheService::HandleCacheRecordRequest(HttpServerRequest& Request, CacheRef& Ref, CachePolicy Policy)
 {
 	switch (auto Verb = Request.RequestVerb())
 	{
-		using enum zen::HttpVerb;
+		using enum HttpVerb;
 
 		case kHead:
 		case kGet:
@@ -136,7 +259,9 @@ HttpStructuredCacheService::HandleCacheRecordRequest(zen::HttpServerRequest& Req
 				bool		  Success		  = m_CacheStore.Get(Ref.BucketSegment, Ref.HashKey, /* out */ Value);
 				bool		  InUpstreamCache = false;
 
-				if (!Success && m_UpstreamCache)
+				const bool QueryUpstream = !Success && m_UpstreamCache && (CachePolicy::QueryRemote == (Policy & CachePolicy::QueryRemote));
+
+				if (QueryUpstream)
 				{
 					const ZenContentType CacheRecordType = Ref.BucketSegment == "legacy"sv			  ? ZenContentType::kBinary
 														   : AcceptType == ZenContentType::kCbPackage ? ZenContentType::kCbPackage
@@ -153,14 +278,13 @@ HttpStructuredCacheService::HandleCacheRecordRequest(zen::HttpServerRequest& Req
 						{
 							if (CacheRecordType == ZenContentType::kCbObject)
 							{
-								const zen::CbValidateError ValidationResult =
-									zen::ValidateCompactBinary(UpstreamResult.Value, zen::CbValidateMode::All);
+								const CbValidateError ValidationResult = ValidateCompactBinary(UpstreamResult.Value, CbValidateMode::All);
 
 								if (ValidationResult == CbValidateError::None)
 								{
-									zen::CbObjectView CacheRecord(UpstreamResult.Value.Data());
+									CbObjectView CacheRecord(UpstreamResult.Value.Data());
 
-									zen::CbObjectWriter IndexData;
+									CbObjectWriter IndexData;
 									IndexData.BeginArray("references");
 									CacheRecord.IterateAttachments([&](CbFieldView Attachment) { IndexData.AddHash(Attachment.AsHash()); });
 									IndexData.EndArray();
@@ -214,6 +338,18 @@ HttpStructuredCacheService::HandleCacheRecordRequest(zen::HttpServerRequest& Req
 								if (FoundCount == AttachmentCount)
 								{
 									m_CacheStore.Put(Ref.BucketSegment, Ref.HashKey, {.Value = CacheRecord.GetBuffer().AsIoBuffer()});
+
+									if (zen::CachePolicy::SkipAttachments == (Policy & zen::CachePolicy::SkipAttachments))
+									{
+										CbPackage PackageWithoutAttachments;
+										PackageWithoutAttachments.SetObject(CacheRecord);
+
+										MemoryOutStream MemStream;
+										BinaryWriter	Writer(MemStream);
+										PackageWithoutAttachments.Save(Writer);
+
+										Value.Value = IoBuffer(IoBuffer::Clone, MemStream.Data(), MemStream.Size());
+									}
 								}
 								else
 								{
@@ -236,7 +372,7 @@ HttpStructuredCacheService::HandleCacheRecordRequest(zen::HttpServerRequest& Req
 				{
 					ZEN_DEBUG("MISS - '{}/{}'", Ref.BucketSegment, Ref.HashKey);
 
-					return Request.WriteResponse(zen::HttpResponseCode::NotFound);
+					return Request.WriteResponse(HttpResponseCode::NotFound);
 				}
 
 				if (Verb == kHead)
@@ -248,41 +384,45 @@ HttpStructuredCacheService::HandleCacheRecordRequest(zen::HttpServerRequest& Req
 				{
 					CbObjectView CacheRecord(Value.Value.Data());
 
-					const zen::CbValidateError ValidationResult = zen::ValidateCompactBinary(Value.Value, zen::CbValidateMode::All);
+					const CbValidateError ValidationResult = ValidateCompactBinary(Value.Value, CbValidateMode::All);
 
 					if (ValidationResult != CbValidateError::None)
 					{
 						ZEN_WARN("GET - cache record '{}/{}' FAILED, invalid compact binary object", Ref.BucketSegment, Ref.HashKey);
 
-						return Request.WriteResponse(zen::HttpResponseCode::NotFound, HttpContentType::kText, "Invalid cache record"sv);
+						return Request.WriteResponse(HttpResponseCode::NotFound, HttpContentType::kText, "Invalid cache record"sv);
 					}
 
-					uint32_t AttachmentCount = 0;
-					uint32_t FoundCount		 = 0;
-					uint64_t AttachmentBytes = 0ull;
+					const bool SkipAttachments = zen::CachePolicy::SkipAttachments == (Policy & zen::CachePolicy::SkipAttachments);
+					uint32_t   AttachmentCount = 0;
+					uint32_t   FoundCount	   = 0;
+					uint64_t   AttachmentBytes = 0ull;
 
 					CbPackage Package;
 
-					CacheRecord.IterateAttachments(
-						[this, &Ref, &Package, &AttachmentCount, &FoundCount, &AttachmentBytes](CbFieldView AttachmentHash) {
-							if (IoBuffer Chunk = m_CidStore.FindChunkByCid(AttachmentHash.AsHash()))
-							{
-								Package.AddAttachment(CbAttachment(CompressedBuffer::FromCompressed(SharedBuffer(Chunk))));
-								AttachmentBytes += Chunk.Size();
-								FoundCount++;
-							}
-							AttachmentCount++;
-						});
-
-					if (FoundCount != AttachmentCount)
+					if (!SkipAttachments)
 					{
-						ZEN_WARN("GET - cache record '{}/{}' FAILED, found '{}' of '{}' attachments",
-								 Ref.BucketSegment,
-								 Ref.HashKey,
-								 FoundCount,
-								 AttachmentCount);
+						CacheRecord.IterateAttachments(
+							[this, &Ref, &Package, &AttachmentCount, &FoundCount, &AttachmentBytes](CbFieldView AttachmentHash) {
+								if (IoBuffer Chunk = m_CidStore.FindChunkByCid(AttachmentHash.AsHash()))
+								{
+									Package.AddAttachment(CbAttachment(CompressedBuffer::FromCompressed(SharedBuffer(Chunk))));
+									AttachmentBytes += Chunk.Size();
+									FoundCount++;
+								}
+								AttachmentCount++;
+							});
+
+						if (FoundCount != AttachmentCount)
+						{
+							ZEN_WARN("GET - cache record '{}/{}' FAILED, found '{}' of '{}' attachments",
+									 Ref.BucketSegment,
+									 Ref.HashKey,
+									 FoundCount,
+									 AttachmentCount);
 
-						return Request.WriteResponse(zen::HttpResponseCode::NotFound, HttpContentType::kText, "Missing attachments"sv);
+							return Request.WriteResponse(HttpResponseCode::NotFound, HttpContentType::kText, "Missing attachments"sv);
+						}
 					}
 
 					Package.SetObject(LoadCompactBinaryObject(Value.Value));
@@ -300,7 +440,7 @@ HttpStructuredCacheService::HandleCacheRecordRequest(zen::HttpServerRequest& Req
 
 					IoBuffer Response(IoBuffer::Clone, MemStream.Data(), MemStream.Size());
 
-					return Request.WriteResponse(zen::HttpResponseCode::OK, HttpContentType::kCbPackage, Response);
+					return Request.WriteResponse(HttpResponseCode::OK, HttpContentType::kCbPackage, Response);
 				}
 				else
 				{
@@ -310,41 +450,43 @@ HttpStructuredCacheService::HandleCacheRecordRequest(zen::HttpServerRequest& Req
 							  NiceBytes(Value.Value.Size()),
 							  InUpstreamCache ? "UPSTREAM" : "LOCAL");
 
-					return Request.WriteResponse(zen::HttpResponseCode::OK, Value.Value.GetContentType(), Value.Value);
+					return Request.WriteResponse(HttpResponseCode::OK, Value.Value.GetContentType(), Value.Value);
 				}
 			}
 			break;
 
 		case kPut:
 			{
-				zen::IoBuffer Body = Request.ReadPayload();
+				IoBuffer Body = Request.ReadPayload();
 
 				if (!Body || Body.Size() == 0)
 				{
-					return Request.WriteResponse(zen::HttpResponseCode::BadRequest);
+					return Request.WriteResponse(HttpResponseCode::BadRequest);
 				}
 
 				const HttpContentType ContentType = Request.RequestContentType();
 
+				const bool StoreUpstream = m_UpstreamCache && (CachePolicy::StoreRemote == (Policy & CachePolicy::StoreRemote));
+
 				if (ContentType == HttpContentType::kBinary || ContentType == HttpContentType::kUnknownContentType)
 				{
 					// TODO: create a cache record and put value in CAS?
 					m_CacheStore.Put(Ref.BucketSegment, Ref.HashKey, {.Value = Body});
 					ZEN_DEBUG("PUT - binary '{}/{}' {}", Ref.BucketSegment, Ref.HashKey, NiceBytes(Body.Size()));
 
-					if (m_UpstreamCache)
+					if (StoreUpstream)
 					{
 						auto Result = m_UpstreamCache->EnqueueUpstream(
 							{.Type = ZenContentType::kBinary, .CacheKey = {Ref.BucketSegment, Ref.HashKey}});
 					}
 
-					return Request.WriteResponse(zen::HttpResponseCode::Created);
+					return Request.WriteResponse(HttpResponseCode::Created);
 				}
 				else if (ContentType == HttpContentType::kCbObject)
 				{
 					// Validate payload before accessing it
-					const zen::CbValidateError ValidationResult =
-						zen::ValidateCompactBinary(MemoryView(Body.Data(), Body.Size()), zen::CbValidateMode::All);
+					const CbValidateError ValidationResult =
+						ValidateCompactBinary(MemoryView(Body.Data(), Body.Size()), CbValidateMode::All);
 
 					if (ValidationResult != CbValidateError::None)
 					{
@@ -360,7 +502,7 @@ HttpStructuredCacheService::HandleCacheRecordRequest(zen::HttpServerRequest& Req
 					}
 
 					// Extract referenced payload hashes
-					zen::CbObjectView Cbo(Body.Data());
+					CbObjectView Cbo(Body.Data());
 
 					std::vector<IoHash> References;
 					std::vector<IoHash> MissingRefs;
@@ -371,7 +513,7 @@ HttpStructuredCacheService::HandleCacheRecordRequest(zen::HttpServerRequest& Req
 
 					if (!References.empty())
 					{
-						zen::CbObjectWriter Idx;
+						CbObjectWriter Idx;
 						Idx.BeginArray("references");
 
 						for (const IoHash& Hash : References)
@@ -393,26 +535,23 @@ HttpStructuredCacheService::HandleCacheRecordRequest(zen::HttpServerRequest& Req
 					ZEN_DEBUG("PUT - cache record '{}/{}' {}, {}/{} attachments missing",
 							  Ref.BucketSegment,
 							  Ref.HashKey,
-							  zen::NiceBytes(CacheValue.Value.Size()),
+							  NiceBytes(CacheValue.Value.Size()),
 							  MissingRefs.size(),
 							  References.size());
 
-					if (MissingRefs.empty())
+					if (MissingRefs.empty() && StoreUpstream)
 					{
-						// Only enqueue valid cache records, i.e. all referenced payloads exists
-						if (m_UpstreamCache)
-						{
-							auto Result = m_UpstreamCache->EnqueueUpstream({.Type		= ZenContentType::kCbObject,
-																			.CacheKey	= {Ref.BucketSegment, Ref.HashKey},
-																			.PayloadIds = std::move(References)});
-						}
+						ZEN_ASSERT(m_UpstreamCache);
+						auto Result = m_UpstreamCache->EnqueueUpstream({.Type		= ZenContentType::kCbObject,
+																		.CacheKey	= {Ref.BucketSegment, Ref.HashKey},
+																		.PayloadIds = std::move(References)});
 
-						return Request.WriteResponse(zen::HttpResponseCode::Created);
+						return Request.WriteResponse(HttpResponseCode::Created);
 					}
 					else
 					{
 						// TODO: Binary attachments?
-						zen::CbObjectWriter Response;
+						CbObjectWriter Response;
 						Response.BeginArray("needs");
 						for (const IoHash& MissingRef : MissingRefs)
 						{
@@ -422,7 +561,7 @@ HttpStructuredCacheService::HandleCacheRecordRequest(zen::HttpServerRequest& Req
 						Response.EndArray();
 
 						// Return Created | BadRequest?
-						return Request.WriteResponse(zen::HttpResponseCode::Created, Response.Save());
+						return Request.WriteResponse(HttpResponseCode::Created, Response.Save());
 					}
 				}
 				else if (ContentType == HttpContentType::kCbPackage)
@@ -437,26 +576,22 @@ HttpStructuredCacheService::HandleCacheRecordRequest(zen::HttpServerRequest& Req
 
 					CbObject CacheRecord = Package.GetObject();
 
-					int32_t	 AttachmentCount	  = 0;
-					int32_t	 NewAttachmentCount	  = 0;
-					uint64_t TotalAttachmentBytes = 0;
-					uint64_t TotalNewBytes		  = 0;
-					bool	 AttachmentsOk		  = true;
-
+					struct AttachmentInsertResult
+					{
+						int32_t	 Count	  = 0;
+						int32_t	 NewCount = 0;
+						uint64_t Bytes	  = 0;
+						uint64_t NewBytes = 0;
+						bool	 Ok		  = false;
+					};
+
+					AttachmentInsertResult		  AttachmentResult{.Ok = true};
 					std::span<const CbAttachment> Attachments = Package.GetAttachments();
+					std::vector<IoHash>			  PayloadIds;
 
-					std::vector<IoHash> PayloadIds;
 					PayloadIds.reserve(Attachments.size());
 
-					CacheRecord.IterateAttachments([this,
-													&Ref,
-													&Package,
-													&AttachmentsOk,
-													&AttachmentCount,
-													&TotalAttachmentBytes,
-													&TotalNewBytes,
-													&NewAttachmentCount,
-													&PayloadIds](CbFieldView AttachmentHash) {
+					CacheRecord.IterateAttachments([this, &Ref, &Package, &AttachmentResult, &PayloadIds](CbFieldView AttachmentHash) {
 						if (const CbAttachment* Attachment = Package.FindAttachment(AttachmentHash.AsHash()))
 						{
 							if (Attachment->IsCompressedBinary())
@@ -469,12 +604,12 @@ HttpStructuredCacheService::HandleCacheRecordRequest(zen::HttpServerRequest& Req
 
 								if (InsertResult.New)
 								{
-									TotalNewBytes += ChunkSize;
-									++NewAttachmentCount;
+									AttachmentResult.NewBytes += ChunkSize;
+									AttachmentResult.NewCount++;
 								}
 
-								TotalAttachmentBytes += ChunkSize;
-								AttachmentCount++;
+								AttachmentResult.Bytes += ChunkSize;
+								AttachmentResult.Count++;
 							}
 							else
 							{
@@ -482,7 +617,7 @@ HttpStructuredCacheService::HandleCacheRecordRequest(zen::HttpServerRequest& Req
 										 Ref.BucketSegment,
 										 Ref.HashKey,
 										 AttachmentHash.AsHash());
-								AttachmentsOk = false;
+								AttachmentResult.Ok = false;
 							}
 						}
 						else
@@ -491,23 +626,24 @@ HttpStructuredCacheService::HandleCacheRecordRequest(zen::HttpServerRequest& Req
 									 Ref.BucketSegment,
 									 Ref.HashKey,
 									 AttachmentHash.AsHash());
-							AttachmentsOk = false;
+							AttachmentResult.Ok = false;
 						}
 					});
 
-					if (!AttachmentsOk)
+					if (!AttachmentResult.Ok)
 					{
 						return Request.WriteResponse(HttpResponseCode::BadRequest, HttpContentType::kText, "Invalid attachments");
 					}
 
 					IoBuffer	   CacheRecordChunk	 = CacheRecord.GetBuffer().AsIoBuffer();
-					const uint64_t TotalPackageBytes = TotalAttachmentBytes + CacheRecordChunk.Size();
+					const uint64_t TotalPackageBytes = AttachmentResult.Bytes + CacheRecordChunk.Size();
 
 					ZenCacheValue CacheValue{.Value = CacheRecordChunk};
 					m_CacheStore.Put(Ref.BucketSegment, Ref.HashKey, CacheValue);
 
-					if (m_UpstreamCache)
+					if (StoreUpstream)
 					{
+						ZEN_ASSERT(m_UpstreamCache);
 						auto Result = m_UpstreamCache->EnqueueUpstream({.Type		= ZenContentType::kCbPackage,
 																		.CacheKey	= {Ref.BucketSegment, Ref.HashKey},
 																		.PayloadIds = std::move(PayloadIds)});
@@ -516,17 +652,17 @@ HttpStructuredCacheService::HandleCacheRecordRequest(zen::HttpServerRequest& Req
 					ZEN_DEBUG("PUT - cache record '{}/{}' {}, {}/{} ({}/{}) new attachments",
 							  Ref.BucketSegment,
 							  Ref.HashKey,
-							  zen::NiceBytes(TotalPackageBytes),
-							  NewAttachmentCount,
-							  AttachmentCount,
-							  zen::NiceBytes(TotalNewBytes),
-							  zen::NiceBytes(TotalAttachmentBytes));
+							  NiceBytes(TotalPackageBytes),
+							  AttachmentResult.NewCount,
+							  AttachmentResult.Count,
+							  NiceBytes(AttachmentResult.NewBytes),
+							  NiceBytes(AttachmentResult.Bytes));
 
-					return Request.WriteResponse(zen::HttpResponseCode::Created);
+					return Request.WriteResponse(HttpResponseCode::Created);
 				}
 				else
 				{
-					return Request.WriteResponse(zen::HttpResponseCode::BadRequest);
+					return Request.WriteResponse(HttpResponseCode::BadRequest);
 				}
 			}
 			break;
@@ -540,7 +676,7 @@ HttpStructuredCacheService::HandleCacheRecordRequest(zen::HttpServerRequest& Req
 }
 
 void
-HttpStructuredCacheService::HandleCachePayloadRequest(zen::HttpServerRequest& Request, CacheRef& Ref)
+HttpStructuredCacheService::HandleCachePayloadRequest(HttpServerRequest& Request, CacheRef& Ref, CachePolicy Policy)
 {
 	// Note: the URL references the uncompressed payload hash - so this maintains the mapping
 	// from uncompressed CAS identity (aka CID/Content ID) to the stored payload hash
@@ -548,27 +684,29 @@ HttpStructuredCacheService::HandleCachePayloadRequest(zen::HttpServerRequest& Re
 	// this is a PITA but a consequence of the fact that the client side code is not able to
 	// address data by compressed hash
 
+	ZEN_UNUSED(Policy);
+
 	switch (auto Verb = Request.RequestVerb())
 	{
-		using enum zen::HttpVerb;
+		using enum HttpVerb;
 
 		case kHead:
 		case kGet:
 			{
-				zen::IoBuffer Payload		  = m_CidStore.FindChunkByCid(Ref.PayloadId);
-				bool		  InUpstreamCache = false;
+				IoBuffer Payload		 = m_CidStore.FindChunkByCid(Ref.PayloadId);
+				bool	 InUpstreamCache = false;
 
 				if (!Payload && m_UpstreamCache)
 				{
 					if (auto UpstreamResult = m_UpstreamCache->GetCachePayload({{Ref.BucketSegment, Ref.HashKey}, Ref.PayloadId});
 						UpstreamResult.Success)
 					{
-						if (zen::CompressedBuffer Compressed = zen::CompressedBuffer::FromCompressed(SharedBuffer(UpstreamResult.Value)))
+						if (CompressedBuffer Compressed = CompressedBuffer::FromCompressed(SharedBuffer(UpstreamResult.Value)))
 						{
-							Payload								  = UpstreamResult.Value;
-							zen::IoHash					ChunkHash = zen::IoHash::HashBuffer(Payload);
-							zen::CasStore::InsertResult Result	  = m_CasStore.InsertChunk(Payload, ChunkHash);
-							InUpstreamCache						  = true;
+							Payload							 = UpstreamResult.Value;
+							IoHash				   ChunkHash = IoHash::HashBuffer(Payload);
+							CasStore::InsertResult Result	 = m_CasStore.InsertChunk(Payload, ChunkHash);
+							InUpstreamCache					 = true;
 
 							m_CidStore.AddCompressedCid(Ref.PayloadId, ChunkHash);
 						}
@@ -582,7 +720,7 @@ HttpStructuredCacheService::HandleCachePayloadRequest(zen::HttpServerRequest& Re
 				if (!Payload)
 				{
 					ZEN_DEBUG("MISS - '{}/{}/{}'", Ref.BucketSegment, Ref.HashKey, Ref.PayloadId);
-					return Request.WriteResponse(zen::HttpResponseCode::NotFound);
+					return Request.WriteResponse(HttpResponseCode::NotFound);
 				}
 
 				ZEN_DEBUG("HIT - '{}/{}/{}' {} (type: {}) ({})",
@@ -598,29 +736,27 @@ HttpStructuredCacheService::HandleCachePayloadRequest(zen::HttpServerRequest& Re
 					Request.SetSuppressResponseBody();
 				}
 
-				return Request.WriteResponse(zen::HttpResponseCode::OK, zen::HttpContentType::kBinary, Payload);
+				return Request.WriteResponse(HttpResponseCode::OK, HttpContentType::kBinary, Payload);
 			}
 			break;
 
 		case kPut:
 			{
-				if (zen::IoBuffer Body = Request.ReadPayload())
+				if (IoBuffer Body = Request.ReadPayload())
 				{
 					if (Body.Size() == 0)
 					{
-						return Request.WriteResponse(zen::HttpResponseCode::BadRequest,
-													 HttpContentType::kText,
-													 "Empty payload not permitted");
+						return Request.WriteResponse(HttpResponseCode::BadRequest, HttpContentType::kText, "Empty payload not permitted");
 					}
 
-					zen::IoHash ChunkHash = zen::IoHash::HashBuffer(Body);
+					IoHash ChunkHash = IoHash::HashBuffer(Body);
 
-					zen::CompressedBuffer Compressed = zen::CompressedBuffer::FromCompressed(SharedBuffer(Body));
+					CompressedBuffer Compressed = CompressedBuffer::FromCompressed(SharedBuffer(Body));
 
 					if (!Compressed)
 					{
 						// All attachment payloads need to be in compressed buffer format
-						return Request.WriteResponse(zen::HttpResponseCode::BadRequest,
+						return Request.WriteResponse(HttpResponseCode::BadRequest,
 													 HttpContentType::kText,
 													 "Attachments must be compressed");
 					}
@@ -632,7 +768,7 @@ HttpStructuredCacheService::HandleCachePayloadRequest(zen::HttpServerRequest& Re
 							return Request.WriteResponse(HttpResponseCode::BadRequest);
 						}
 
-						zen::CasStore::InsertResult Result = m_CasStore.InsertChunk(Body, ChunkHash);
+						CasStore::InsertResult Result = m_CasStore.InsertChunk(Body, ChunkHash);
 
 						m_CidStore.AddCompressedCid(Ref.PayloadId, ChunkHash);
 
@@ -646,11 +782,11 @@ HttpStructuredCacheService::HandleCachePayloadRequest(zen::HttpServerRequest& Re
 
 						if (Result.New)
 						{
-							return Request.WriteResponse(zen::HttpResponseCode::Created);
+							return Request.WriteResponse(HttpResponseCode::Created);
 						}
 						else
 						{
-							return Request.WriteResponse(zen::HttpResponseCode::OK);
+							return Request.WriteResponse(HttpResponseCode::OK);
 						}
 					}
 				}
@@ -666,7 +802,7 @@ HttpStructuredCacheService::HandleCachePayloadRequest(zen::HttpServerRequest& Re
 }
 
 bool
-HttpStructuredCacheService::ValidateKeyUri(zen::HttpServerRequest& Request, CacheRef& OutRef)
+HttpStructuredCacheService::ValidateKeyUri(HttpServerRequest& Request, CacheRef& OutRef)
 {
 	std::string_view			Key				  = Request.RelativeUri();
 	std::string_view::size_type BucketSplitOffset = Key.find_first_of('/');
@@ -702,14 +838,14 @@ HttpStructuredCacheService::ValidateKeyUri(zen::HttpServerRequest& Request, Cach
 		PayloadSegment = Key.substr(PayloadSplitOffset + 1);
 	}
 
-	if (HashSegment.size() != zen::IoHash::StringLength)
+	if (HashSegment.size() != IoHash::StringLength)
 	{
 		return false;
 	}
 
-	if (!PayloadSegment.empty() && PayloadSegment.size() == zen::IoHash::StringLength)
+	if (!PayloadSegment.empty() && PayloadSegment.size() == IoHash::StringLength)
 	{
-		const bool IsOk = zen::ParseHexBytes(PayloadSegment.data(), PayloadSegment.size(), OutRef.PayloadId.Hash);
+		const bool IsOk = ParseHexBytes(PayloadSegment.data(), PayloadSegment.size(), OutRef.PayloadId.Hash);
 
 		if (!IsOk)
 		{
@@ -718,10 +854,10 @@ HttpStructuredCacheService::ValidateKeyUri(zen::HttpServerRequest& Request, Cach
 	}
 	else
 	{
-		OutRef.PayloadId = zen::IoHash::Zero;
+		OutRef.PayloadId = IoHash::Zero;
 	}
 
-	const bool IsOk = zen::ParseHexBytes(HashSegment.data(), HashSegment.size(), OutRef.HashKey.Hash);
+	const bool IsOk = ParseHexBytes(HashSegment.data(), HashSegment.size(), OutRef.HashKey.Hash);
 
 	if (!IsOk)
 	{