remove gc v1 (#121)

* kill gc v1
* block use of gc v1 from zen command line
* warn and flip to gcv2 if --gc-v2=false is specified for zenserver

1 files changed, 19 insertions, 506 deletions

diff --git a/src/zenstore/gc.cpp b/src/zenstore/gc.cpp
index 1276b9b4c..981ba15cb 100644
--- a/src/zenstore/gc.cpp
+++ b/src/zenstore/gc.cpp
@@ -196,152 +196,6 @@ SaveCompactBinaryObject(const fs::path& Path, const CbObject& Object)
 
 //////////////////////////////////////////////////////////////////////////
 
-struct GcContext::GcState
-{
-	using CacheKeyContexts = std::unordered_map<std::string, std::vector<IoHash>>;
-
-	CacheKeyContexts   m_ExpiredCacheKeys;
-	HashKeySet		   m_RetainedCids;
-	HashKeySet		   m_DeletedCids;
-	GcClock::TimePoint m_CacheExpireTime;
-	GcClock::TimePoint m_ProjectStoreExpireTime;
-	bool			   m_DeletionMode		 = true;
-	bool			   m_CollectSmallObjects = false;
-	bool			   m_SkipCid			 = false;
-
-	std::filesystem::path DiskReservePath;
-};
-
-GcContext::GcContext(const GcClock::TimePoint& CacheExpireTime, const GcClock::TimePoint& ProjectStoreExpireTime)
-: m_State(std::make_unique<GcState>())
-{
-	m_State->m_CacheExpireTime		  = CacheExpireTime;
-	m_State->m_ProjectStoreExpireTime = ProjectStoreExpireTime;
-}
-
-GcContext::~GcContext()
-{
-}
-
-void
-GcContext::AddRetainedCids(std::span<const IoHash> Cids)
-{
-	m_State->m_RetainedCids.AddHashesToSet(Cids);
-}
-
-void
-GcContext::SetExpiredCacheKeys(const std::string& CacheKeyContext, std::vector<IoHash>&& ExpiredKeys)
-{
-	m_State->m_ExpiredCacheKeys[CacheKeyContext] = std::move(ExpiredKeys);
-}
-
-void
-GcContext::IterateCids(std::function<void(const IoHash&)> Callback)
-{
-	m_State->m_RetainedCids.IterateHashes([&](const IoHash& Hash) { Callback(Hash); });
-}
-
-void
-GcContext::FilterCids(std::span<const IoHash> Cid, std::function<void(const IoHash&)> KeepFunc)
-{
-	m_State->m_RetainedCids.FilterHashes(Cid, [&](const IoHash& Hash) { KeepFunc(Hash); });
-}
-
-void
-GcContext::FilterCids(std::span<const IoHash> Cid, std::function<void(const IoHash&, bool)>&& FilterFunc)
-{
-	m_State->m_RetainedCids.FilterHashes(Cid, std::move(FilterFunc));
-}
-
-void
-GcContext::AddDeletedCids(std::span<const IoHash> Cas)
-{
-	m_State->m_DeletedCids.AddHashesToSet(Cas);
-}
-
-const HashKeySet&
-GcContext::DeletedCids()
-{
-	return m_State->m_DeletedCids;
-}
-
-std::span<const IoHash>
-GcContext::ExpiredCacheKeys(const std::string& CacheKeyContext) const
-{
-	return m_State->m_ExpiredCacheKeys[CacheKeyContext];
-}
-
-bool
-GcContext::SkipCid() const
-{
-	return m_State->m_SkipCid;
-}
-
-void
-GcContext::SetSkipCid(bool NewState)
-{
-	m_State->m_SkipCid = NewState;
-}
-
-bool
-GcContext::IsDeletionMode() const
-{
-	return m_State->m_DeletionMode;
-}
-
-void
-GcContext::SetDeletionMode(bool NewState)
-{
-	m_State->m_DeletionMode = NewState;
-}
-
-bool
-GcContext::CollectSmallObjects() const
-{
-	return m_State->m_CollectSmallObjects;
-}
-
-void
-GcContext::CollectSmallObjects(bool NewState)
-{
-	m_State->m_CollectSmallObjects = NewState;
-}
-
-GcClock::TimePoint
-GcContext::CacheExpireTime() const
-{
-	return m_State->m_CacheExpireTime;
-}
-
-GcClock::TimePoint
-GcContext::ProjectStoreExpireTime() const
-{
-	return m_State->m_ProjectStoreExpireTime;
-}
-
-void
-GcContext::DiskReservePath(const std::filesystem::path& Path)
-{
-	m_State->DiskReservePath = Path;
-}
-
-uint64_t
-GcContext::ClaimGCReserve()
-{
-	if (!std::filesystem::is_regular_file(m_State->DiskReservePath))
-	{
-		return 0;
-	}
-	uint64_t ReclaimedSize = std::filesystem::file_size(m_State->DiskReservePath);
-	if (std::filesystem::remove(m_State->DiskReservePath))
-	{
-		return ReclaimedSize;
-	}
-	return 0;
-}
-
-//////////////////////////////////////////////////////////////////////////
-
 GcManager::GcManager() : m_Log(logging::Get("gc"))
 {
 }
@@ -1287,20 +1141,6 @@ GcManager::SetCancelGC(bool CancelFlag)
 }
 
 void
-GcManager::AddGcContributor(GcContributor* Contributor)
-{
-	RwLock::ExclusiveLockScope _(m_Lock);
-	m_GcContribs.push_back(Contributor);
-}
-
-void
-GcManager::RemoveGcContributor(GcContributor* Contributor)
-{
-	RwLock::ExclusiveLockScope _(m_Lock);
-	std::erase_if(m_GcContribs, [&](GcContributor* $) { return $ == Contributor; });
-}
-
-void
 GcManager::AddGcStorage(GcStorage* Storage)
 {
 	ZEN_ASSERT(Storage != nullptr);
@@ -1327,58 +1167,6 @@ GcManager::ScrubStorage(ScrubContext& GcCtx)
 }
 
 GcStorageSize
-GcManager::CollectGarbage(GcContext& GcCtx)
-{
-	ZEN_TRACE_CPU("Gc::CollectGarbage");
-
-	GcStorageSize GCTotalSizeDiff;
-
-	RwLock::SharedLockScope _(m_Lock);
-
-	// First gather reference set
-	{
-		ZEN_TRACE_CPU("Gc::CollectGarbage::GatherReferences");
-		Stopwatch  Timer;
-		const auto Guard = MakeGuard([&] { ZEN_INFO("gathered references in {}", NiceTimeSpanMs(Timer.GetElapsedTimeMs())); });
-		for (GcContributor* Contributor : m_GcContribs)
-		{
-			if (CheckGCCancel())
-			{
-				return GCTotalSizeDiff;
-			}
-			Contributor->GatherReferences(GcCtx);
-		}
-	}
-
-	// Then trim storage
-	{
-		ZEN_TRACE_CPU("Gc::CollectGarbage::CollectGarbage");
-
-		Stopwatch  Timer;
-		const auto Guard = MakeGuard([&] {
-			ZEN_INFO("collected garbage in {}. Removed {} disk space, {} memory",
-					 NiceTimeSpanMs(Timer.GetElapsedTimeMs()),
-					 NiceBytes(GCTotalSizeDiff.DiskSize),
-					 NiceBytes(GCTotalSizeDiff.MemorySize));
-		});
-		for (GcStorage* Storage : m_GcStorage)
-		{
-			if (CheckGCCancel())
-			{
-				break;
-			}
-
-			const auto PreSize = Storage->StorageSize();
-			Storage->CollectGarbage(GcCtx);
-			const auto PostSize = Storage->StorageSize();
-			GCTotalSizeDiff.DiskSize += PreSize.DiskSize > PostSize.DiskSize ? PreSize.DiskSize - PostSize.DiskSize : 0;
-			GCTotalSizeDiff.MemorySize += PreSize.MemorySize > PostSize.MemorySize ? PreSize.MemorySize - PostSize.MemorySize : 0;
-		}
-	}
-	return GCTotalSizeDiff;
-}
-
-GcStorageSize
 GcManager::TotalStorageSize() const
 {
 	ZEN_TRACE_CPU("Gc::TotalStorageSize");
@@ -2319,14 +2107,10 @@ GcScheduler::CollectGarbage(const GcClock::TimePoint& CacheExpireTime,
 
 	try
 	{
-		GcContext GcCtx(CacheExpireTime, ProjectStoreExpireTime);
-		GcCtx.SetDeletionMode(Delete);
-		GcCtx.SetSkipCid(SkipCid);
-		GcCtx.CollectSmallObjects(CollectSmallObjects);
-		GcCtx.DiskReservePath(m_Config.RootDirectory / "reserve.gc");
+		const std::filesystem::path DiskReservePath = m_Config.RootDirectory / "reserve.gc";
 
 		auto ReclaimDiskReserve = [&]() {
-			std::error_code Ec = CreateGCReserve(m_Config.RootDirectory / "reserve.gc", m_Config.DiskReserveSize);
+			std::error_code Ec = CreateGCReserve(DiskReservePath, m_Config.DiskReserveSize);
 			if (Ec)
 			{
 				ZEN_WARN("unable to create GC reserve at '{}' with size {}, reason: '{}'",
@@ -2344,7 +2128,20 @@ GcScheduler::CollectGarbage(const GcClock::TimePoint& CacheExpireTime,
 		if (m_AreDiskWritesBlocked.load())
 		{
 			// We are low on disk, check if we can release our extra storage reserve, if we can't bail from doing GC
-			uint64_t ReleasedSpace = GcCtx.ClaimGCReserve();
+			auto ClaimDiskReserve = [&]() -> uint64_t {
+				if (!std::filesystem::is_regular_file(DiskReservePath))
+				{
+					return 0;
+				}
+				uint64_t ReclaimedSize = std::filesystem::file_size(DiskReservePath);
+				if (std::filesystem::remove(DiskReservePath))
+				{
+					return ReclaimedSize;
+				}
+				return 0;
+			};
+
+			uint64_t ReleasedSpace = ClaimDiskReserve();
 			if (ReleasedSpace == 0)
 			{
 				ZEN_WARN(
@@ -2364,23 +2161,8 @@ GcScheduler::CollectGarbage(const GcClock::TimePoint& CacheExpireTime,
 			GcStorageSize Diff;
 			switch (UseGCVersion)
 			{
-				case GcVersion::kV1:
-					ZEN_INFO(
-						"GCV1: Garbage collection STARTING, small objects gc {}, {} CAS. Cache cutoff time {}, project store cutoff time "
-						"{}",
-						GcCtx.CollectSmallObjects() ? "ENABLED"sv : "DISABLED"sv,
-						SkipCid ? "skip"sv : "include"sv,
-						CacheExpireTime,
-						ProjectStoreExpireTime);
-					Diff = m_GcManager.CollectGarbage(GcCtx);
-					if (SkipCid)
-					{
-						m_LastLightweightGCV2Result.reset();
-					}
-					else
-					{
-						m_LastFullGCV2Result.reset();
-					}
+				case GcVersion::kV1_Deprecated:
+					ZEN_WARN("GCV1: Depreated - no GC will be executed");
 					break;
 				case GcVersion::kV2:
 					{
@@ -2394,7 +2176,7 @@ GcScheduler::CollectGarbage(const GcClock::TimePoint& CacheExpireTime,
 													 .Verbose							= Verbose,
 													 .SingleThread						= SingleThreaded,
 													 .CompactBlockUsageThresholdPercent = CompactBlockUsageThresholdPercent,
-													 .DiskReservePath					= m_Config.RootDirectory / "reserve.gc",
+													 .DiskReservePath					= DiskReservePath,
 													 .AttachmentRangeMin				= AttachmentRangeMin,
 													 .AttachmentRangeMax				= AttachmentRangeMax,
 													 .StoreCacheAttachmentMetaData		= StoreCacheAttachmentMetaData,
@@ -2609,248 +2391,8 @@ GcScheduler::CollectGarbage(const GcClock::TimePoint& CacheExpireTime,
 
 #if ZEN_WITH_TESTS
 
-namespace gc::impl {
-	static CompressedBuffer Compress(IoBuffer Buffer)
-	{
-		return CompressedBuffer::Compress(SharedBuffer::MakeView(Buffer.GetData(), Buffer.GetSize()));
-	}
-}  // namespace gc::impl
-
-TEST_CASE("gc.basic")
-{
-	using namespace gc::impl;
-
-	ScopedTemporaryDirectory TempDir;
-
-	CidStoreConfiguration CasConfig;
-	CasConfig.RootDirectory = TempDir.Path() / "cas";
-
-	GcManager Gc;
-	CidStore  CidStore(Gc);
-
-	CidStore.Initialize(CasConfig);
-
-	IoBuffer Chunk			 = CreateRandomBlob(128);
-	auto	 CompressedChunk = Compress(Chunk);
-
-	const auto InsertResult = CidStore.AddChunk(CompressedChunk.GetCompressed().Flatten().AsIoBuffer(), CompressedChunk.DecodeRawHash());
-	CHECK(InsertResult.New);
-
-	GcContext GcCtx(GcClock::Now() - std::chrono::hours(24), GcClock::Now() - std::chrono::hours(24));
-	GcCtx.CollectSmallObjects(true);
-
-	CidStore.Flush();
-	Gc.CollectGarbage(GcCtx);
-
-	CHECK(!CidStore.ContainsChunk(CompressedChunk.DecodeRawHash()));
-}
-
-TEST_CASE("gc.full")
-{
-	using namespace gc::impl;
-
-	ScopedTemporaryDirectory TempDir;
-
-	CidStoreConfiguration CasConfig;
-	CasConfig.RootDirectory = TempDir.Path() / "cas";
-
-	GcManager				  Gc;
-	std::unique_ptr<CasStore> CasStore = CreateCasStore(Gc);
-
-	CasStore->Initialize(CasConfig);
-
-	uint64_t ChunkSizes[9]	= {128, 541, 1023, 781, 218, 37, 4, 997, 5};
-	IoBuffer Chunks[9]		= {CreateRandomBlob(ChunkSizes[0]),
-						   CreateRandomBlob(ChunkSizes[1]),
-						   CreateRandomBlob(ChunkSizes[2]),
-						   CreateRandomBlob(ChunkSizes[3]),
-						   CreateRandomBlob(ChunkSizes[4]),
-						   CreateRandomBlob(ChunkSizes[5]),
-						   CreateRandomBlob(ChunkSizes[6]),
-						   CreateRandomBlob(ChunkSizes[7]),
-						   CreateRandomBlob(ChunkSizes[8])};
-	IoHash	 ChunkHashes[9] = {
-		  IoHash::HashBuffer(Chunks[0].Data(), Chunks[0].Size()),
-		  IoHash::HashBuffer(Chunks[1].Data(), Chunks[1].Size()),
-		  IoHash::HashBuffer(Chunks[2].Data(), Chunks[2].Size()),
-		  IoHash::HashBuffer(Chunks[3].Data(), Chunks[3].Size()),
-		  IoHash::HashBuffer(Chunks[4].Data(), Chunks[4].Size()),
-		  IoHash::HashBuffer(Chunks[5].Data(), Chunks[5].Size()),
-		  IoHash::HashBuffer(Chunks[6].Data(), Chunks[6].Size()),
-		  IoHash::HashBuffer(Chunks[7].Data(), Chunks[7].Size()),
-		  IoHash::HashBuffer(Chunks[8].Data(), Chunks[8].Size()),
-	  };
-
-	CasStore->InsertChunk(Chunks[0], ChunkHashes[0]);
-	CasStore->InsertChunk(Chunks[1], ChunkHashes[1]);
-	CasStore->InsertChunk(Chunks[2], ChunkHashes[2]);
-	CasStore->InsertChunk(Chunks[3], ChunkHashes[3]);
-	CasStore->InsertChunk(Chunks[4], ChunkHashes[4]);
-	CasStore->InsertChunk(Chunks[5], ChunkHashes[5]);
-	CasStore->InsertChunk(Chunks[6], ChunkHashes[6]);
-	CasStore->InsertChunk(Chunks[7], ChunkHashes[7]);
-	CasStore->InsertChunk(Chunks[8], ChunkHashes[8]);
-
-	CidStoreSize InitialSize = CasStore->TotalSize();
-
-	// Keep first and last
-	{
-		GcContext GcCtx(GcClock::Now() - std::chrono::hours(24), GcClock::Now() - std::chrono::hours(24));
-		GcCtx.CollectSmallObjects(true);
-
-		std::vector<IoHash> KeepChunks;
-		KeepChunks.push_back(ChunkHashes[0]);
-		KeepChunks.push_back(ChunkHashes[8]);
-		GcCtx.AddRetainedCids(KeepChunks);
-
-		CasStore->Flush();
-		Gc.CollectGarbage(GcCtx);
-
-		CHECK(CasStore->ContainsChunk(ChunkHashes[0]));
-		CHECK(!CasStore->ContainsChunk(ChunkHashes[1]));
-		CHECK(!CasStore->ContainsChunk(ChunkHashes[2]));
-		CHECK(!CasStore->ContainsChunk(ChunkHashes[3]));
-		CHECK(!CasStore->ContainsChunk(ChunkHashes[4]));
-		CHECK(!CasStore->ContainsChunk(ChunkHashes[5]));
-		CHECK(!CasStore->ContainsChunk(ChunkHashes[6]));
-		CHECK(!CasStore->ContainsChunk(ChunkHashes[7]));
-		CHECK(CasStore->ContainsChunk(ChunkHashes[8]));
-
-		CHECK(ChunkHashes[0] == IoHash::HashBuffer(CasStore->FindChunk(ChunkHashes[0])));
-		CHECK(ChunkHashes[8] == IoHash::HashBuffer(CasStore->FindChunk(ChunkHashes[8])));
-	}
-
-	CasStore->InsertChunk(Chunks[1], ChunkHashes[1]);
-	CasStore->InsertChunk(Chunks[2], ChunkHashes[2]);
-	CasStore->InsertChunk(Chunks[3], ChunkHashes[3]);
-	CasStore->InsertChunk(Chunks[4], ChunkHashes[4]);
-	CasStore->InsertChunk(Chunks[5], ChunkHashes[5]);
-	CasStore->InsertChunk(Chunks[6], ChunkHashes[6]);
-	CasStore->InsertChunk(Chunks[7], ChunkHashes[7]);
-
-	// Keep last
-	{
-		GcContext GcCtx(GcClock::Now() - std::chrono::hours(24), GcClock::Now() - std::chrono::hours(24));
-		GcCtx.CollectSmallObjects(true);
-		std::vector<IoHash> KeepChunks;
-		KeepChunks.push_back(ChunkHashes[8]);
-		GcCtx.AddRetainedCids(KeepChunks);
-
-		CasStore->Flush();
-		Gc.CollectGarbage(GcCtx);
-
-		CHECK(!CasStore->ContainsChunk(ChunkHashes[0]));
-		CHECK(!CasStore->ContainsChunk(ChunkHashes[1]));
-		CHECK(!CasStore->ContainsChunk(ChunkHashes[2]));
-		CHECK(!CasStore->ContainsChunk(ChunkHashes[3]));
-		CHECK(!CasStore->ContainsChunk(ChunkHashes[4]));
-		CHECK(!CasStore->ContainsChunk(ChunkHashes[5]));
-		CHECK(!CasStore->ContainsChunk(ChunkHashes[6]));
-		CHECK(!CasStore->ContainsChunk(ChunkHashes[7]));
-		CHECK(CasStore->ContainsChunk(ChunkHashes[8]));
-
-		CHECK(ChunkHashes[8] == IoHash::HashBuffer(CasStore->FindChunk(ChunkHashes[8])));
-
-		CasStore->InsertChunk(Chunks[1], ChunkHashes[1]);
-		CasStore->InsertChunk(Chunks[2], ChunkHashes[2]);
-		CasStore->InsertChunk(Chunks[3], ChunkHashes[3]);
-		CasStore->InsertChunk(Chunks[4], ChunkHashes[4]);
-		CasStore->InsertChunk(Chunks[5], ChunkHashes[5]);
-		CasStore->InsertChunk(Chunks[6], ChunkHashes[6]);
-		CasStore->InsertChunk(Chunks[7], ChunkHashes[7]);
-	}
-
-	// Keep mixed
-	{
-		GcContext GcCtx(GcClock::Now() - std::chrono::hours(24), GcClock::Now() - std::chrono::hours(24));
-		GcCtx.CollectSmallObjects(true);
-		std::vector<IoHash> KeepChunks;
-		KeepChunks.push_back(ChunkHashes[1]);
-		KeepChunks.push_back(ChunkHashes[4]);
-		KeepChunks.push_back(ChunkHashes[7]);
-		GcCtx.AddRetainedCids(KeepChunks);
-
-		CasStore->Flush();
-		Gc.CollectGarbage(GcCtx);
-
-		CHECK(!CasStore->ContainsChunk(ChunkHashes[0]));
-		CHECK(CasStore->ContainsChunk(ChunkHashes[1]));
-		CHECK(!CasStore->ContainsChunk(ChunkHashes[2]));
-		CHECK(!CasStore->ContainsChunk(ChunkHashes[3]));
-		CHECK(CasStore->ContainsChunk(ChunkHashes[4]));
-		CHECK(!CasStore->ContainsChunk(ChunkHashes[5]));
-		CHECK(!CasStore->ContainsChunk(ChunkHashes[6]));
-		CHECK(CasStore->ContainsChunk(ChunkHashes[7]));
-		CHECK(!CasStore->ContainsChunk(ChunkHashes[8]));
-
-		CHECK(ChunkHashes[1] == IoHash::HashBuffer(CasStore->FindChunk(ChunkHashes[1])));
-		CHECK(ChunkHashes[4] == IoHash::HashBuffer(CasStore->FindChunk(ChunkHashes[4])));
-		CHECK(ChunkHashes[7] == IoHash::HashBuffer(CasStore->FindChunk(ChunkHashes[7])));
-
-		CasStore->InsertChunk(Chunks[0], ChunkHashes[0]);
-		CasStore->InsertChunk(Chunks[2], ChunkHashes[2]);
-		CasStore->InsertChunk(Chunks[3], ChunkHashes[3]);
-		CasStore->InsertChunk(Chunks[5], ChunkHashes[5]);
-		CasStore->InsertChunk(Chunks[6], ChunkHashes[6]);
-		CasStore->InsertChunk(Chunks[8], ChunkHashes[8]);
-	}
-
-	// Keep multiple at end
-	{
-		GcContext GcCtx(GcClock::Now() - std::chrono::hours(24), GcClock::Now() - std::chrono::hours(24));
-		GcCtx.CollectSmallObjects(true);
-		std::vector<IoHash> KeepChunks;
-		KeepChunks.push_back(ChunkHashes[6]);
-		KeepChunks.push_back(ChunkHashes[7]);
-		KeepChunks.push_back(ChunkHashes[8]);
-		GcCtx.AddRetainedCids(KeepChunks);
-
-		CasStore->Flush();
-		Gc.CollectGarbage(GcCtx);
-
-		CHECK(!CasStore->ContainsChunk(ChunkHashes[0]));
-		CHECK(!CasStore->ContainsChunk(ChunkHashes[1]));
-		CHECK(!CasStore->ContainsChunk(ChunkHashes[2]));
-		CHECK(!CasStore->ContainsChunk(ChunkHashes[3]));
-		CHECK(!CasStore->ContainsChunk(ChunkHashes[4]));
-		CHECK(!CasStore->ContainsChunk(ChunkHashes[5]));
-		CHECK(CasStore->ContainsChunk(ChunkHashes[6]));
-		CHECK(CasStore->ContainsChunk(ChunkHashes[7]));
-		CHECK(CasStore->ContainsChunk(ChunkHashes[8]));
-
-		CHECK(ChunkHashes[6] == IoHash::HashBuffer(CasStore->FindChunk(ChunkHashes[6])));
-		CHECK(ChunkHashes[7] == IoHash::HashBuffer(CasStore->FindChunk(ChunkHashes[7])));
-		CHECK(ChunkHashes[8] == IoHash::HashBuffer(CasStore->FindChunk(ChunkHashes[8])));
-
-		CasStore->InsertChunk(Chunks[0], ChunkHashes[0]);
-		CasStore->InsertChunk(Chunks[1], ChunkHashes[1]);
-		CasStore->InsertChunk(Chunks[2], ChunkHashes[2]);
-		CasStore->InsertChunk(Chunks[3], ChunkHashes[3]);
-		CasStore->InsertChunk(Chunks[4], ChunkHashes[4]);
-		CasStore->InsertChunk(Chunks[5], ChunkHashes[5]);
-	}
-
-	// Verify that we nicely appended blocks even after all GC operations
-	CHECK(ChunkHashes[0] == IoHash::HashBuffer(CasStore->FindChunk(ChunkHashes[0])));
-	CHECK(ChunkHashes[1] == IoHash::HashBuffer(CasStore->FindChunk(ChunkHashes[1])));
-	CHECK(ChunkHashes[2] == IoHash::HashBuffer(CasStore->FindChunk(ChunkHashes[2])));
-	CHECK(ChunkHashes[3] == IoHash::HashBuffer(CasStore->FindChunk(ChunkHashes[3])));
-	CHECK(ChunkHashes[4] == IoHash::HashBuffer(CasStore->FindChunk(ChunkHashes[4])));
-	CHECK(ChunkHashes[5] == IoHash::HashBuffer(CasStore->FindChunk(ChunkHashes[5])));
-	CHECK(ChunkHashes[6] == IoHash::HashBuffer(CasStore->FindChunk(ChunkHashes[6])));
-	CHECK(ChunkHashes[7] == IoHash::HashBuffer(CasStore->FindChunk(ChunkHashes[7])));
-	CHECK(ChunkHashes[8] == IoHash::HashBuffer(CasStore->FindChunk(ChunkHashes[8])));
-
-	auto FinalSize = CasStore->TotalSize();
-
-	CHECK_LE(InitialSize.TinySize, FinalSize.TinySize);
-	CHECK_GE(InitialSize.TinySize + (1u << 28), FinalSize.TinySize);
-}
-
 TEST_CASE("gc.diskusagewindow")
 {
-	using namespace gc::impl;
-
 	DiskUsageWindow Stats;
 	Stats.Append({.SampleTime = 0, .DiskUsage = 0});	// 0	0
 	Stats.Append({.SampleTime = 10, .DiskUsage = 10});	// 1	10
@@ -3008,35 +2550,6 @@ TEST_CASE("gc.diskusagewindow")
 	}
 }
 
-TEST_CASE("scrub.basic")
-{
-	using namespace gc::impl;
-
-	ScopedTemporaryDirectory TempDir;
-
-	CidStoreConfiguration CasConfig;
-	CasConfig.RootDirectory = TempDir.Path() / "cas";
-
-	GcManager Gc;
-	CidStore  CidStore(Gc);
-
-	CidStore.Initialize(CasConfig);
-
-	IoBuffer Chunk			 = CreateRandomBlob(128);
-	auto	 CompressedChunk = Compress(Chunk);
-
-	const auto InsertResult = CidStore.AddChunk(CompressedChunk.GetCompressed().Flatten().AsIoBuffer(), CompressedChunk.DecodeRawHash());
-	CHECK(InsertResult.New);
-
-	GcContext GcCtx(GcClock::Now() - std::chrono::hours(24), GcClock::Now() - std::chrono::hours(24));
-	GcCtx.CollectSmallObjects(true);
-
-	CidStore.Flush();
-	Gc.CollectGarbage(GcCtx);
-
-	CHECK(!CidStore.ContainsChunk(CompressedChunk.DecodeRawHash()));
-}
-
 TEST_CASE("gc.keepunusedreferences")
 {
 	// Order is important, this is the order the hashes would be sorted by FilterReferences