bugfixes and test for namespace drop

1 files changed, 92 insertions, 15 deletions

diff --git a/zenserver/cache/structuredcachestore.cpp b/zenserver/cache/structuredcachestore.cpp
index aa3be3974..e4dbf390a 100644
--- a/zenserver/cache/structuredcachestore.cpp
+++ b/zenserver/cache/structuredcachestore.cpp
@@ -376,11 +376,7 @@ bool
 ZenCacheNamespace::Drop()
 {
 	m_MemLayer.Drop();
-	if (!m_DiskLayer.Drop())
-	{
-		return false;
-	}
-	return MoveAndDeleteDirectory(m_RootDir);
+	return m_DiskLayer.Drop();
 }
 
 void
@@ -2152,9 +2148,8 @@ ZenCacheDiskLayer::Drop()
 		{
 			return false;
 		}
-		return MoveAndDeleteDirectory(m_RootDir);
 	}
-	return true;
+	return MoveAndDeleteDirectory(m_RootDir);
 }
 
 void
@@ -2324,10 +2319,7 @@ ZenCacheStore::DropNamespace(std::string_view InNamespace)
 		ZenCacheNamespace& Namespace = *It->second;
 		m_DroppedNamespaces.push_back(std::move(It->second));
 		m_Namespaces.erase(It);
-		if (!Namespace.Drop())
-		{
-			return false;
-		}
+		return Namespace.Drop();
 	}
 	ZEN_WARN("request for unknown namespace '{}' in ZenCacheStore::DropNamespace", InNamespace);
 	return false;
@@ -3280,25 +3272,110 @@ TEST_CASE("z$.drop.bucket")
 		Workers.ScheduleWork([&]() {
 			zen::Sleep(100);
 			Value1.Value = IoBuffer{};
-			Value1		 = GetValue(Zcs, Namespace, Bucket, Key1);
-			CHECK(!Value1.Value);
 			WorkComplete = true;
 		});
 		// On Windows, DropBucket() will be blocked as long as we hold a reference to a buffer in the bucket
 		// Our DropBucket execution blocks any incoming request from completing until we are done with the drop
-		Zcs.DropBucket(Namespace, Bucket);
+		CHECK(Zcs.DropBucket(Namespace, Bucket));
 		while (!WorkComplete)
 		{
 			zen::Sleep(1);
 		}
-		CHECK(!Value1.Value);
 
 		// Entire bucket should be dropped, but doing a request should will re-create the namespace but it must still be empty
+		Value1 = GetValue(Zcs, Namespace, Bucket, Key1);
+		CHECK(!Value1.Value);
 		ZenCacheValue Value2 = GetValue(Zcs, Namespace, Bucket, Key2);
 		CHECK(!Value2.Value);
 	}
 }
 
+TEST_CASE("z$.drop.namespace")
+{
+	using namespace testutils;
+
+	const auto CreateCacheValue = [](size_t Size) -> CbObject {
+		std::vector<uint8_t> Buf;
+		Buf.resize(Size);
+
+		CbObjectWriter Writer;
+		Writer.AddBinary("Binary"sv, Buf.data(), Buf.size());
+		return Writer.Save();
+	};
+
+	ScopedTemporaryDirectory TempDir;
+	CreateDirectories(TempDir.Path());
+
+	auto PutValue =
+		[&CreateCacheValue](ZenCacheStore& Zcs, std::string_view Namespace, std::string_view Bucket, size_t KeyIndex, size_t Size) {
+			// Create a cache record
+			IoHash	 Key		= CreateKey(KeyIndex);
+			CbObject CacheValue = CreateCacheValue(Size);
+
+			IoBuffer Buffer = CacheValue.GetBuffer().AsIoBuffer();
+			Buffer.SetContentType(ZenContentType::kCbObject);
+
+			ZenCacheValue PutValue = {.Value = Buffer};
+			Zcs.Put(Namespace, Bucket, Key, PutValue);
+			return Key;
+		};
+	auto GetValue = [](ZenCacheStore& Zcs, std::string_view Namespace, std::string_view Bucket, const IoHash& Key) {
+		ZenCacheValue GetValue;
+		Zcs.Get(Namespace, Bucket, Key, GetValue);
+		return GetValue;
+	};
+	WorkerThreadPool Workers(1);
+	{
+		CasGc		  Gc;
+		ZenCacheStore Zcs(Gc, {.BasePath = TempDir.Path() / "cache", .AllowAutomaticCreationOfNamespaces = true});
+		const auto	  Bucket1	 = "teardrinker1"sv;
+		const auto	  Bucket2	 = "teardrinker2"sv;
+		const auto	  Namespace1 = "mynamespace1"sv;
+		const auto	  Namespace2 = "mynamespace2"sv;
+
+		IoHash Key1 = PutValue(Zcs, Namespace1, Bucket1, 42, 4096);
+		IoHash Key2 = PutValue(Zcs, Namespace1, Bucket2, 43, 2048);
+		IoHash Key3 = PutValue(Zcs, Namespace2, Bucket1, 44, 4096);
+		IoHash Key4 = PutValue(Zcs, Namespace2, Bucket2, 45, 2048);
+
+		ZenCacheValue Value1 = GetValue(Zcs, Namespace1, Bucket1, Key1);
+		CHECK(Value1.Value);
+		ZenCacheValue Value2 = GetValue(Zcs, Namespace1, Bucket2, Key2);
+		CHECK(Value2.Value);
+		ZenCacheValue Value3 = GetValue(Zcs, Namespace2, Bucket1, Key3);
+		CHECK(Value3.Value);
+		ZenCacheValue Value4 = GetValue(Zcs, Namespace2, Bucket2, Key4);
+		CHECK(Value4.Value);
+
+		std::atomic_bool WorkComplete = false;
+		Workers.ScheduleWork([&]() {
+			zen::Sleep(100);
+			Value1.Value = IoBuffer{};
+			Value2.Value = IoBuffer{};
+			Value3.Value = IoBuffer{};
+			Value4.Value = IoBuffer{};
+			WorkComplete = true;
+		});
+		// On Windows, DropBucket() will be blocked as long as we hold a reference to a buffer in the bucket
+		// Our DropBucket execution blocks any incoming request from completing until we are done with the drop
+		CHECK(Zcs.DropNamespace(Namespace1));
+		while (!WorkComplete)
+		{
+			zen::Sleep(1);
+		}
+
+		// Entire namespace should be dropped, but doing a request should will re-create the namespace but it must still be empty
+		Value1 = GetValue(Zcs, Namespace1, Bucket1, Key1);
+		CHECK(!Value1.Value);
+		Value2 = GetValue(Zcs, Namespace1, Bucket2, Key2);
+		CHECK(!Value2.Value);
+		Value3 = GetValue(Zcs, Namespace2, Bucket1, Key3);
+		CHECK(Value3.Value);
+		Value4 = GetValue(Zcs, Namespace2, Bucket2, Key4);
+		CHECK(Value4.Value);
+	}
+}
+
 TEST_CASE("z$.blocked.disklayer.put")
 {
 	ScopedTemporaryDirectory TempDir;