Merge pull request #102 from EpicGames/de/auto-create-namespaces

Automatically create namespaces on requests (if enabled via configuration)

1 files changed, 52 insertions, 19 deletions

diff --git a/zenserver/cache/structuredcachestore.cpp b/zenserver/cache/structuredcachestore.cpp
index 7509c5a71..3189a14cc 100644
--- a/zenserver/cache/structuredcachestore.cpp
+++ b/zenserver/cache/structuredcachestore.cpp
@@ -2130,12 +2130,16 @@ ZenCacheDiskLayer::TotalSize() const
 
 static constexpr std::string_view UE4DDCNamespaceName = "ue4.ddc";
 
-ZenCacheStore::ZenCacheStore(CasGc& Gc, std::filesystem::path BasePath) : GcStorage(Gc), GcContributor(Gc)
+ZenCacheStore::ZenCacheStore(CasGc& Gc, const Configuration& Configuration)
+: GcStorage(Gc)
+, GcContributor(Gc)
+, m_Gc(Gc)
+, m_Configuration(Configuration)
 {
-	CreateDirectories(BasePath);
+	CreateDirectories(m_Configuration.BasePath);
 
 	DirectoryContent DirContent;
-	GetDirectoryContent(BasePath, DirectoryContent::IncludeDirsFlag, DirContent);
+	GetDirectoryContent(m_Configuration.BasePath, DirectoryContent::IncludeDirsFlag, DirContent);
 
 	std::vector<std::string> LegacyBuckets;
 	std::vector<std::string> Namespaces;
@@ -2150,7 +2154,7 @@ ZenCacheStore::ZenCacheStore(CasGc& Gc, std::filesystem::path BasePath) : GcStor
 		LegacyBuckets.push_back(DirName);
 	}
 
-	ZEN_INFO("Found #{} namespaces in '{}' and #{} legacy buckets", Namespaces.size(), BasePath, LegacyBuckets.size());
+	ZEN_INFO("Found #{} namespaces in '{}' and #{} legacy buckets", Namespaces.size(), m_Configuration.BasePath, LegacyBuckets.size());
 
 	if (std::find(Namespaces.begin(), Namespaces.end(), UE4DDCNamespaceName) == Namespaces.end())
 	{
@@ -2158,13 +2162,14 @@ ZenCacheStore::ZenCacheStore(CasGc& Gc, std::filesystem::path BasePath) : GcStor
 
 		ZEN_INFO("Moving #{} legacy buckets to '{}' namespace", LegacyBuckets.size(), UE4DDCNamespaceName);
 
-		std::filesystem::path DefaultNamespaceFolder = BasePath / fmt::format("{}{}", NamespaceDiskPrefix, UE4DDCNamespaceName);
+		std::filesystem::path DefaultNamespaceFolder =
+			m_Configuration.BasePath / fmt::format("{}{}", NamespaceDiskPrefix, UE4DDCNamespaceName);
 		CreateDirectories(DefaultNamespaceFolder);
 
 		// Move any non-namespace folders into the default namespace folder
 		for (const std::string& DirName : LegacyBuckets)
 		{
-			std::filesystem::path LegacyFolder = BasePath / DirName;
+			std::filesystem::path LegacyFolder = m_Configuration.BasePath / DirName;
 			std::filesystem::path NewPath	   = DefaultNamespaceFolder / DirName;
 			std::error_code		  Ec;
 			std::filesystem::rename(LegacyFolder, NewPath, Ec);
@@ -2179,7 +2184,7 @@ ZenCacheStore::ZenCacheStore(CasGc& Gc, std::filesystem::path BasePath) : GcStor
 	for (const std::string& NamespaceName : Namespaces)
 	{
 		m_Namespaces[NamespaceName] =
-			std::make_unique<ZenCacheNamespace>(Gc, BasePath / fmt::format("{}{}", NamespaceDiskPrefix, NamespaceName));
+			std::make_unique<ZenCacheNamespace>(Gc, m_Configuration.BasePath / fmt::format("{}{}", NamespaceDiskPrefix, NamespaceName));
 	}
 }
 
@@ -2247,7 +2252,23 @@ ZenCacheStore::GetNamespace(std::string_view Namespace)
 			return It->second.get();
 		}
 	}
-	return nullptr;
+	_.ReleaseNow();
+
+	if (!m_Configuration.AllowAutomaticCreationOfNamespaces)
+	{
+		return nullptr;
+	}
+
+	RwLock::ExclusiveLockScope __(m_NamespacesLock);
+	if (auto It = m_Namespaces.find(std::string(Namespace)); It != m_Namespaces.end())
+	{
+		return It->second.get();
+	}
+
+	auto NewNamespace = m_Namespaces.insert_or_assign(
+		std::string(Namespace),
+		std::make_unique<ZenCacheNamespace>(m_Gc, m_Configuration.BasePath / fmt::format("{}{}", NamespaceDiskPrefix, Namespace)));
+	return NewNamespace.first->second.get();
 }
 
 void
@@ -3048,40 +3069,52 @@ TEST_CASE("z$.namespaces")
 	ScopedTemporaryDirectory TempDir;
 	CreateDirectories(TempDir.Path());
 
+	IoHash Key1;
+	IoHash Key2;
 	{
 		CasGc		  Gc;
-		ZenCacheStore Zcs(Gc, TempDir.Path() / "cache");
+		ZenCacheStore Zcs(Gc, {.BasePath = TempDir.Path() / "cache", .AllowAutomaticCreationOfNamespaces = false});
 		const auto	  Bucket		  = "teardrinker"sv;
 		const auto	  CustomNamespace = "mynamespace"sv;
 
 		// Create a cache record
-		const IoHash Key		= CreateKey(42);
-		CbObject	 CacheValue = CreateCacheValue(4096);
+		Key1				= CreateKey(42);
+		CbObject CacheValue = CreateCacheValue(4096);
 
 		IoBuffer Buffer = CacheValue.GetBuffer().AsIoBuffer();
 		Buffer.SetContentType(ZenContentType::kCbObject);
 
 		ZenCacheValue PutValue = {.Value = Buffer};
-		Zcs.Put(ZenCacheStore::DefaultNamespace, Bucket, Key, PutValue);
+		Zcs.Put(ZenCacheStore::DefaultNamespace, Bucket, Key1, PutValue);
 
 		ZenCacheValue GetValue;
-		CHECK(Zcs.Get(ZenCacheStore::DefaultNamespace, Bucket, Key, GetValue));
+		CHECK(Zcs.Get(ZenCacheStore::DefaultNamespace, Bucket, Key1, GetValue));
+		CHECK(!Zcs.Get(CustomNamespace, Bucket, Key1, GetValue));
 
-		CHECK(!Zcs.Get(CustomNamespace, Bucket, Key, GetValue));
+		// This should just be dropped as we don't allow creating of namespaces on the fly
+		Zcs.Put(CustomNamespace, Bucket, Key1, PutValue);
+		CHECK(!Zcs.Get(CustomNamespace, Bucket, Key1, GetValue));
+	}
 
-		// This should just be dropped for now until we decide how we add namespaces
-		Zcs.Put(CustomNamespace, Bucket, Key, PutValue);
-		CHECK(!Zcs.Get(CustomNamespace, Bucket, Key, GetValue));
+	{
+		CasGc		  Gc;
+		ZenCacheStore Zcs(Gc, {.BasePath = TempDir.Path() / "cache", .AllowAutomaticCreationOfNamespaces = true});
+		const auto	  Bucket		  = "teardrinker"sv;
+		const auto	  CustomNamespace = "mynamespace"sv;
 
-		const IoHash Key2		 = CreateKey(43);
-		CbObject	 CacheValue2 = CreateCacheValue(4096);
+		Key2				 = CreateKey(43);
+		CbObject CacheValue2 = CreateCacheValue(4096);
 
 		IoBuffer Buffer2 = CacheValue2.GetBuffer().AsIoBuffer();
 		Buffer2.SetContentType(ZenContentType::kCbObject);
 		ZenCacheValue PutValue2 = {.Value = Buffer2};
 		Zcs.Put(CustomNamespace, Bucket, Key2, PutValue2);
 
+		ZenCacheValue GetValue;
 		CHECK(!Zcs.Get(ZenCacheStore::DefaultNamespace, Bucket, Key2, GetValue));
+		CHECK(Zcs.Get(ZenCacheStore::DefaultNamespace, Bucket, Key1, GetValue));
+		CHECK(!Zcs.Get(CustomNamespace, Bucket, Key1, GetValue));
+		CHECK(Zcs.Get(CustomNamespace, Bucket, Key2, GetValue));
 	}
 }