Merge remote-tracking branch 'origin/main' into de/zen-service-command

1 files changed, 48 insertions, 52 deletions

diff --git a/src/zenserver/zenserver.cpp b/src/zenserver/zenserver.cpp
index 27ec4c690..5cab54acc 100644
--- a/src/zenserver/zenserver.cpp
+++ b/src/zenserver/zenserver.cpp
@@ -239,18 +239,18 @@ ZenServer::Initialize(const ZenServerOptions& ServerOptions, ZenServerState::Zen
 	CidStoreConfiguration Config;
 	Config.RootDirectory = m_DataRoot / "cas";
 
-	m_CidStore = std::make_unique<CidStore>(m_GcManager);
-	m_CidStore->Initialize(Config);
+	m_CidStores.insert_or_assign({}, std::make_unique<CidStore>(m_GcManager));
+	m_CidStores.at({})->Initialize(Config);
 
 	ZEN_INFO("instantiating project service");
 
-	m_ProjectStore = new ProjectStore(*m_CidStore,
+	m_ProjectStore = new ProjectStore([this](std::string_view) -> CidStore& { return *m_CidStores.at({}).get(); },
 									  m_DataRoot / "projects",
 									  m_GcManager,
 									  *m_JobQueue,
 									  *m_OpenProcessCache,
 									  ProjectStore::Configuration{});
-	m_HttpProjectService.reset(new HttpProjectService{*m_CidStore, m_ProjectStore, m_StatusService, m_StatsService, *m_AuthMgr});
+	m_HttpProjectService.reset(new HttpProjectService(m_ProjectStore, m_StatusService, m_StatsService, *m_AuthMgr));
 
 	if (ServerOptions.WorksSpacesConfig.Enabled)
 	{
@@ -265,10 +265,15 @@ ZenServer::Initialize(const ZenServerOptions& ServerOptions, ZenServerState::Zen
 
 	if (ServerOptions.BuildStoreConfig.Enabled)
 	{
+		CidStoreConfiguration BuildCidConfig;
+		BuildCidConfig.RootDirectory = m_DataRoot / "builds_cas";
+		m_BuildCidStore				 = std::make_unique<CidStore>(m_GcManager);
+		m_BuildCidStore->Initialize(BuildCidConfig);
+
 		BuildStoreConfig BuildsCfg;
 		BuildsCfg.RootDirectory		= m_DataRoot / "builds";
 		BuildsCfg.MaxDiskSpaceLimit = ServerOptions.BuildStoreConfig.MaxDiskSpaceLimit;
-		m_BuildStore				= std::make_unique<BuildStore>(std::move(BuildsCfg), m_GcManager);
+		m_BuildStore				= std::make_unique<BuildStore>(std::move(BuildsCfg), m_GcManager, *m_BuildCidStore);
 	}
 
 	if (ServerOptions.StructuredCacheConfig.Enabled)
@@ -357,17 +362,15 @@ ZenServer::Initialize(const ZenServerOptions& ServerOptions, ZenServerState::Zen
 	m_GcScheduler.Initialize(GcConfig);
 
 	// Create and register admin interface last to make sure all is properly initialized
-	m_AdminService =
-		std::make_unique<HttpAdminService>(m_GcScheduler,
-										   *m_JobQueue,
-										   m_CacheStore.Get(),
-										   m_CidStore.get(),
-										   m_ProjectStore,
-										   m_BuildStore.get(),
-										   HttpAdminService::LogPaths{.AbsLogPath	= ServerOptions.AbsLogFile,
-																	  .HttpLogPath	= ServerOptions.DataDir / "logs" / "http.log",
-																	  .CacheLogPath = ServerOptions.DataDir / "logs" / "z$.log"},
-										   ServerOptions);
+	m_AdminService = std::make_unique<HttpAdminService>(
+		m_GcScheduler,
+		*m_JobQueue,
+		m_CacheStore.Get(),
+		[this]() { Flush(); },
+		HttpAdminService::LogPaths{.AbsLogPath	 = ServerOptions.AbsLogFile,
+								   .HttpLogPath	 = ServerOptions.DataDir / "logs" / "http.log",
+								   .CacheLogPath = ServerOptions.DataDir / "logs" / "z$.log"},
+		ServerOptions);
 	m_Http->RegisterService(*m_AdminService);
 
 	return EffectiveBasePort;
@@ -419,10 +422,10 @@ ZenServer::InitializeState(const ZenServerOptions& ServerOptions)
 			if (CbValidateError ValidationResult = ValidateCompactBinary(Manifest, CbValidateMode::All);
 				ValidationResult != CbValidateError::None)
 			{
-				ZEN_WARN("Manifest validation failed: {}, state will be wiped", uint32_t(ValidationResult));
+				ZEN_WARN("Manifest validation failed: {}, state will be wiped", zen::ToString(ValidationResult));
 
 				WipeState  = true;
-				WipeReason = fmt::format("Validation of manifest at '{}' failed: {}", ManifestPath, uint32_t(ValidationResult));
+				WipeReason = fmt::format("Validation of manifest at '{}' failed: {}", ManifestPath, zen::ToString(ValidationResult));
 			}
 			else
 			{
@@ -547,6 +550,7 @@ ZenServer::InitializeStructuredCache(const ZenServerOptions& ServerOptions)
 	Config.AllowAutomaticCreationOfNamespaces = true;
 	Config.Logging							  = {.EnableWriteLog  = ServerOptions.StructuredCacheConfig.WriteLogEnabled,
 												 .EnableAccessLog = ServerOptions.StructuredCacheConfig.AccessLogEnabled};
+
 	for (const auto& It : ServerOptions.StructuredCacheConfig.PerBucketConfigs)
 	{
 		const std::string&					   BucketName	   = It.first;
@@ -554,7 +558,8 @@ ZenServer::InitializeStructuredCache(const ZenServerOptions& ServerOptions)
 		ZenCacheDiskLayer::BucketConfiguration BucketConfig	   = {.MaxBlockSize			 = ZenBucketConfig.MaxBlockSize,
 																  .PayloadAlignment		 = ZenBucketConfig.PayloadAlignment,
 																  .MemCacheSizeThreshold = ZenBucketConfig.MemCacheSizeThreshold,
-																  .LargeObjectThreshold	 = ZenBucketConfig.LargeObjectThreshold};
+																  .LargeObjectThreshold	 = ZenBucketConfig.LargeObjectThreshold,
+																  .LimitOverwrites		 = ZenBucketConfig.LimitOverwrites};
 		Config.NamespaceConfig.DiskLayerConfig.BucketConfigMap.insert_or_assign(BucketName, BucketConfig);
 	}
 	Config.NamespaceConfig.DiskLayerConfig.BucketConfig.MaxBlockSize = ServerOptions.StructuredCacheConfig.BucketConfig.MaxBlockSize,
@@ -564,6 +569,7 @@ ZenServer::InitializeStructuredCache(const ZenServerOptions& ServerOptions)
 		ServerOptions.StructuredCacheConfig.BucketConfig.MemCacheSizeThreshold,
 	Config.NamespaceConfig.DiskLayerConfig.BucketConfig.LargeObjectThreshold =
 		ServerOptions.StructuredCacheConfig.BucketConfig.LargeObjectThreshold,
+	Config.NamespaceConfig.DiskLayerConfig.BucketConfig.LimitOverwrites = ServerOptions.StructuredCacheConfig.BucketConfig.LimitOverwrites;
 	Config.NamespaceConfig.DiskLayerConfig.MemCacheTargetFootprintBytes = ServerOptions.StructuredCacheConfig.MemTargetFootprintBytes;
 	Config.NamespaceConfig.DiskLayerConfig.MemCacheTrimIntervalSeconds	= ServerOptions.StructuredCacheConfig.MemTrimIntervalSeconds;
 	Config.NamespaceConfig.DiskLayerConfig.MemCacheMaxAgeSeconds		= ServerOptions.StructuredCacheConfig.MemMaxAgeSeconds;
@@ -587,7 +593,7 @@ ZenServer::InitializeStructuredCache(const ZenServerOptions& ServerOptions)
 		UpstreamOptions.ThreadCount = static_cast<uint32_t>(UpstreamConfig.UpstreamThreadCount);
 	}
 
-	m_UpstreamCache	  = CreateUpstreamCache(UpstreamOptions, *m_CacheStore, *m_CidStore);
+	m_UpstreamCache	  = CreateUpstreamCache(UpstreamOptions, *m_CacheStore);
 	m_UpstreamService = std::make_unique<HttpUpstreamService>(*m_UpstreamCache, *m_AuthMgr);
 	m_UpstreamCache->Initialize();
 
@@ -651,19 +657,24 @@ ZenServer::InitializeStructuredCache(const ZenServerOptions& ServerOptions)
 		}
 	}
 
-	m_StructuredCacheService = std::make_unique<HttpStructuredCacheService>(*m_CacheStore,
-																			*m_CidStore,
-																			m_StatsService,
-																			m_StatusService,
-																			*m_UpstreamCache,
-																			m_GcManager.GetDiskWriteBlocker(),
-																			*m_OpenProcessCache);
+	m_StructuredCacheService = std::make_unique<HttpStructuredCacheService>(
+		*m_CacheStore,
+		[this](std::string_view) -> CidStore& { return *m_CidStores.at({}).get(); },
+		m_StatsService,
+		m_StatusService,
+		*m_UpstreamCache,
+		m_GcManager.GetDiskWriteBlocker(),
+		*m_OpenProcessCache);
 
 	m_Http->RegisterService(*m_StructuredCacheService);
 	m_Http->RegisterService(*m_UpstreamService);
 
 	m_StatsReporter.AddProvider(m_CacheStore.Get());
-	m_StatsReporter.AddProvider(m_CidStore.get());
+	for (const auto& It : m_CidStores)
+	{
+		m_StatsReporter.AddProvider(It.second.get());
+	}
+	m_StatsReporter.AddProvider(m_BuildCidStore.get());
 }
 
 void
@@ -836,6 +847,7 @@ ZenServer::Cleanup()
 
 		m_BuildStoreService.reset();
 		m_BuildStore = {};
+		m_BuildCidStore.reset();
 
 		m_StructuredCacheService.reset();
 		m_UpstreamService.reset();
@@ -847,7 +859,7 @@ ZenServer::Cleanup()
 		m_Workspaces.reset();
 		m_HttpProjectService.reset();
 		m_ProjectStore = {};
-		m_CidStore.reset();
+		m_CidStores.clear();
 		m_AuthService.reset();
 		m_AuthMgr.reset();
 		m_Http = {};
@@ -1028,37 +1040,21 @@ ZenServer::CheckOwnerPid()
 }
 
 void
-ZenServer::ScrubStorage()
-{
-	Stopwatch Timer;
-	ZEN_INFO("Storage validation STARTING");
-
-	WorkerThreadPool ThreadPool{1, "Scrub"};
-	ScrubContext	 Ctx{ThreadPool};
-	m_CidStore->ScrubStorage(Ctx);
-	m_ProjectStore->ScrubStorage(Ctx);
-	m_StructuredCacheService->ScrubStorage(Ctx);
-
-	const uint64_t ElapsedTimeMs = Timer.GetElapsedTimeMs();
-
-	ZEN_INFO("Storage validation DONE in {}, ({} in {} chunks - {})",
-			 NiceTimeSpanMs(ElapsedTimeMs),
-			 NiceBytes(Ctx.ScrubbedBytes()),
-			 Ctx.ScrubbedChunks(),
-			 NiceByteRate(Ctx.ScrubbedBytes(), ElapsedTimeMs));
-}
-
-void
 ZenServer::Flush()
 {
-	if (m_CidStore)
-		m_CidStore->Flush();
+	for (auto& It : m_CidStores)
+	{
+		It.second->Flush();
+	}
 
 	if (m_StructuredCacheService)
 		m_StructuredCacheService->Flush();
 
 	if (m_ProjectStore)
 		m_ProjectStore->Flush();
+
+	if (m_BuildCidStore)
+		m_BuildCidStore->Flush();
 }
 
 void