Merge branch 'main' into zs/ui-show-cook-artifacts

9 files changed, 656 insertions, 1 deletions

diff --git a/src/zenserver/admin/admin.cpp b/src/zenserver/admin/admin.cpp
index 2888f5450..0da6e31ad 100644
--- a/src/zenserver/admin/admin.cpp
+++ b/src/zenserver/admin/admin.cpp
@@ -20,6 +20,7 @@
 #include <zenstore/cidstore.h>
 #include <zenstore/gc.h>
 
+#include <zenstore/buildstore/buildstore.h>
 #include <zenstore/cache/structuredcachestore.h>
 #include <zenutil/workerpools.h>
 #include "config.h"
@@ -105,6 +106,7 @@ HttpAdminService::HttpAdminService(GcScheduler&			   Scheduler,
 								   ZenCacheStore*		   CacheStore,
 								   CidStore*			   CidStore,
 								   ProjectStore*		   ProjectStore,
+								   BuildStore*			   BuildStore,
 								   const LogPaths&		   LogPaths,
 								   const ZenServerOptions& ServerOptions)
 : m_GcScheduler(Scheduler)
@@ -112,6 +114,7 @@ HttpAdminService::HttpAdminService(GcScheduler&			   Scheduler,
 , m_CacheStore(CacheStore)
 , m_CidStore(CidStore)
 , m_ProjectStore(ProjectStore)
+, m_BuildStore(BuildStore)
 , m_LogPaths(LogPaths)
 , m_ServerOptions(ServerOptions)
 {
@@ -306,6 +309,7 @@ HttpAdminService::HttpAdminService(GcScheduler&			   Scheduler,
 				Response << "Interval" << ToTimeSpan(State.Config.Interval);
 				Response << "MaxCacheDuration" << ToTimeSpan(State.Config.MaxCacheDuration);
 				Response << "MaxProjectStoreDuration" << ToTimeSpan(State.Config.MaxProjectStoreDuration);
+				Response << "MaxBuildStoreDuration" << ToTimeSpan(State.Config.MaxBuildStoreDuration);
 				Response << "CollectSmallObjects" << State.Config.CollectSmallObjects;
 				Response << "Enabled" << State.Config.Enabled;
 				Response << "DiskReserveSize" << NiceBytes(State.Config.DiskReserveSize);
@@ -401,6 +405,14 @@ HttpAdminService::HttpAdminService(GcScheduler&			   Scheduler,
 				}
 			}
 
+			if (auto Param = Params.GetValue("maxbuildstoreduration"); Param.empty() == false)
+			{
+				if (auto Value = ParseInt<uint64_t>(Param))
+				{
+					GcParams.MaxBuildStoreDuration = std::chrono::seconds(Value.value());
+				}
+			}
+
 			if (auto Param = Params.GetValue("disksizesoftlimit"); Param.empty() == false)
 			{
 				if (auto Value = ParseInt<uint64_t>(Param))
@@ -782,6 +794,10 @@ HttpAdminService::HttpAdminService(GcScheduler&			   Scheduler,
 			{
 				m_ProjectStore->Flush();
 			}
+			if (m_BuildStore)
+			{
+				m_BuildStore->Flush();
+			}
 			HttpReq.WriteResponse(HttpResponseCode::OK);
 		},
 		HttpVerb::kPost);
diff --git a/src/zenserver/admin/admin.h b/src/zenserver/admin/admin.h
index 563c4f536..e7821dead 100644
--- a/src/zenserver/admin/admin.h
+++ b/src/zenserver/admin/admin.h
@@ -12,6 +12,7 @@ class JobQueue;
 class ZenCacheStore;
 class CidStore;
 class ProjectStore;
+class BuildStore;
 struct ZenServerOptions;
 
 class HttpAdminService : public zen::HttpService
@@ -28,6 +29,7 @@ public:
 					 ZenCacheStore*			 CacheStore,
 					 CidStore*				 CidStore,
 					 ProjectStore*			 ProjectStore,
+					 BuildStore*			 BuildStore,
 					 const LogPaths&		 LogPaths,
 					 const ZenServerOptions& ServerOptions);
 	~HttpAdminService();
@@ -42,6 +44,7 @@ private:
 	ZenCacheStore*			m_CacheStore;
 	CidStore*				m_CidStore;
 	ProjectStore*			m_ProjectStore;
+	BuildStore*				m_BuildStore;
 	LogPaths				m_LogPaths;
 	const ZenServerOptions& m_ServerOptions;
 };
diff --git a/src/zenserver/buildstore/httpbuildstore.cpp b/src/zenserver/buildstore/httpbuildstore.cpp
new file mode 100644
index 000000000..06bfea423
--- /dev/null
+++ b/src/zenserver/buildstore/httpbuildstore.cpp
@@ -0,0 +1,526 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "httpbuildstore.h"
+
+#include <zencore/compactbinarybuilder.h>
+#include <zencore/compactbinaryvalidation.h>
+#include <zencore/compactbinaryvalue.h>
+#include <zencore/fmtutils.h>
+#include <zencore/logging.h>
+#include <zencore/trace.h>
+#include <zenhttp/packageformat.h>
+#include <zenstore/buildstore/buildstore.h>
+#include <zenutil/workerpools.h>
+
+#include <numeric>
+
+namespace zen {
+using namespace std::literals;
+
+ZEN_DEFINE_LOG_CATEGORY_STATIC(LogBuilds, "builds"sv);
+
+HttpBuildStoreService::HttpBuildStoreService(HttpStatsService& StatsService, BuildStore& Store)
+: m_Log(logging::Get("builds"))
+, m_StatsService(StatsService)
+, m_BuildStore(Store)
+{
+	Initialize();
+}
+
+HttpBuildStoreService::~HttpBuildStoreService()
+{
+}
+
+const char*
+HttpBuildStoreService::BaseUri() const
+{
+	return "/builds/";
+}
+
+void
+HttpBuildStoreService::Initialize()
+{
+	ZEN_LOG_INFO(LogBuilds, "Initializing Builds Service");
+
+	m_StatsService.RegisterHandler("builds", *this);
+
+	m_Router.AddPattern("namespace", "([[:alnum:]-_.]+)");
+	m_Router.AddPattern("bucket", "([[:alnum:]-_.]+)");
+	m_Router.AddPattern("buildid", "([[:xdigit:]]{24})");
+	m_Router.AddPattern("hash", "([[:xdigit:]]{40})");
+
+	m_Router.RegisterRoute(
+		"{namespace}/{bucket}/{buildid}/blobs/{hash}",
+		[this](HttpRouterRequest& Req) { PutBlobRequest(Req); },
+		HttpVerb::kPut);
+
+	m_Router.RegisterRoute(
+		"{namespace}/{bucket}/{buildid}/blobs/{hash}",
+		[this](HttpRouterRequest& Req) { GetBlobRequest(Req); },
+		HttpVerb::kGet);
+
+	m_Router.RegisterRoute(
+		"{namespace}/{bucket}/{buildid}/blobs/putBlobMetadata",
+		[this](HttpRouterRequest& Req) { PutMetadataRequest(Req); },
+		HttpVerb::kPost);
+
+	m_Router.RegisterRoute(
+		"{namespace}/{bucket}/{buildid}/blobs/getBlobMetadata",
+		[this](HttpRouterRequest& Req) { GetMetadatasRequest(Req); },
+		HttpVerb::kPost);
+
+	m_Router.RegisterRoute(
+		"{namespace}/{bucket}/{buildid}/blobs/exists",
+		[this](HttpRouterRequest& Req) { BlobsExistsRequest(Req); },
+		HttpVerb::kPost);
+}
+
+void
+HttpBuildStoreService::HandleRequest(zen::HttpServerRequest& Request)
+{
+	ZEN_TRACE_CPU("HttpBuildStoreService::HandleRequest");
+	metrics::OperationTiming::Scope $(m_HttpRequests);
+
+	m_BuildStoreStats.RequestCount++;
+	if (m_Router.HandleRequest(Request) == false)
+	{
+		ZEN_LOG_WARN(LogBuilds, "No route found for {0}", Request.RelativeUri());
+		return Request.WriteResponse(HttpResponseCode::NotFound, HttpContentType::kText, "Not found"sv);
+	}
+}
+
+void
+HttpBuildStoreService::PutBlobRequest(HttpRouterRequest& Req)
+{
+	ZEN_TRACE_CPU("HttpBuildStoreService::PutBlobRequest");
+	HttpServerRequest&	   ServerRequest = Req.ServerRequest();
+	const std::string_view Namespace	 = Req.GetCapture(1);
+	const std::string_view Bucket		 = Req.GetCapture(2);
+	const std::string_view BuildId		 = Req.GetCapture(3);
+	const std::string_view Hash			 = Req.GetCapture(4);
+	ZEN_UNUSED(Namespace, Bucket, BuildId);
+	IoHash BlobHash;
+	if (!IoHash::TryParse(Hash, BlobHash))
+	{
+		m_BuildStoreStats.BadRequestCount++;
+		return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+										   HttpContentType::kText,
+										   fmt::format("Invalid blob hash '{}'", Hash));
+	}
+	m_BuildStoreStats.BlobWriteCount++;
+	IoBuffer Payload = ServerRequest.ReadPayload();
+	if (!Payload)
+	{
+		m_BuildStoreStats.BadRequestCount++;
+		return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+										   HttpContentType::kText,
+										   fmt::format("Payload blob {} is empty", Hash));
+	}
+	if (Payload.GetContentType() != HttpContentType::kCompressedBinary)
+	{
+		m_BuildStoreStats.BadRequestCount++;
+		return ServerRequest.WriteResponse(
+			HttpResponseCode::BadRequest,
+			HttpContentType::kText,
+			fmt::format("Payload blob {} content type {} is invalid", Hash, ToString(Payload.GetContentType())));
+	}
+	m_BuildStore.PutBlob(BlobHash, ServerRequest.ReadPayload());
+	//	ZEN_INFO("Stored blob {}. Size: {}", BlobHash, ServerRequest.ReadPayload().GetSize());
+	return ServerRequest.WriteResponse(HttpResponseCode::OK);
+}
+
+void
+HttpBuildStoreService::GetBlobRequest(HttpRouterRequest& Req)
+{
+	ZEN_TRACE_CPU("HttpBuildStoreService::GetBlobRequest");
+	HttpServerRequest& ServerRequest = Req.ServerRequest();
+	std::string_view   Namespace	 = Req.GetCapture(1);
+	std::string_view   Bucket		 = Req.GetCapture(2);
+	std::string_view   BuildId		 = Req.GetCapture(3);
+	std::string_view   Hash			 = Req.GetCapture(4);
+	ZEN_UNUSED(Namespace, Bucket, BuildId);
+	IoHash BlobHash;
+	if (!IoHash::TryParse(Hash, BlobHash))
+	{
+		m_BuildStoreStats.BadRequestCount++;
+		return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+										   HttpContentType::kText,
+										   fmt::format("Invalid blob hash '{}'", Hash));
+	}
+	zen::HttpRanges Ranges;
+	bool			HasRange = ServerRequest.TryGetRanges(Ranges);
+	if (Ranges.size() > 1)
+	{
+		// Only a single range is supported
+		return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+										   HttpContentType::kText,
+										   "Multiple ranges in blob request is not supported");
+	}
+
+	m_BuildStoreStats.BlobReadCount++;
+	IoBuffer Blob = m_BuildStore.GetBlob(BlobHash);
+	if (!Blob)
+	{
+		return ServerRequest.WriteResponse(HttpResponseCode::NotFound,
+										   HttpContentType::kText,
+										   fmt::format("Blob with hash '{}' could not be found", Hash));
+	}
+	//	ZEN_INFO("Fetched blob {}. Size: {}", BlobHash, Blob.GetSize());
+	m_BuildStoreStats.BlobHitCount++;
+	if (HasRange)
+	{
+		const HttpRange& Range		 = Ranges.front();
+		const uint64_t	 BlobSize	 = Blob.GetSize();
+		const uint64_t	 MaxBlobSize = Range.Start < BlobSize ? Range.Start - BlobSize : 0;
+		const uint64_t	 RangeSize	 = Min(Range.End - Range.Start + 1, MaxBlobSize);
+		if (Range.Start + RangeSize >= BlobSize)
+		{
+			return ServerRequest.WriteResponse(HttpResponseCode::NoContent);
+		}
+		Blob = IoBuffer(Blob, Range.Start, RangeSize);
+		return ServerRequest.WriteResponse(HttpResponseCode::OK, ZenContentType::kBinary, Blob);
+	}
+	else
+	{
+		return ServerRequest.WriteResponse(HttpResponseCode::OK, Blob.GetContentType(), Blob);
+	}
+}
+
+void
+HttpBuildStoreService::PutMetadataRequest(HttpRouterRequest& Req)
+{
+	ZEN_TRACE_CPU("HttpBuildStoreService::PutMetadataRequest");
+	HttpServerRequest& ServerRequest = Req.ServerRequest();
+	std::string_view   Namespace	 = Req.GetCapture(1);
+	std::string_view   Bucket		 = Req.GetCapture(2);
+	std::string_view   BuildId		 = Req.GetCapture(3);
+
+	IoBuffer MetaPayload = ServerRequest.ReadPayload();
+	if (MetaPayload.GetContentType() != ZenContentType::kCbPackage)
+	{
+		throw std::runtime_error(fmt::format("PutMetadataRequest payload has unexpected payload type '{}', expected '{}'",
+											 ToString(MetaPayload.GetContentType()),
+											 ToString(ZenContentType::kCbPackage)));
+	}
+	CbPackage Message = ParsePackageMessage(MetaPayload);
+
+	CbObjectView MessageObject = Message.GetObject();
+	if (!MessageObject)
+	{
+		throw std::runtime_error("PutMetadataRequest payload object is missing");
+	}
+	CbArrayView BlobsArray	  = MessageObject["blobHashes"sv].AsArrayView();
+	CbArrayView MetadataArray = MessageObject["metadatas"sv].AsArrayView();
+
+	const uint64_t BlobCount = BlobsArray.Num();
+	if (BlobCount == 0)
+	{
+		throw std::runtime_error("PutMetadataRequest blobs array is empty");
+	}
+	if (BlobCount != MetadataArray.Num())
+	{
+		throw std::runtime_error(
+			fmt::format("PutMetadataRequest metadata array size {} does not match blobs array size {}", MetadataArray.Num(), BlobCount));
+	}
+
+	std::vector<IoHash>	  BlobHashes;
+	std::vector<IoBuffer> MetadataPayloads;
+
+	BlobHashes.reserve(BlobCount);
+	MetadataPayloads.reserve(BlobCount);
+
+	auto BlobsArrayIt	 = begin(BlobsArray);
+	auto MetadataArrayIt = begin(MetadataArray);
+	while (BlobsArrayIt != end(BlobsArray))
+	{
+		const IoHash BlobHash	  = (*BlobsArrayIt).AsHash();
+		const IoHash MetadataHash = (*MetadataArrayIt).AsAttachment();
+
+		const CbAttachment* Attachment = Message.FindAttachment(MetadataHash);
+		if (Attachment == nullptr)
+		{
+			throw std::runtime_error(fmt::format("Blob metadata attachment {} is missing", MetadataHash));
+		}
+		BlobHashes.push_back(BlobHash);
+		if (Attachment->IsObject())
+		{
+			MetadataPayloads.push_back(Attachment->AsObject().GetBuffer().MakeOwned().AsIoBuffer());
+			MetadataPayloads.back().SetContentType(ZenContentType::kCbObject);
+		}
+		else if (Attachment->IsCompressedBinary())
+		{
+			MetadataPayloads.push_back(Attachment->AsCompressedBinary().GetCompressed().Flatten().AsIoBuffer());
+			MetadataPayloads.back().SetContentType(ZenContentType::kCompressedBinary);
+		}
+		else
+		{
+			ZEN_ASSERT(Attachment->IsBinary());
+			MetadataPayloads.push_back(Attachment->AsBinary().AsIoBuffer());
+			MetadataPayloads.back().SetContentType(ZenContentType::kBinary);
+		}
+
+		BlobsArrayIt++;
+		MetadataArrayIt++;
+	}
+	m_BuildStore.PutMetadatas(BlobHashes, MetadataPayloads);
+	return ServerRequest.WriteResponse(HttpResponseCode::OK);
+}
+
+void
+HttpBuildStoreService::GetMetadatasRequest(HttpRouterRequest& Req)
+{
+	ZEN_TRACE_CPU("HttpBuildStoreService::GetMetadatasRequest");
+	HttpServerRequest& ServerRequest = Req.ServerRequest();
+	std::string_view   Namespace	 = Req.GetCapture(1);
+	std::string_view   Bucket		 = Req.GetCapture(2);
+	std::string_view   BuildId		 = Req.GetCapture(3);
+	ZEN_UNUSED(Namespace, Bucket, BuildId);
+	IoBuffer RequestPayload = ServerRequest.ReadPayload();
+	if (!RequestPayload)
+	{
+		m_BuildStoreStats.BadRequestCount++;
+		return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+										   HttpContentType::kText,
+										   "Expected compact binary body for metadata request, body is missing");
+	}
+	if (RequestPayload.GetContentType() != HttpContentType::kCbObject)
+	{
+		m_BuildStoreStats.BadRequestCount++;
+		return ServerRequest.WriteResponse(
+			HttpResponseCode::BadRequest,
+			HttpContentType::kText,
+			fmt::format("Expected compact binary body for metadata request, got {}", ToString(RequestPayload.GetContentType())));
+	}
+	if (CbValidateError ValidateError = ValidateCompactBinary(RequestPayload.GetView(), CbValidateMode::Default);
+		ValidateError != CbValidateError::None)
+	{
+		m_BuildStoreStats.BadRequestCount++;
+		return ServerRequest.WriteResponse(
+			HttpResponseCode::BadRequest,
+			HttpContentType::kText,
+			fmt::format("Compact binary body for metadata request is not valid, reason: {}", ToString(ValidateError)));
+	}
+	CbObject	RequestObject = LoadCompactBinaryObject(RequestPayload);
+	CbArrayView BlobsArray	  = RequestObject["blobHashes"sv].AsArrayView();
+	if (!BlobsArray)
+	{
+		m_BuildStoreStats.BadRequestCount++;
+		return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+										   HttpContentType::kText,
+										   "Compact binary body for metadata request is missing 'blobHashes' array");
+	}
+	const uint64_t BlobCount = BlobsArray.Num();
+
+	std::vector<IoHash> BlobRawHashes;
+	BlobRawHashes.reserve(BlobCount);
+	for (CbFieldView BlockHashView : BlobsArray)
+	{
+		BlobRawHashes.push_back(BlockHashView.AsHash());
+		if (BlobRawHashes.back() == IoHash::Zero)
+		{
+			const uint8_t Type = (uint8_t)BlockHashView.GetValue().GetType();
+			return ServerRequest.WriteResponse(
+				HttpResponseCode::BadRequest,
+				HttpContentType::kText,
+				fmt::format("Compact binary body for metadata 'blobHashes' array contains invalid field type: {}", Type));
+		}
+	}
+	m_BuildStoreStats.BlobMetaReadCount += BlobRawHashes.size();
+	std::vector<IoBuffer> BlockMetadatas = m_BuildStore.GetMetadatas(BlobRawHashes, &GetSmallWorkerPool(EWorkloadType::Burst));
+
+	CbPackage							   ResponsePackage;
+	std::vector<CbAttachment>			   Attachments;
+	tsl::robin_set<IoHash, IoHash::Hasher> AttachmentHashes;
+	Attachments.reserve(BlobCount);
+	AttachmentHashes.reserve(BlobCount);
+	{
+		CbObjectWriter ResponseWriter;
+
+		ResponseWriter.BeginArray("blobHashes");
+		for (size_t BlockHashIndex = 0; BlockHashIndex < BlobRawHashes.size(); BlockHashIndex++)
+		{
+			if (BlockMetadatas[BlockHashIndex])
+			{
+				const IoHash& BlockHash = BlobRawHashes[BlockHashIndex];
+				ResponseWriter.AddHash(BlockHash);
+			}
+		}
+		ResponseWriter.EndArray();	// blobHashes
+
+		ResponseWriter.BeginArray("metadatas");
+
+		for (size_t BlockHashIndex = 0; BlockHashIndex < BlobRawHashes.size(); BlockHashIndex++)
+		{
+			if (IoBuffer Metadata = BlockMetadatas[BlockHashIndex]; Metadata)
+			{
+				switch (Metadata.GetContentType())
+				{
+					case ZenContentType::kCbObject:
+						{
+							CbObject	 Object		= CbObject(SharedBuffer(std::move(Metadata)).MakeOwned());
+							const IoHash ObjectHash = Object.GetHash();
+							ResponseWriter.AddBinaryAttachment(ObjectHash);
+							if (!AttachmentHashes.contains(ObjectHash))
+							{
+								Attachments.push_back(CbAttachment(Object, ObjectHash));
+								AttachmentHashes.insert(ObjectHash);
+							}
+						}
+						break;
+					case ZenContentType::kCompressedBinary:
+						{
+							IoHash			 RawHash;
+							uint64_t		 _;
+							CompressedBuffer Compressed = CompressedBuffer::FromCompressed(SharedBuffer(std::move(Metadata)), RawHash, _);
+							ResponseWriter.AddBinaryAttachment(RawHash);
+							if (!AttachmentHashes.contains(RawHash))
+							{
+								Attachments.push_back(CbAttachment(Compressed, RawHash));
+								AttachmentHashes.insert(RawHash);
+							}
+						}
+						break;
+					default:
+						{
+							const IoHash RawHash = IoHash::HashBuffer(Metadata);
+							ResponseWriter.AddBinaryAttachment(RawHash);
+							if (!AttachmentHashes.contains(RawHash))
+							{
+								Attachments.push_back(CbAttachment(SharedBuffer(Metadata), RawHash));
+								AttachmentHashes.insert(RawHash);
+							}
+						}
+						break;
+				}
+			}
+		}
+
+		ResponseWriter.EndArray();	// metadatas
+
+		ResponsePackage.SetObject(ResponseWriter.Save());
+	}
+	ResponsePackage.AddAttachments(Attachments);
+
+	CompositeBuffer RpcResponseBuffer = FormatPackageMessageBuffer(ResponsePackage);
+	ServerRequest.WriteResponse(HttpResponseCode::OK, HttpContentType::kCbPackage, RpcResponseBuffer);
+}
+
+void
+HttpBuildStoreService::BlobsExistsRequest(HttpRouterRequest& Req)
+{
+	ZEN_TRACE_CPU("HttpBuildStoreService::BlobsExistsRequest");
+	HttpServerRequest& ServerRequest = Req.ServerRequest();
+	std::string_view   Namespace	 = Req.GetCapture(1);
+	std::string_view   Bucket		 = Req.GetCapture(2);
+	std::string_view   BuildId		 = Req.GetCapture(3);
+	ZEN_UNUSED(Namespace, Bucket, BuildId);
+	IoBuffer RequestPayload = ServerRequest.ReadPayload();
+	if (!RequestPayload)
+	{
+		m_BuildStoreStats.BadRequestCount++;
+		return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+										   HttpContentType::kText,
+										   "Expected compact binary body for blob exists request, body is missing");
+	}
+	if (RequestPayload.GetContentType() != HttpContentType::kCbObject)
+	{
+		m_BuildStoreStats.BadRequestCount++;
+		return ServerRequest.WriteResponse(
+			HttpResponseCode::BadRequest,
+			HttpContentType::kText,
+			fmt::format("Expected compact binary body for blob exists request, got {}", ToString(RequestPayload.GetContentType())));
+	}
+	if (CbValidateError ValidateError = ValidateCompactBinary(RequestPayload.GetView(), CbValidateMode::Default);
+		ValidateError != CbValidateError::None)
+	{
+		m_BuildStoreStats.BadRequestCount++;
+		return ServerRequest.WriteResponse(
+			HttpResponseCode::BadRequest,
+			HttpContentType::kText,
+			fmt::format("Compact binary body for blob exists request is not valid, reason: {}", ToString(ValidateError)));
+	}
+	CbObject	RequestObject = LoadCompactBinaryObject(RequestPayload);
+	CbArrayView BlobsArray	  = RequestObject["blobHashes"sv].AsArrayView();
+	if (!BlobsArray)
+	{
+		m_BuildStoreStats.BadRequestCount++;
+		return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+										   HttpContentType::kText,
+										   "Compact binary body for blob exists request is missing 'blobHashes' array");
+	}
+
+	std::vector<IoHash> BlobRawHashes;
+	BlobRawHashes.reserve(BlobsArray.Num());
+	for (CbFieldView BlockHashView : BlobsArray)
+	{
+		BlobRawHashes.push_back(BlockHashView.AsHash());
+		if (BlobRawHashes.back() == IoHash::Zero)
+		{
+			const uint8_t Type = (uint8_t)BlockHashView.GetValue().GetType();
+			return ServerRequest.WriteResponse(
+				HttpResponseCode::BadRequest,
+				HttpContentType::kText,
+				fmt::format("Compact binary body for blob exists request 'blobHashes' array contains invalid field type: {}", Type));
+		}
+	}
+
+	m_BuildStoreStats.BlobExistsCount += BlobRawHashes.size();
+	std::vector<BuildStore::BlobExistsResult> BlobsExists = m_BuildStore.BlobsExists(BlobRawHashes);
+	CbObjectWriter							  ResponseWriter(9 * BlobsExists.size());
+	ResponseWriter.BeginArray("blobExists"sv);
+	for (const BuildStore::BlobExistsResult& BlobExists : BlobsExists)
+	{
+		ResponseWriter.AddBool(BlobExists.HasBody);
+		if (BlobExists.HasBody)
+		{
+			m_BuildStoreStats.BlobExistsBodyHitCount++;
+		}
+	}
+	ResponseWriter.EndArray();	// blobExist
+	ResponseWriter.BeginArray("metadataExists"sv);
+	for (const BuildStore::BlobExistsResult& BlobExists : BlobsExists)
+	{
+		ResponseWriter.AddBool(BlobExists.HasBody);
+		if (BlobExists.HasMetadata)
+		{
+			m_BuildStoreStats.BlobExistsMetaHitCount++;
+		}
+	}
+	ResponseWriter.EndArray();	// metadataExists
+	CbObject ResponseObject = ResponseWriter.Save();
+	return ServerRequest.WriteResponse(HttpResponseCode::OK, ResponseObject);
+}
+
+void
+HttpBuildStoreService::HandleStatsRequest(HttpServerRequest& Request)
+{
+	ZEN_TRACE_CPU("HttpBuildStoreService::Stats");
+	CbObjectWriter Cbo;
+
+	EmitSnapshot("requests", m_HttpRequests, Cbo);
+
+	Cbo.BeginObject("builds");
+	{
+		Cbo.BeginObject("blobs");
+		{
+			Cbo << "readcount" << m_BuildStoreStats.BlobReadCount << "writecount" << m_BuildStoreStats.BlobWriteCount << "hitcount"
+				<< m_BuildStoreStats.BlobHitCount;
+		}
+		Cbo.EndObject();
+
+		Cbo.BeginObject("metadata");
+		{
+			Cbo << "readcount" << m_BuildStoreStats.BlobMetaReadCount << "writecount" << m_BuildStoreStats.BlobMetaWriteCount << "hitcount"
+				<< m_BuildStoreStats.BlobMetaHitCount;
+		}
+		Cbo.EndObject();
+
+		Cbo << "requestcount" << m_BuildStoreStats.RequestCount;
+		Cbo << "badrequestcount" << m_BuildStoreStats.BadRequestCount;
+	}
+	Cbo.EndObject();
+
+	return Request.WriteResponse(HttpResponseCode::OK, Cbo.Save());
+}
+
+}  // namespace zen
diff --git a/src/zenserver/buildstore/httpbuildstore.h b/src/zenserver/buildstore/httpbuildstore.h
new file mode 100644
index 000000000..a59aa882a
--- /dev/null
+++ b/src/zenserver/buildstore/httpbuildstore.h
@@ -0,0 +1,65 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include <zencore/stats.h>
+#include <zenhttp/httpserver.h>
+#include <zenhttp/httpstats.h>
+
+#include <filesystem>
+
+namespace zen {
+
+class BuildStore;
+
+class HttpBuildStoreService final : public zen::HttpService, public IHttpStatsProvider
+{
+public:
+	HttpBuildStoreService(HttpStatsService& StatsService, BuildStore& Store);
+	virtual ~HttpBuildStoreService();
+
+	virtual const char* BaseUri() const override;
+	virtual void		HandleRequest(zen::HttpServerRequest& Request) override;
+
+	virtual void HandleStatsRequest(HttpServerRequest& Request) override;
+
+private:
+	struct BuildStoreStats
+	{
+		std::atomic_uint64_t BlobReadCount{};
+		std::atomic_uint64_t BlobHitCount{};
+		std::atomic_uint64_t BlobWriteCount{};
+		std::atomic_uint64_t BlobMetaReadCount{};
+		std::atomic_uint64_t BlobMetaHitCount{};
+		std::atomic_uint64_t BlobMetaWriteCount{};
+		std::atomic_uint64_t BlobExistsCount{};
+		std::atomic_uint64_t BlobExistsBodyHitCount{};
+		std::atomic_uint64_t BlobExistsMetaHitCount{};
+		std::atomic_uint64_t RequestCount{};
+		std::atomic_uint64_t BadRequestCount{};
+	};
+
+	void Initialize();
+
+	inline LoggerRef Log() { return m_Log; }
+
+	LoggerRef m_Log;
+
+	void PutBlobRequest(HttpRouterRequest& Req);
+	void GetBlobRequest(HttpRouterRequest& Req);
+
+	void PutMetadataRequest(HttpRouterRequest& Req);
+	void GetMetadatasRequest(HttpRouterRequest& Req);
+
+	void BlobsExistsRequest(HttpRouterRequest& Req);
+
+	HttpRequestRouter m_Router;
+
+	HttpStatsService& m_StatsService;
+
+	BuildStore&				 m_BuildStore;
+	BuildStoreStats			 m_BuildStoreStats;
+	metrics::OperationTiming m_HttpRequests;
+};
+
+}  // namespace zen
diff --git a/src/zenserver/config.cpp b/src/zenserver/config.cpp
index 809092378..0da98210c 100644
--- a/src/zenserver/config.cpp
+++ b/src/zenserver/config.cpp
@@ -377,6 +377,9 @@ ParseConfigFile(const std::filesystem::path& Path,
 	LuaOptions.AddOption("server.objectstore.enabled"sv, ServerOptions.ObjectStoreEnabled, "objectstore-enabled"sv);
 	LuaOptions.AddOption("server.objectstore.buckets"sv, ServerOptions.ObjectStoreConfig);
 
+	////// buildsstore
+	LuaOptions.AddOption("server.buildstore.enabled"sv, ServerOptions.BuildStoreConfig.Enabled, "buildstore-enabled"sv);
+
 	////// network
 	LuaOptions.AddOption("network.httpserverclass"sv, ServerOptions.HttpServerConfig.ServerClass, "http"sv);
 	LuaOptions.AddOption("network.httpserverthreads"sv, ServerOptions.HttpServerConfig.ThreadCount, "http-threads"sv);
@@ -1031,6 +1034,13 @@ ParseCliOptions(int argc, char* argv[], ZenServerOptions& ServerOptions)
 					   cxxopts::value<std::vector<std::string>>(BucketConfigs),
 					   "");
 
+	options.add_option("buildstore",
+					   "",
+					   "buildstore-enabled",
+					   "Whether the builds store is enabled or not.",
+					   cxxopts::value<bool>(ServerOptions.BuildStoreConfig.Enabled)->default_value("false"),
+					   "");
+
 	options.add_option("stats",
 					   "",
 					   "statsd",
diff --git a/src/zenserver/config.h b/src/zenserver/config.h
index c7781aada..a87b6f8b3 100644
--- a/src/zenserver/config.h
+++ b/src/zenserver/config.h
@@ -59,11 +59,17 @@ struct ZenProjectStoreEvictionPolicy
 	int32_t MaxDurationSeconds = 7 * 24 * 60 * 60;
 };
 
+struct ZenBuildStoreEvictionPolicy
+{
+	int32_t MaxDurationSeconds = 3 * 24 * 60 * 60;
+};
+
 struct ZenGcConfig
 {
 	//	ZenCasEvictionPolicy   Cas;
 	ZenCacheEvictionPolicy		  Cache;
 	ZenProjectStoreEvictionPolicy ProjectStore;
+	ZenBuildStoreEvictionPolicy	  BuildStore;
 	int32_t						  MonitorIntervalSeconds			= 30;
 	int32_t						  IntervalSeconds					= 0;
 	bool						  CollectSmallObjects				= true;
@@ -130,6 +136,11 @@ struct ZenProjectStoreConfig
 	bool StoreProjectAttachmentMetaData = false;
 };
 
+struct ZenBuildStoreConfig
+{
+	bool Enabled = false;
+};
+
 struct ZenWorkspacesConfig
 {
 	bool Enabled				   = false;
@@ -145,6 +156,7 @@ struct ZenServerOptions
 	zen::HttpServerConfig	 HttpServerConfig;
 	ZenStructuredCacheConfig StructuredCacheConfig;
 	ZenProjectStoreConfig	 ProjectStoreConfig;
+	ZenBuildStoreConfig		 BuildStoreConfig;
 	ZenStatsConfig			 StatsConfig;
 	ZenWorkspacesConfig		 WorksSpacesConfig;
 	std::filesystem::path	 SystemRootDir;				  // System root directory (used for machine level config)
diff --git a/src/zenserver/workspaces/httpworkspaces.cpp b/src/zenserver/workspaces/httpworkspaces.cpp
index 8a4b977ad..0b7fd0400 100644
--- a/src/zenserver/workspaces/httpworkspaces.cpp
+++ b/src/zenserver/workspaces/httpworkspaces.cpp
@@ -84,7 +84,7 @@ HttpWorkspacesService::HttpWorkspacesService(HttpStatsService& StatsService, con
 
 HttpWorkspacesService::~HttpWorkspacesService()
 {
-	m_StatsService.UnregisterHandler("prj", *this);
+	m_StatsService.UnregisterHandler("ws", *this);
 }
 
 const char*
diff --git a/src/zenserver/zenserver.cpp b/src/zenserver/zenserver.cpp
index f84bc0b00..03e269d49 100644
--- a/src/zenserver/zenserver.cpp
+++ b/src/zenserver/zenserver.cpp
@@ -23,6 +23,7 @@
 #include <zencore/trace.h>
 #include <zencore/workthreadpool.h>
 #include <zenhttp/httpserver.h>
+#include <zenstore/buildstore/buildstore.h>
 #include <zenstore/cidstore.h>
 #include <zenstore/scrubcontext.h>
 #include <zenstore/workspaces.h>
@@ -262,6 +263,13 @@ ZenServer::Initialize(const ZenServerOptions& ServerOptions, ZenServerState::Zen
 									  *m_Workspaces));
 	}
 
+	if (ServerOptions.BuildStoreConfig.Enabled)
+	{
+		BuildStoreConfig ObjCfg;
+		ObjCfg.RootDirectory = m_DataRoot / "builds";
+		m_BuildStore		 = std::make_unique<BuildStore>(std::move(ObjCfg), m_GcManager);
+	}
+
 	if (ServerOptions.StructuredCacheConfig.Enabled)
 	{
 		InitializeStructuredCache(ServerOptions);
@@ -310,6 +318,12 @@ ZenServer::Initialize(const ZenServerOptions& ServerOptions, ZenServerState::Zen
 		m_Http->RegisterService(*m_ObjStoreService);
 	}
 
+	if (ServerOptions.BuildStoreConfig.Enabled)
+	{
+		m_BuildStoreService = std::make_unique<HttpBuildStoreService>(m_StatsService, *m_BuildStore);
+		m_Http->RegisterService(*m_BuildStoreService);
+	}
+
 #if ZEN_WITH_VFS
 	m_VfsService = std::make_unique<VfsService>();
 	m_VfsService->AddService(Ref<ProjectStore>(m_ProjectStore));
@@ -327,6 +341,7 @@ ZenServer::Initialize(const ZenServerOptions& ServerOptions, ZenServerState::Zen
 							   .Interval				= std::chrono::seconds(ServerOptions.GcConfig.IntervalSeconds),
 							   .MaxCacheDuration		= std::chrono::seconds(ServerOptions.GcConfig.Cache.MaxDurationSeconds),
 							   .MaxProjectStoreDuration = std::chrono::seconds(ServerOptions.GcConfig.ProjectStore.MaxDurationSeconds),
+							   .MaxBuildStoreDuration	= std::chrono::seconds(ServerOptions.GcConfig.BuildStore.MaxDurationSeconds),
 							   .CollectSmallObjects		= ServerOptions.GcConfig.CollectSmallObjects,
 							   .Enabled					= ServerOptions.GcConfig.Enabled,
 							   .DiskReserveSize			= ServerOptions.GcConfig.DiskReserveSize,
@@ -347,6 +362,7 @@ ZenServer::Initialize(const ZenServerOptions& ServerOptions, ZenServerState::Zen
 										   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"},
@@ -801,6 +817,9 @@ ZenServer::Cleanup()
 		m_ObjStoreService.reset();
 		m_FrontendService.reset();
 
+		m_BuildStoreService.reset();
+		m_BuildStore = {};
+
 		m_StructuredCacheService.reset();
 		m_UpstreamService.reset();
 		m_UpstreamCache.reset();
diff --git a/src/zenserver/zenserver.h b/src/zenserver/zenserver.h
index 80054dc35..5cfa04ba1 100644
--- a/src/zenserver/zenserver.h
+++ b/src/zenserver/zenserver.h
@@ -25,6 +25,7 @@ ZEN_THIRD_PARTY_INCLUDES_END
 #include <zenstore/cache/structuredcachestore.h>
 #include <zenstore/gc.h>
 #include "admin/admin.h"
+#include "buildstore/httpbuildstore.h"
 #include "cache/httpstructuredcache.h"
 #include "diag/diagsvcs.h"
 #include "frontend/frontend.h"
@@ -127,6 +128,8 @@ private:
 	Ref<ZenCacheStore>				  m_CacheStore;
 	std::unique_ptr<OpenProcessCache> m_OpenProcessCache;
 	HttpTestService					  m_TestService;
+	std::unique_ptr<BuildStore>		  m_BuildStore;
+
 #if ZEN_WITH_TESTS
 	HttpTestingService m_TestingService;
 #endif
@@ -140,6 +143,7 @@ private:
 	HttpHealthService							m_HealthService;
 	std::unique_ptr<HttpFrontendService>		m_FrontendService;
 	std::unique_ptr<HttpObjectStoreService>		m_ObjStoreService;
+	std::unique_ptr<HttpBuildStoreService>		m_BuildStoreService;
 	std::unique_ptr<VfsService>					m_VfsService;
 	std::unique_ptr<JobQueue>					m_JobQueue;
 	std::unique_ptr<HttpAdminService>			m_AdminService;