cleanup and review feedback

4 files changed, 44 insertions, 43 deletions

diff --git a/zenserver/cache/structuredcache.cpp b/zenserver/cache/structuredcache.cpp
index 8deb958be..69ee32bd6 100644
--- a/zenserver/cache/structuredcache.cpp
+++ b/zenserver/cache/structuredcache.cpp
@@ -176,7 +176,7 @@ HttpStructuredCacheService::HandleCacheBucketRequest(HttpServerRequest& Request,
 		case HttpVerb::kDelete:
 			// Drop bucket
 
-			if (m_CacheStore.DropBucket("", Bucket))
+			if (m_CacheStore.DropBucket(ZenCacheStore::DefaultNamespace, Bucket))
 			{
 				return Request.WriteResponse(HttpResponseCode::OK);
 			}
@@ -225,7 +225,8 @@ HttpStructuredCacheService::HandleGetCacheRecord(zen::HttpServerRequest& Request
 		return Request.WriteResponse(HttpResponseCode::OK);
 	}
 
-	if (EnumHasAllFlags(PolicyFromURL, CachePolicy::QueryLocal) && m_CacheStore.Get("", Ref.BucketSegment, Ref.HashKey, ClientResultValue))
+	if (EnumHasAllFlags(PolicyFromURL, CachePolicy::QueryLocal) &&
+		m_CacheStore.Get(ZenCacheStore::DefaultNamespace, Ref.BucketSegment, Ref.HashKey, ClientResultValue))
 	{
 		Success					   = true;
 		ZenContentType ContentType = ClientResultValue.Value.GetContentType();
@@ -350,7 +351,7 @@ HttpStructuredCacheService::HandleGetCacheRecord(zen::HttpServerRequest& Request
 
 				if (Success && StoreLocal)
 				{
-					m_CacheStore.Put("", Ref.BucketSegment, Ref.HashKey, ClientResultValue);
+					m_CacheStore.Put(ZenCacheStore::DefaultNamespace, Ref.BucketSegment, Ref.HashKey, ClientResultValue);
 				}
 			}
 			else if (AcceptType == ZenContentType::kCbPackage)
@@ -404,7 +405,7 @@ HttpStructuredCacheService::HandleGetCacheRecord(zen::HttpServerRequest& Request
 
 						if (StoreLocal)
 						{
-							m_CacheStore.Put("", Ref.BucketSegment, Ref.HashKey, CacheValue);
+							m_CacheStore.Put(ZenCacheStore::DefaultNamespace, Ref.BucketSegment, Ref.HashKey, CacheValue);
 						}
 
 						BinaryWriter MemStream;
@@ -486,7 +487,7 @@ HttpStructuredCacheService::HandlePutCacheRecord(zen::HttpServerRequest& Request
 	if (ContentType == HttpContentType::kBinary || ContentType == HttpContentType::kCompressedBinary)
 	{
 		ZEN_DEBUG("PUT - '{}/{}' {} '{}'", Ref.BucketSegment, Ref.HashKey, NiceBytes(Body.Size()), ToString(ContentType));
-		m_CacheStore.Put("", Ref.BucketSegment, Ref.HashKey, {.Value = Body});
+		m_CacheStore.Put(ZenCacheStore::DefaultNamespace, Ref.BucketSegment, Ref.HashKey, {.Value = Body});
 
 		if (EnumHasAllFlags(PolicyFromURL, CachePolicy::StoreRemote))
 		{
@@ -528,7 +529,7 @@ HttpStructuredCacheService::HandlePutCacheRecord(zen::HttpServerRequest& Request
 				  ValidAttachments.size());
 
 		Body.SetContentType(ZenContentType::kCbObject);
-		m_CacheStore.Put("", Ref.BucketSegment, Ref.HashKey, {.Value = Body});
+		m_CacheStore.Put(ZenCacheStore::DefaultNamespace, Ref.BucketSegment, Ref.HashKey, {.Value = Body});
 
 		const bool IsPartialRecord = TotalCount != static_cast<int32_t>(ValidAttachments.size());
 
@@ -611,7 +612,7 @@ HttpStructuredCacheService::HandlePutCacheRecord(zen::HttpServerRequest& Request
 		CacheValue.Value = CacheRecord.GetBuffer().AsIoBuffer();
 		CacheValue.Value.SetContentType(ZenContentType::kCbObject);
 
-		m_CacheStore.Put("", Ref.BucketSegment, Ref.HashKey, CacheValue);
+		m_CacheStore.Put(ZenCacheStore::DefaultNamespace, Ref.BucketSegment, Ref.HashKey, CacheValue);
 
 		const bool IsPartialRecord = Count.Valid != Count.Total;
 
@@ -1013,7 +1014,7 @@ HttpStructuredCacheService::PutCacheRecord(PutRequestData& Request, const CbPack
 	CacheValue.Value = IoBuffer(Record.GetSize());
 	Record.CopyTo(MutableMemoryView(CacheValue.Value.MutableData(), CacheValue.Value.GetSize()));
 	CacheValue.Value.SetContentType(ZenContentType::kCbObject);
-	m_CacheStore.Put("", Request.Key.Bucket, Request.Key.Hash, CacheValue);
+	m_CacheStore.Put(ZenCacheStore::DefaultNamespace, Request.Key.Bucket, Request.Key.Hash, CacheValue);
 
 	const bool IsPartialRecord = Count.Valid != Count.Total;
 
@@ -1099,7 +1100,7 @@ HttpStructuredCacheService::HandleRpcGetCacheRecords(zen::HttpServerRequest& Htt
 		ZenCacheValue RecordCacheValue;
 
 		if (EnumHasAllFlags(Policy.GetRecordPolicy(), CachePolicy::QueryLocal) &&
-			m_CacheStore.Get("", Key.Bucket, Key.Hash, RecordCacheValue))
+			m_CacheStore.Get(ZenCacheStore::DefaultNamespace, Key.Bucket, Key.Hash, RecordCacheValue))
 		{
 			Request.RecordCacheValue = std::move(RecordCacheValue.Value);
 			if (Request.RecordCacheValue.GetContentType() != ZenContentType::kCbObject)
@@ -1230,7 +1231,7 @@ HttpStructuredCacheService::HandleRpcGetCacheRecords(zen::HttpServerRequest& Htt
 				Request.RecordObject = ObjectBuffer;
 				if (EnumHasAllFlags(Request.DownstreamPolicy.GetRecordPolicy(), CachePolicy::StoreLocal))
 				{
-					m_CacheStore.Put("", Key.Bucket, Key.Hash, {.Value = {Request.RecordCacheValue}});
+					m_CacheStore.Put(ZenCacheStore::DefaultNamespace, Key.Bucket, Key.Hash, {.Value = {Request.RecordCacheValue}});
 				}
 				ParseValues(Request);
 				Request.UsedUpstream = true;
@@ -1387,7 +1388,7 @@ HttpStructuredCacheService::HandleRpcPutCacheValues(zen::HttpServerRequest& Requ
 				{
 					IoBuffer Value = Chunk.GetCompressed().Flatten().AsIoBuffer();
 					Value.SetContentType(ZenContentType::kCompressedBinary);
-					m_CacheStore.Put("", Key.Bucket, Key.Hash, {.Value = Value});
+					m_CacheStore.Put(ZenCacheStore::DefaultNamespace, Key.Bucket, Key.Hash, {.Value = Value});
 					TransferredSize = Chunk.GetCompressedSize();
 				}
 				Succeeded = true;
@@ -1401,7 +1402,8 @@ HttpStructuredCacheService::HandleRpcPutCacheValues(zen::HttpServerRequest& Requ
 		else if (EnumHasAllFlags(Policy, CachePolicy::QueryLocal))
 		{
 			ZenCacheValue ExistingValue;
-			if (m_CacheStore.Get("", Key.Bucket, Key.Hash, ExistingValue) && IsCompressedBinary(ExistingValue.Value.GetContentType()))
+			if (m_CacheStore.Get(ZenCacheStore::DefaultNamespace, Key.Bucket, Key.Hash, ExistingValue) &&
+				IsCompressedBinary(ExistingValue.Value.GetContentType()))
 			{
 				Succeeded = true;
 			}
@@ -1484,7 +1486,8 @@ HttpStructuredCacheService::HandleRpcGetCacheValues(zen::HttpServerRequest& Http
 		ZenCacheValue CacheValue;
 		if (EnumHasAllFlags(Policy, CachePolicy::QueryLocal))
 		{
-			if (m_CacheStore.Get("", Key.Bucket, Key.Hash, CacheValue) && IsCompressedBinary(CacheValue.Value.GetContentType()))
+			if (m_CacheStore.Get(ZenCacheStore::DefaultNamespace, Key.Bucket, Key.Hash, CacheValue) &&
+				IsCompressedBinary(CacheValue.Value.GetContentType()))
 			{
 				Result = CompressedBuffer::FromCompressed(SharedBuffer(CacheValue.Value));
 			}
@@ -1548,7 +1551,10 @@ HttpStructuredCacheService::HandleRpcGetCacheValues(zen::HttpServerRequest& Http
 						// that we copy data from upstream even when SkipData and !StoreLocal are true means that it is too expensive
 						// for us to keep the data only on the upstream server.
 						// if (EnumHasAllFlags(Policy, CachePolicy::StoreLocal))
-						m_CacheStore.Put("", Request.Key.Bucket, Request.Key.Hash, ZenCacheValue{Params.Value});
+						m_CacheStore.Put(ZenCacheStore::DefaultNamespace,
+										 Request.Key.Bucket,
+										 Request.Key.Hash,
+										 ZenCacheValue{Params.Value});
 						ZEN_DEBUG("GETCACHEVALUES HIT - '{}/{}' {} ({}) in {}",
 								  ChunkRequest.Key.Bucket,
 								  ChunkRequest.Key.Hash,
@@ -1804,7 +1810,7 @@ HttpStructuredCacheService::GetLocalCacheRecords(std::vector<CacheKeyRequest>&
 			if (!Record.Exists && EnumHasAllFlags(Record.DownstreamPolicy, CachePolicy::QueryLocal))
 			{
 				ZenCacheValue CacheValue;
-				if (m_CacheStore.Get("", RecordKey.Key.Bucket, RecordKey.Key.Hash, CacheValue))
+				if (m_CacheStore.Get(ZenCacheStore::DefaultNamespace, RecordKey.Key.Bucket, RecordKey.Key.Hash, CacheValue))
 				{
 					Record.Exists	  = true;
 					Record.CacheValue = std::move(CacheValue.Value);
@@ -1839,7 +1845,7 @@ HttpStructuredCacheService::GetLocalCacheRecords(std::vector<CacheKeyRequest>&
 
 			if (EnumHasAllFlags(Record.DownstreamPolicy, CachePolicy::StoreLocal))
 			{
-				m_CacheStore.Put("", Key.Bucket, Key.Hash, {.Value = Record.CacheValue});
+				m_CacheStore.Put(ZenCacheStore::DefaultNamespace, Key.Bucket, Key.Hash, {.Value = Record.CacheValue});
 			}
 		};
 		m_UpstreamCache.GetCacheRecords(UpstreamRecordRequests, std::move(OnCacheRecordGetComplete));
@@ -1936,7 +1942,7 @@ HttpStructuredCacheService::GetLocalCacheValues(std::vector<cache::detail::Chunk
 		if (!Request->Exists && EnumHasAllFlags(Request->DownstreamPolicy, CachePolicy::QueryLocal))
 		{
 			ZenCacheValue CacheValue;
-			if (m_CacheStore.Get("", Request->Key->Key.Bucket, Request->Key->Key.Hash, CacheValue))
+			if (m_CacheStore.Get(ZenCacheStore::DefaultNamespace, Request->Key->Key.Bucket, Request->Key->Key.Hash, CacheValue))
 			{
 				if (IsCompressedBinary(CacheValue.Value.GetContentType()))
 				{
@@ -2005,7 +2011,7 @@ HttpStructuredCacheService::GetUpstreamCacheChunks(std::vector<CacheChunkRequest
 					}
 					else
 					{
-						m_CacheStore.Put("", Key.Key.Bucket, Key.Key.Hash, {.Value = Params.Value});
+						m_CacheStore.Put(ZenCacheStore::DefaultNamespace, Key.Key.Bucket, Key.Key.Hash, {.Value = Params.Value});
 					}
 				}
 				if (!EnumHasAllFlags(Request.DownstreamPolicy, CachePolicy::SkipData))
diff --git a/zenserver/cache/structuredcachestore.cpp b/zenserver/cache/structuredcachestore.cpp
index 075b7d408..7db18a7bb 100644
--- a/zenserver/cache/structuredcachestore.cpp
+++ b/zenserver/cache/structuredcachestore.cpp
@@ -2100,7 +2100,7 @@ ZenCacheDiskLayer::TotalSize() const
 
 //////////////////////////// ZenCacheStore
 
-const char* ZenCacheNamespaceDirPrefix = "ns_";
+static constexpr std::string_view ZenCacheNamespaceDirPrefix = "ns_";
 
 namespace {
 
@@ -2146,10 +2146,10 @@ ZenCacheStore::ZenCacheStore(std::filesystem::path BasePath, CasGc& Gc) : GcStor
 
 	ZEN_INFO("Found #{} namespaces in '{}' and #{} legacy buckets", Namespaces.size(), BasePath, LegacyBuckets.size());
 
-	if (std::find(Namespaces.begin(), Namespaces.end(), "") == Namespaces.end())
+	if (std::find(Namespaces.begin(), Namespaces.end(), DefaultNamespace) == Namespaces.end())
 	{
 		ZEN_INFO("Moving #{} legacy buckets to anonymous namespace", LegacyBuckets.size());
-		std::filesystem::path DefaultNamespaceFolder = BasePath / ZenCacheNamespaceDirPrefix;
+		std::filesystem::path DefaultNamespaceFolder = BasePath / fmt::format("{}{}", ZenCacheNamespaceDirPrefix, DefaultNamespace);
 		CreateDirectories(DefaultNamespaceFolder);
 
 		// Move any non-namespace folders into the default namespace folder
@@ -2159,12 +2159,12 @@ ZenCacheStore::ZenCacheStore(std::filesystem::path BasePath, CasGc& Gc) : GcStor
 			std::filesystem::path NewPath	   = DefaultNamespaceFolder / DirName;
 			std::filesystem::rename(LegacyFolder, NewPath);
 		}
-		Namespaces.push_back("");
+		Namespaces.push_back(std::string(DefaultNamespace));
 	}
 
 	for (const std::string& NamespaceName : Namespaces)
 	{
-		Ref<ZenCacheNamespace> Store = new ZenCacheNamespace(Gc, BasePath / (ZenCacheNamespaceDirPrefix + NamespaceName));
+		Ref<ZenCacheNamespace> Store = new ZenCacheNamespace(Gc, BasePath / fmt::format("{}{}", ZenCacheNamespaceDirPrefix, NamespaceName));
 		m_Namespaces[NamespaceName]	 = Store;
 	}
 }
@@ -2175,7 +2175,7 @@ ZenCacheStore::~ZenCacheStore()
 }
 
 bool
-ZenCacheStore::Get(const std::string& Namespace, std::string_view Bucket, const IoHash& HashKey, ZenCacheValue& OutValue)
+ZenCacheStore::Get(std::string_view Namespace, std::string_view Bucket, const IoHash& HashKey, ZenCacheValue& OutValue)
 {
 	Ref<ZenCacheNamespace> Store = GetStore(Namespace);
 	if (!Store)
@@ -2186,9 +2186,9 @@ ZenCacheStore::Get(const std::string& Namespace, std::string_view Bucket, const
 }
 
 void
-ZenCacheStore::Put(const std::string& Namespace, std::string_view Bucket, const IoHash& HashKey, const ZenCacheValue& Value)
+ZenCacheStore::Put(std::string_view Namespace, std::string_view Bucket, const IoHash& HashKey, const ZenCacheValue& Value)
 {
-	Ref<ZenCacheNamespace> Store = GetStore(Namespace);
+	Ref<ZenCacheNamespace> Store = GetStore(std::string(Namespace));
 	if (!Store)
 	{
 		return;
@@ -2197,9 +2197,9 @@ ZenCacheStore::Put(const std::string& Namespace, std::string_view Bucket, const
 }
 
 bool
-ZenCacheStore::DropBucket(const std::string& Namespace, std::string_view Bucket)
+ZenCacheStore::DropBucket(std::string_view Namespace, std::string_view Bucket)
 {
-	Ref<ZenCacheNamespace> Store = GetStore(Namespace);
+	Ref<ZenCacheNamespace> Store = GetStore(std::string(Namespace));
 	if (!Store)
 	{
 		return false;
@@ -2210,14 +2210,7 @@ ZenCacheStore::DropBucket(const std::string& Namespace, std::string_view Bucket)
 void
 ZenCacheStore::Flush()
 {
-	std::vector<Ref<ZenCacheNamespace>> Stores;
-	RwLock::SharedLockScope				_(m_NamespacesLock);
-	Stores.reserve(m_Namespaces.size());
-	for (const auto& Entry : m_Namespaces)
-	{
-		Stores.push_back(Entry.second);
-	}
-	_.ReleaseNow();
+	std::vector<Ref<ZenCacheNamespace>> Stores = GetAllStores();
 	for (const Ref<ZenCacheNamespace>& Store : Stores)
 	{
 		Store->Flush();
@@ -2235,10 +2228,10 @@ ZenCacheStore::Scrub(ScrubContext& Ctx)
 }
 
 Ref<ZenCacheNamespace>
-ZenCacheStore::GetStore(const std::string& Namespace)
+ZenCacheStore::GetStore(std::string_view Namespace)
 {
 	RwLock::SharedLockScope _(m_NamespacesLock);
-	if (auto It = m_Namespaces.find(Namespace); It != m_Namespaces.end())
+	if (auto It = m_Namespaces.find(std::string(Namespace)); It != m_Namespaces.end())
 	{
 		return It->second;
 	}
diff --git a/zenserver/cache/structuredcachestore.h b/zenserver/cache/structuredcachestore.h
index a803b0603..910c56745 100644
--- a/zenserver/cache/structuredcachestore.h
+++ b/zenserver/cache/structuredcachestore.h
@@ -356,12 +356,14 @@ private:
 class ZenCacheStore final : public GcStorage, public GcContributor
 {
 public:
+	static constexpr std::string_view DefaultNamespace = "";
+
 	ZenCacheStore(std::filesystem::path BasePath, CasGc& Gc);
 	~ZenCacheStore();
 
-	bool Get(const std::string& Namespace, std::string_view Bucket, const IoHash& HashKey, ZenCacheValue& OutValue);
-	void Put(const std::string& Namespace, std::string_view Bucket, const IoHash& HashKey, const ZenCacheValue& Value);
-	bool DropBucket(const std::string& Namespace, std::string_view Bucket);
+	bool Get(std::string_view Namespace, std::string_view Bucket, const IoHash& HashKey, ZenCacheValue& OutValue);
+	void Put(std::string_view Namespace, std::string_view Bucket, const IoHash& HashKey, const ZenCacheValue& Value);
+	bool DropBucket(std::string_view Namespace, std::string_view Bucket);
 	void Flush();
 	void Scrub(ScrubContext& Ctx);
 
@@ -370,7 +372,7 @@ public:
 	virtual GcStorageSize StorageSize() const override;
 
 private:
-	Ref<ZenCacheNamespace>									GetStore(const std::string& Namespace);
+	Ref<ZenCacheNamespace>									GetStore(std::string_view Namespace);
 	std::vector<Ref<ZenCacheNamespace>>						GetAllStores() const;
 	mutable RwLock											m_NamespacesLock;
 	std::unordered_map<std::string, Ref<ZenCacheNamespace>> m_Namespaces;
diff --git a/zenserver/upstream/upstreamcache.cpp b/zenserver/upstream/upstreamcache.cpp
index c89227106..c870e0773 100644
--- a/zenserver/upstream/upstreamcache.cpp
+++ b/zenserver/upstream/upstreamcache.cpp
@@ -1517,7 +1517,7 @@ private:
 		ZenCacheValue		  CacheValue;
 		std::vector<IoBuffer> Payloads;
 
-		if (!m_CacheStore.Get("", CacheRecord.Key.Bucket, CacheRecord.Key.Hash, CacheValue))
+		if (!m_CacheStore.Get(ZenCacheStore::DefaultNamespace, CacheRecord.Key.Bucket, CacheRecord.Key.Hash, CacheValue))
 		{
 			ZEN_WARN("process upstream FAILED, '{}/{}', cache record doesn't exist", CacheRecord.Key.Bucket, CacheRecord.Key.Hash);
 			return;