Initial support for cache policies.

1 files changed, 136 insertions, 15 deletions

diff --git a/zenserver/cache/structuredcache.cpp b/zenserver/cache/structuredcache.cpp
index da2e8850e..c66b1f98d 100644
--- a/zenserver/cache/structuredcache.cpp
+++ b/zenserver/cache/structuredcache.cpp
@@ -25,12 +25,125 @@
 #include <queue>
 #include <thread>
 
+#include <gsl/gsl-lite.hpp>
+
 namespace zen {
 
 using namespace std::literals;
 
 //////////////////////////////////////////////////////////////////////////
 
+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 zen::HttpServerRequest::QueryParams& QueryParams)
+{
+	CachePolicy QueryPolicy = CachePolicy::Query;
+
+	{
+		std::string_view Opts = QueryParams.GetValue("query"sv);
+		if (!Opts.empty())
+		{
+			QueryPolicy = CachePolicy::None;
+			zen::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;
+			zen::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())
+		{
+			zen::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,
 													   zen::CasStore&				  InStore,
 													   zen::CidStore&				  InCidStore,
@@ -78,13 +191,16 @@ HttpStructuredCacheService::HandleRequest(zen::HttpServerRequest& Request)
 		return Request.WriteResponse(zen::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;
@@ -121,7 +237,7 @@ HttpStructuredCacheService::HandleCacheBucketRequest(zen::HttpServerRequest& Req
 }
 
 void
-HttpStructuredCacheService::HandleCacheRecordRequest(zen::HttpServerRequest& Request, CacheRef& Ref)
+HttpStructuredCacheService::HandleCacheRecordRequest(zen::HttpServerRequest& Request, CacheRef& Ref, CachePolicy Policy)
 {
 	switch (auto Verb = Request.RequestVerb())
 	{
@@ -136,7 +252,10 @@ 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 && (zen::CachePolicy::QueryRemote == (Policy & zen::CachePolicy::QueryRemote));
+
+				if (QueryUpstream)
 				{
 					const ZenContentType CacheRecordType = Ref.BucketSegment == "legacy"sv			  ? ZenContentType::kBinary
 														   : AcceptType == ZenContentType::kCbPackage ? ZenContentType::kCbPackage
@@ -326,13 +445,15 @@ HttpStructuredCacheService::HandleCacheRecordRequest(zen::HttpServerRequest& Req
 
 				const HttpContentType ContentType = Request.RequestContentType();
 
+				const bool StoreUpstream = m_UpstreamCache && (zen::CachePolicy::StoreRemote == (Policy & zen::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}});
@@ -397,15 +518,12 @@ HttpStructuredCacheService::HandleCacheRecordRequest(zen::HttpServerRequest& Req
 							  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);
 					}
@@ -502,8 +620,9 @@ HttpStructuredCacheService::HandleCacheRecordRequest(zen::HttpServerRequest& Req
 					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)});
@@ -536,7 +655,7 @@ HttpStructuredCacheService::HandleCacheRecordRequest(zen::HttpServerRequest& Req
 }
 
 void
-HttpStructuredCacheService::HandleCachePayloadRequest(zen::HttpServerRequest& Request, CacheRef& Ref)
+HttpStructuredCacheService::HandleCachePayloadRequest(zen::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
@@ -544,6 +663,8 @@ 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;