Added upstream cache policy command line option (read|write,readonly,writeonly,disabled).

5 files changed, 72 insertions, 23 deletions

diff --git a/zenserver/config.cpp b/zenserver/config.cpp
index 578a3a202..30401a52e 100644
--- a/zenserver/config.cpp
+++ b/zenserver/config.cpp
@@ -55,6 +55,27 @@ PickDefaultStateDirectory()
 
 #endif
 
+UpstreamCachePolicy
+ParseUpstreamCachePolicy(std::string_view Options)
+{
+	if (Options == "readonly")
+	{
+		return UpstreamCachePolicy::Read;
+	}
+	else if (Options == "writeonly")
+	{
+		return UpstreamCachePolicy::Write;
+	}
+	else if (Options == "disabled")
+	{
+		return UpstreamCachePolicy::Disabled;
+	}
+	else
+	{
+		return UpstreamCachePolicy::ReadWrite;
+	}
+}
+
 void
 ParseGlobalCliOptions(int argc, char* argv[], ZenServerOptions& GlobalOptions, ZenServiceConfig& ServiceConfig)
 {
@@ -98,6 +119,14 @@ ParseGlobalCliOptions(int argc, char* argv[], ZenServerOptions& GlobalOptions, Z
 					   cxxopts::value<bool>(ServiceConfig.ShouldCrash)->default_value("false"),
 					   "");
 
+	std::string UpstreamCachePolicyOptions;
+	options.add_option("cache",
+					   "",
+					   "upstream-cache-policy",
+					   "",
+					   cxxopts::value<std::string>(UpstreamCachePolicyOptions)->default_value(""),
+					   "Upstream cache policy (readwrite|readonly|writeonly|disabled)");
+
 	options.add_option("cache",
 					   "",
 					   "upstream-jupiter-url",
@@ -163,13 +192,6 @@ ParseGlobalCliOptions(int argc, char* argv[], ZenServerOptions& GlobalOptions, Z
 
 	options.add_option("cache",
 					   "",
-					   "upstream-enabled",
-					   "Whether upstream caching is disabled",
-					   cxxopts::value<bool>(ServiceConfig.UpstreamCacheConfig.Enabled)->default_value("true"),
-					   "");
-
-	options.add_option("cache",
-					   "",
 					   "upstream-thread-count",
 					   "Number of threads used for upstream procsssing",
 					   cxxopts::value<int>(ServiceConfig.UpstreamCacheConfig.UpstreamThreadCount)->default_value("4"),
@@ -185,6 +207,8 @@ ParseGlobalCliOptions(int argc, char* argv[], ZenServerOptions& GlobalOptions, Z
 
 			exit(0);
 		}
+
+		ServiceConfig.UpstreamCacheConfig.CachePolicy = ParseUpstreamCachePolicy(UpstreamCachePolicyOptions);
 	}
 	catch (cxxopts::OptionParseException& e)
 	{
@@ -261,7 +285,8 @@ ParseServiceConfig(const std::filesystem::path& DataRoot, ZenServiceConfig& Serv
 
 			if (auto UpstreamConfig = StructuredCacheConfig->get<sol::optional<sol::table>>("upstream"))
 			{
-				ServiceConfig.UpstreamCacheConfig.Enabled = UpstreamConfig->get_or("enable", ServiceConfig.UpstreamCacheConfig.Enabled);
+				std::string Policy									  = UpstreamConfig->get_or("policy", std::string());
+				ServiceConfig.UpstreamCacheConfig.CachePolicy		  = ParseUpstreamCachePolicy(Policy);
 				ServiceConfig.UpstreamCacheConfig.UpstreamThreadCount = UpstreamConfig->get_or("upstreamthreadcount", 4);
 
 				if (auto JupiterConfig = UpstreamConfig->get<sol::optional<sol::table>>("jupiter"))
diff --git a/zenserver/config.h b/zenserver/config.h
index 80ec86905..c3f08f84f 100644
--- a/zenserver/config.h
+++ b/zenserver/config.h
@@ -34,12 +34,20 @@ struct ZenUpstreamZenConfig
 	std::string Url;
 };
 
+enum class UpstreamCachePolicy : uint8_t
+{
+	Disabled  = 0,
+	Read	  = 1 << 0,
+	Write	  = 1 << 1,
+	ReadWrite = Read | Write
+};
+
 struct ZenUpstreamCacheConfig
 {
 	ZenUpstreamJupiterConfig JupiterConfig;
 	ZenUpstreamZenConfig	 ZenConfig;
 	int						 UpstreamThreadCount = 4;
-	bool					 Enabled			 = false;
+	UpstreamCachePolicy		 CachePolicy		 = UpstreamCachePolicy::ReadWrite;
 };
 
 struct ZenServiceConfig
diff --git a/zenserver/upstream/upstreamcache.cpp b/zenserver/upstream/upstreamcache.cpp
index 38d30a795..c015ef3e9 100644
--- a/zenserver/upstream/upstreamcache.cpp
+++ b/zenserver/upstream/upstreamcache.cpp
@@ -559,12 +559,15 @@ public:
 
 	virtual GetUpstreamCacheResult GetCacheRecord(UpstreamCacheKey CacheKey, ZenContentType Type) override
 	{
-		for (auto& Endpoint : m_Endpoints)
+		if (m_Options.ReadUpstream)
 		{
-			if (GetUpstreamCacheResult Result = Endpoint->GetCacheRecord(CacheKey, Type); Result.Success)
+			for (auto& Endpoint : m_Endpoints)
 			{
-				m_Stats.Add(*Endpoint, Result);
-				return Result;
+				if (GetUpstreamCacheResult Result = Endpoint->GetCacheRecord(CacheKey, Type); Result.Success)
+				{
+					m_Stats.Add(*Endpoint, Result);
+					return Result;
+				}
 			}
 		}
 
@@ -573,12 +576,15 @@ public:
 
 	virtual GetUpstreamCacheResult GetCachePayload(UpstreamPayloadKey PayloadKey) override
 	{
-		for (auto& Endpoint : m_Endpoints)
+		if (m_Options.ReadUpstream)
 		{
-			if (GetUpstreamCacheResult Result = Endpoint->GetCachePayload(PayloadKey); Result.Success)
+			for (auto& Endpoint : m_Endpoints)
 			{
-				m_Stats.Add(*Endpoint, Result);
-				return Result;
+				if (GetUpstreamCacheResult Result = Endpoint->GetCachePayload(PayloadKey); Result.Success)
+				{
+					m_Stats.Add(*Endpoint, Result);
+					return Result;
+				}
 			}
 		}
 
@@ -587,7 +593,7 @@ public:
 
 	virtual EnqueueResult EnqueueUpstream(UpstreamCacheRecord CacheRecord) override
 	{
-		if (m_IsRunning.load())
+		if (m_IsRunning.load() && m_Options.WriteUpstream)
 		{
 			if (!m_UpstreamThreads.empty())
 			{
diff --git a/zenserver/upstream/upstreamcache.h b/zenserver/upstream/upstreamcache.h
index 327778452..3b054d815 100644
--- a/zenserver/upstream/upstreamcache.h
+++ b/zenserver/upstream/upstreamcache.h
@@ -36,7 +36,9 @@ struct UpstreamCacheRecord
 
 struct UpstreamCacheOptions
 {
-	uint32_t ThreadCount = 4;
+	uint32_t ThreadCount   = 4;
+	bool	 ReadUpstream  = true;
+	bool	 WriteUpstream = true;
 };
 
 struct GetUpstreamCacheResult
diff --git a/zenserver/zenserver.cpp b/zenserver/zenserver.cpp
index eb0324161..63e94ab7d 100644
--- a/zenserver/zenserver.cpp
+++ b/zenserver/zenserver.cpp
@@ -11,9 +11,9 @@
 #include <zencore/timer.h>
 #include <zencore/windows.h>
 #include <zenhttp/httpserver.h>
-#include <zenutil/zenserverprocess.h>
 #include <zenstore/cas.h>
 #include <zenstore/cidstore.h>
+#include <zenutil/zenserverprocess.h>
 
 #include <fmt/format.h>
 #include <mimalloc-new-delete.h>
@@ -162,11 +162,15 @@ public:
 			m_CacheStore = std::make_unique<ZenCacheStore>(*m_CasStore, m_DataRoot / "cache");
 
 			std::unique_ptr<zen::UpstreamCache> UpstreamCache;
-			if (ServiceConfig.UpstreamCacheConfig.Enabled)
+			if (ServiceConfig.UpstreamCacheConfig.CachePolicy != UpstreamCachePolicy::Disabled)
 			{
 				const ZenUpstreamCacheConfig& UpstreamConfig = ServiceConfig.UpstreamCacheConfig;
 
 				zen::UpstreamCacheOptions UpstreamOptions;
+				UpstreamOptions.ReadUpstream =
+					(uint8_t(ServiceConfig.UpstreamCacheConfig.CachePolicy) & uint8_t(UpstreamCachePolicy::Read)) != 0;
+				UpstreamOptions.WriteUpstream =
+					(uint8_t(ServiceConfig.UpstreamCacheConfig.CachePolicy) & uint8_t(UpstreamCachePolicy::Write)) != 0;
 
 				if (UpstreamConfig.UpstreamThreadCount < 32)
 				{
@@ -212,7 +216,11 @@ public:
 
 				if (UpstreamCache->Initialize())
 				{
-					ZEN_INFO("upstream cache active");
+					ZEN_INFO("upstream cache active ({})",
+							 UpstreamOptions.ReadUpstream && UpstreamOptions.WriteUpstream ? "READ|WRITE"
+							 : UpstreamOptions.ReadUpstream								   ? "READONLY"
+							 : UpstreamOptions.WriteUpstream							   ? "WRITEONLY"
+																						   : "DISABLED");
 				}
 				else
 				{
@@ -422,7 +430,7 @@ private:
 	bool m_DebugOptionForcedCrash = false;
 };
 
-}
+}  // namespace zen
 
 int
 main(int argc, char* argv[])