Merge branch 'main' into lm/restrict-content-type

13 files changed, 572 insertions, 135 deletions

diff --git a/src/zenserver/storage/admin/admin.cpp b/src/zenserver/storage/admin/admin.cpp
index 19155e02b..c9f999c69 100644
--- a/src/zenserver/storage/admin/admin.cpp
+++ b/src/zenserver/storage/admin/admin.cpp
@@ -716,7 +716,7 @@ HttpAdminService::HttpAdminService(GcScheduler&			   Scheduler,
 		"logs",
 		[this](HttpRouterRequest& Req) {
 			CbObjectWriter Obj;
-			auto		   LogLevel = logging::level::ToStringView(logging::GetLogLevel());
+			auto		   LogLevel = logging::ToStringView(logging::GetLogLevel());
 			Obj.AddString("loglevel", std::string_view(LogLevel.data(), LogLevel.size()));
 			Obj.AddString("Logfile", PathToUtf8(m_LogPaths.AbsLogPath));
 			Obj.BeginObject("cache");
@@ -767,8 +767,8 @@ HttpAdminService::HttpAdminService(GcScheduler&			   Scheduler,
 			}
 			if (std::string Param(Params.GetValue("loglevel")); Param.empty() == false)
 			{
-				logging::level::LogLevel NewLevel = logging::level::ParseLogLevelString(Param);
-				std::string_view		 LogLevel = logging::level::ToStringView(NewLevel);
+				logging::LogLevel NewLevel = logging::ParseLogLevelString(Param);
+				std::string_view  LogLevel = logging::ToStringView(NewLevel);
 				if (LogLevel != Param)
 				{
 					return Req.ServerRequest().WriteResponse(HttpResponseCode::BadRequest,
diff --git a/src/zenserver/storage/buildstore/httpbuildstore.cpp b/src/zenserver/storage/buildstore/httpbuildstore.cpp
index f5ba30616..de9589078 100644
--- a/src/zenserver/storage/buildstore/httpbuildstore.cpp
+++ b/src/zenserver/storage/buildstore/httpbuildstore.cpp
@@ -71,7 +71,7 @@ HttpBuildStoreService::Initialize()
 	m_Router.RegisterRoute(
 		"{namespace}/{bucket}/{buildid}/blobs/{hash}",
 		[this](HttpRouterRequest& Req) { GetBlobRequest(Req); },
-		HttpVerb::kGet);
+		HttpVerb::kGet | HttpVerb::kPost);
 
 	m_Router.RegisterRoute(
 		"{namespace}/{bucket}/{buildid}/blobs/putBlobMetadata",
@@ -161,14 +161,57 @@ HttpBuildStoreService::GetBlobRequest(HttpRouterRequest& Req)
 										   HttpContentType::kText,
 										   fmt::format("Invalid blob hash '{}'", Hash));
 	}
-	zen::HttpRanges Ranges;
-	bool			HasRange = ServerRequest.TryGetRanges(Ranges);
-	if (Ranges.size() > 1)
+
+	std::vector<std::pair<uint64_t, uint64_t>> OffsetAndLengthPairs;
+	if (ServerRequest.RequestVerb() == HttpVerb::kPost)
 	{
-		// Only a single range is supported
-		return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
-										   HttpContentType::kText,
-										   "Multiple ranges in blob request is not supported");
+		CbObject RangePayload = ServerRequest.ReadPayloadObject();
+		if (RangePayload)
+		{
+			CbArrayView RangesArray = RangePayload["ranges"sv].AsArrayView();
+			OffsetAndLengthPairs.reserve(RangesArray.Num());
+			for (CbFieldView FieldView : RangesArray)
+			{
+				CbObjectView RangeView	 = FieldView.AsObjectView();
+				uint64_t	 RangeOffset = RangeView["offset"sv].AsUInt64();
+				uint64_t	 RangeLength = RangeView["length"sv].AsUInt64();
+				OffsetAndLengthPairs.push_back(std::make_pair(RangeOffset, RangeLength));
+			}
+			if (OffsetAndLengthPairs.size() > MaxRangeCountPerRequestSupported)
+			{
+				return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+												   HttpContentType::kText,
+												   fmt::format("Number of ranges ({}) for blob request exceeds maximum range count {}",
+															   OffsetAndLengthPairs.size(),
+															   MaxRangeCountPerRequestSupported));
+			}
+		}
+		if (OffsetAndLengthPairs.empty())
+		{
+			m_BuildStoreStats.BadRequestCount++;
+			return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+											   HttpContentType::kText,
+											   "Fetching blob without ranges must be done with the GET verb");
+		}
+	}
+	else
+	{
+		HttpRanges Ranges;
+		bool	   HasRange = ServerRequest.TryGetRanges(Ranges);
+		if (HasRange)
+		{
+			if (Ranges.size() > 1)
+			{
+				// Only a single http range is supported, we have limited support for http multirange responses
+				m_BuildStoreStats.BadRequestCount++;
+				return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+												   HttpContentType::kText,
+												   fmt::format("Multiple ranges in blob request is only supported for {} accept type",
+															   ToString(HttpContentType::kCbPackage)));
+			}
+			const HttpRange& FirstRange = Ranges.front();
+			OffsetAndLengthPairs.push_back(std::make_pair<uint64_t, uint64_t>(FirstRange.Start, FirstRange.End - FirstRange.Start + 1));
+		}
 	}
 
 	m_BuildStoreStats.BlobReadCount++;
@@ -179,24 +222,79 @@ HttpBuildStoreService::GetBlobRequest(HttpRouterRequest& Req)
 										   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)
+
+	if (OffsetAndLengthPairs.empty())
+	{
+		return ServerRequest.WriteResponse(HttpResponseCode::OK, Blob.GetContentType(), Blob);
+	}
+
+	if (ServerRequest.AcceptContentType() == HttpContentType::kCbPackage)
 	{
-		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)
+		const uint64_t BlobSize = Blob.GetSize();
+
+		CbPackage			  ResponsePackage;
+		std::vector<IoBuffer> RangeBuffers;
+		CbObjectWriter		  Writer;
+		Writer.BeginArray("ranges"sv);
+		for (const std::pair<uint64_t, uint64_t>& Range : OffsetAndLengthPairs)
 		{
-			return ServerRequest.WriteResponse(HttpResponseCode::NoContent);
+			const uint64_t MaxBlobSize = Range.first < BlobSize ? BlobSize - Range.first : 0;
+			const uint64_t RangeSize   = Min(Range.second, MaxBlobSize);
+			Writer.BeginObject();
+			{
+				if (Range.first + RangeSize <= BlobSize)
+				{
+					RangeBuffers.push_back(IoBuffer(Blob, Range.first, RangeSize));
+					Writer.AddInteger("offset"sv, Range.first);
+					Writer.AddInteger("length"sv, RangeSize);
+				}
+				else
+				{
+					Writer.AddInteger("offset"sv, Range.first);
+					Writer.AddInteger("length"sv, 0);
+				}
+			}
+			Writer.EndObject();
 		}
-		Blob = IoBuffer(Blob, Range.Start, RangeSize);
-		return ServerRequest.WriteResponse(HttpResponseCode::OK, ZenContentType::kBinary, Blob);
+		Writer.EndArray();
+
+		CompositeBuffer Ranges(RangeBuffers);
+		CbAttachment	PayloadAttachment(std::move(Ranges), BlobHash);
+		Writer.AddAttachment("payload", PayloadAttachment);
+
+		CbObject HeaderObject = Writer.Save();
+
+		ResponsePackage.AddAttachment(PayloadAttachment);
+		ResponsePackage.SetObject(HeaderObject);
+
+		CompositeBuffer RpcResponseBuffer = FormatPackageMessageBuffer(ResponsePackage);
+		uint64_t		ResponseSize	  = RpcResponseBuffer.GetSize();
+		ZEN_UNUSED(ResponseSize);
+		return ServerRequest.WriteResponse(HttpResponseCode::OK, HttpContentType::kCbPackage, RpcResponseBuffer);
 	}
 	else
 	{
-		return ServerRequest.WriteResponse(HttpResponseCode::OK, Blob.GetContentType(), Blob);
+		if (OffsetAndLengthPairs.size() != 1)
+		{
+			// Only a single http range is supported, we have limited support for http multirange responses
+			m_BuildStoreStats.BadRequestCount++;
+			return ServerRequest.WriteResponse(
+				HttpResponseCode::BadRequest,
+				HttpContentType::kText,
+				fmt::format("Multiple ranges in blob request is only supported for {} accept type", ToString(HttpContentType::kCbPackage)));
+		}
+
+		const std::pair<uint64_t, uint64_t>& OffsetAndLength = OffsetAndLengthPairs.front();
+		const uint64_t						 BlobSize		 = Blob.GetSize();
+		const uint64_t						 MaxBlobSize	 = OffsetAndLength.first < BlobSize ? BlobSize - OffsetAndLength.first : 0;
+		const uint64_t						 RangeSize		 = Min(OffsetAndLength.second, MaxBlobSize);
+		if (OffsetAndLength.first + RangeSize > BlobSize)
+		{
+			return ServerRequest.WriteResponse(HttpResponseCode::NoContent);
+		}
+		Blob = IoBuffer(Blob, OffsetAndLength.first, RangeSize);
+		return ServerRequest.WriteResponse(HttpResponseCode::OK, ZenContentType::kBinary, Blob);
 	}
 }
 
@@ -507,8 +605,8 @@ HttpBuildStoreService::BlobsExistsRequest(HttpRouterRequest& Req)
 	return ServerRequest.WriteResponse(HttpResponseCode::OK, ResponseObject);
 }
 
-void
-HttpBuildStoreService::HandleStatsRequest(HttpServerRequest& Request)
+CbObject
+HttpBuildStoreService::CollectStats()
 {
 	ZEN_TRACE_CPU("HttpBuildStoreService::Stats");
 
@@ -562,7 +660,13 @@ HttpBuildStoreService::HandleStatsRequest(HttpServerRequest& Request)
 	}
 	Cbo.EndObject();
 
-	return Request.WriteResponse(HttpResponseCode::OK, Cbo.Save());
+	return Cbo.Save();
+}
+
+void
+HttpBuildStoreService::HandleStatsRequest(HttpServerRequest& Request)
+{
+	Request.WriteResponse(HttpResponseCode::OK, CollectStats());
 }
 
 void
@@ -571,6 +675,11 @@ HttpBuildStoreService::HandleStatusRequest(HttpServerRequest& Request)
 	ZEN_TRACE_CPU("HttpBuildStoreService::Status");
 	CbObjectWriter Cbo;
 	Cbo << "ok" << true;
+	Cbo.BeginObject("capabilities");
+	{
+		Cbo << "maxrangecountperrequest" << MaxRangeCountPerRequestSupported;
+	}
+	Cbo.EndObject();  // capabilities
 	Request.WriteResponse(HttpResponseCode::OK, Cbo.Save());
 }
 
diff --git a/src/zenserver/storage/buildstore/httpbuildstore.h b/src/zenserver/storage/buildstore/httpbuildstore.h
index e10986411..2a09b71cf 100644
--- a/src/zenserver/storage/buildstore/httpbuildstore.h
+++ b/src/zenserver/storage/buildstore/httpbuildstore.h
@@ -22,8 +22,9 @@ public:
 	virtual const char* BaseUri() const override;
 	virtual void		HandleRequest(zen::HttpServerRequest& Request) override;
 
-	virtual void HandleStatsRequest(HttpServerRequest& Request) override;
-	virtual void HandleStatusRequest(HttpServerRequest& Request) override;
+	virtual CbObject CollectStats() override;
+	virtual void	 HandleStatsRequest(HttpServerRequest& Request) override;
+	virtual void	 HandleStatusRequest(HttpServerRequest& Request) override;
 
 private:
 	struct BuildStoreStats
@@ -45,6 +46,8 @@ private:
 
 	inline LoggerRef Log() { return m_Log; }
 
+	static constexpr uint32_t MaxRangeCountPerRequestSupported = 256u;
+
 	LoggerRef m_Log;
 
 	void PutBlobRequest(HttpRouterRequest& Req);
diff --git a/src/zenserver/storage/cache/httpstructuredcache.cpp b/src/zenserver/storage/cache/httpstructuredcache.cpp
index 72f29d14e..06b8f6c27 100644
--- a/src/zenserver/storage/cache/httpstructuredcache.cpp
+++ b/src/zenserver/storage/cache/httpstructuredcache.cpp
@@ -654,7 +654,7 @@ HttpStructuredCacheService::HandleCacheNamespaceRequest(HttpServerRequest& Reque
 					auto NewEnd = std::unique(AllAttachments.begin(), AllAttachments.end());
 					AllAttachments.erase(NewEnd, AllAttachments.end());
 
-					uint64_t AttachmentsSize = 0;
+					std::atomic<uint64_t> AttachmentsSize = 0;
 
 					m_CidStore.IterateChunks(
 						AllAttachments,
@@ -746,7 +746,7 @@ HttpStructuredCacheService::HandleCacheBucketRequest(HttpServerRequest& Request,
 						ResponseWriter << "Size" << ValuesSize;
 						ResponseWriter << "AttachmentCount" << ContentStats.Attachments.size();
 
-						uint64_t AttachmentsSize = 0;
+						std::atomic<uint64_t> AttachmentsSize = 0;
 
 						WorkerThreadPool& WorkerPool = GetMediumWorkerPool(EWorkloadType::Background);
 
@@ -1827,8 +1827,8 @@ HttpStructuredCacheService::HandleRpcRequest(HttpServerRequest& Request, std::st
 	}
 }
 
-void
-HttpStructuredCacheService::HandleStatsRequest(HttpServerRequest& Request)
+CbObject
+HttpStructuredCacheService::CollectStats()
 {
 	ZEN_MEMSCOPE(GetCacheHttpTag());
 
@@ -1858,13 +1858,132 @@ HttpStructuredCacheService::HandleStatsRequest(HttpServerRequest& Request)
 	const CidStoreSize	 CidSize   = m_CidStore.TotalSize();
 	const CacheStoreSize CacheSize = m_CacheStore.TotalSize();
 
+	Cbo.BeginObject("cache");
+	{
+		Cbo << "badrequestcount" << BadRequestCount;
+		Cbo.BeginObject("rpc");
+		Cbo << "count" << RpcRequests;
+		Cbo << "ops" << RpcRecordBatchRequests + RpcValueBatchRequests + RpcChunkBatchRequests;
+		Cbo.BeginObject("records");
+		Cbo << "count" << RpcRecordRequests;
+		Cbo << "ops" << RpcRecordBatchRequests;
+		Cbo.EndObject();
+		Cbo.BeginObject("values");
+		Cbo << "count" << RpcValueRequests;
+		Cbo << "ops" << RpcValueBatchRequests;
+		Cbo.EndObject();
+		Cbo.BeginObject("chunks");
+		Cbo << "count" << RpcChunkRequests;
+		Cbo << "ops" << RpcChunkBatchRequests;
+		Cbo.EndObject();
+		Cbo.EndObject();
+
+		Cbo.BeginObject("size");
+		{
+			Cbo << "disk" << CacheSize.DiskSize;
+			Cbo << "memory" << CacheSize.MemorySize;
+		}
+		Cbo.EndObject();
+
+		Cbo << "hits" << HitCount << "misses" << MissCount << "writes" << WriteCount;
+		Cbo << "hit_ratio" << (TotalCount > 0 ? (double(HitCount) / double(TotalCount)) : 0.0);
+
+		if (m_UpstreamCache.IsActive())
+		{
+			Cbo << "upstream_ratio" << (HitCount > 0 ? (double(UpstreamHitCount) / double(HitCount)) : 0.0);
+			Cbo << "upstream_hits" << m_CacheStats.UpstreamHitCount;
+			Cbo << "upstream_ratio" << (HitCount > 0 ? (double(UpstreamHitCount) / double(HitCount)) : 0.0);
+			Cbo << "upstream_ratio" << (HitCount > 0 ? (double(UpstreamHitCount) / double(HitCount)) : 0.0);
+		}
+
+		Cbo << "cidhits" << ChunkHitCount << "cidmisses" << ChunkMissCount << "cidwrites" << ChunkWriteCount;
+
+		{
+			ZenCacheStore::CacheStoreStats StoreStatsData = m_CacheStore.Stats();
+			Cbo.BeginObject("store");
+			Cbo << "hits" << StoreStatsData.HitCount << "misses" << StoreStatsData.MissCount << "writes" << StoreStatsData.WriteCount
+				<< "rejected_writes" << StoreStatsData.RejectedWriteCount << "rejected_reads" << StoreStatsData.RejectedReadCount;
+			const uint64_t StoreTotal = StoreStatsData.HitCount + StoreStatsData.MissCount;
+			Cbo << "hit_ratio" << (StoreTotal > 0 ? (double(StoreStatsData.HitCount) / double(StoreTotal)) : 0.0);
+			EmitSnapshot("read", StoreStatsData.GetOps, Cbo);
+			EmitSnapshot("write", StoreStatsData.PutOps, Cbo);
+			Cbo.EndObject();
+		}
+	}
+	Cbo.EndObject();
+
+	if (m_UpstreamCache.IsActive())
+	{
+		EmitSnapshot("upstream_gets", m_UpstreamGetRequestTiming, Cbo);
+		Cbo.BeginObject("upstream");
+		{
+			m_UpstreamCache.GetStatus(Cbo);
+		}
+		Cbo.EndObject();
+	}
+
+	Cbo.BeginObject("cid");
+	{
+		Cbo.BeginObject("size");
+		{
+			Cbo << "tiny" << CidSize.TinySize;
+			Cbo << "small" << CidSize.SmallSize;
+			Cbo << "large" << CidSize.LargeSize;
+			Cbo << "total" << CidSize.TotalSize;
+		}
+		Cbo.EndObject();
+	}
+	Cbo.EndObject();
+
+	return Cbo.Save();
+}
+
+void
+HttpStructuredCacheService::HandleStatsRequest(HttpServerRequest& Request)
+{
+	ZEN_MEMSCOPE(GetCacheHttpTag());
+
 	bool ShowCidStoreStats	 = Request.GetQueryParams().GetValue("cidstorestats") == "true";
 	bool ShowCacheStoreStats = Request.GetQueryParams().GetValue("cachestorestats") == "true";
 
-	CidStoreStats CidStoreStats = {};
+	if (!ShowCidStoreStats && !ShowCacheStoreStats)
+	{
+		Request.WriteResponse(HttpResponseCode::OK, CollectStats());
+		return;
+	}
+
+	// Full stats with optional detailed store/cid breakdowns
+
+	CbObjectWriter Cbo;
+
+	EmitSnapshot("requests", m_HttpRequests, Cbo);
+
+	const uint64_t		 HitCount		  = m_CacheStats.HitCount;
+	const uint64_t		 UpstreamHitCount = m_CacheStats.UpstreamHitCount;
+	const uint64_t		 MissCount		  = m_CacheStats.MissCount;
+	const uint64_t		 WriteCount		  = m_CacheStats.WriteCount;
+	const uint64_t		 BadRequestCount  = m_CacheStats.BadRequestCount;
+	struct CidStoreStats StoreStats		  = m_CidStore.Stats();
+	const uint64_t		 ChunkHitCount	  = StoreStats.HitCount;
+	const uint64_t		 ChunkMissCount	  = StoreStats.MissCount;
+	const uint64_t		 ChunkWriteCount  = StoreStats.WriteCount;
+	const uint64_t		 TotalCount		  = HitCount + MissCount;
+
+	const uint64_t RpcRequests			  = m_CacheStats.RpcRequests;
+	const uint64_t RpcRecordRequests	  = m_CacheStats.RpcRecordRequests;
+	const uint64_t RpcRecordBatchRequests = m_CacheStats.RpcRecordBatchRequests;
+	const uint64_t RpcValueRequests		  = m_CacheStats.RpcValueRequests;
+	const uint64_t RpcValueBatchRequests  = m_CacheStats.RpcValueBatchRequests;
+	const uint64_t RpcChunkRequests		  = m_CacheStats.RpcChunkRequests;
+	const uint64_t RpcChunkBatchRequests  = m_CacheStats.RpcChunkBatchRequests;
+
+	const CidStoreSize	 CidSize   = m_CidStore.TotalSize();
+	const CacheStoreSize CacheSize = m_CacheStore.TotalSize();
+
+	CidStoreStats DetailedCidStoreStats = {};
 	if (ShowCidStoreStats)
 	{
-		CidStoreStats = m_CidStore.Stats();
+		DetailedCidStoreStats = m_CidStore.Stats();
 	}
 	ZenCacheStore::CacheStoreStats CacheStoreStats = {};
 	if (ShowCacheStoreStats)
@@ -2002,8 +2121,8 @@ HttpStructuredCacheService::HandleStatsRequest(HttpServerRequest& Request)
 			}
 			Cbo.EndObject();
 		}
-		Cbo.EndObject();
 	}
+	Cbo.EndObject();
 
 	if (m_UpstreamCache.IsActive())
 	{
@@ -2029,10 +2148,10 @@ HttpStructuredCacheService::HandleStatsRequest(HttpServerRequest& Request)
 		if (ShowCidStoreStats)
 		{
 			Cbo.BeginObject("store");
-			Cbo << "hits" << CidStoreStats.HitCount << "misses" << CidStoreStats.MissCount << "writes" << CidStoreStats.WriteCount;
-			EmitSnapshot("read", CidStoreStats.FindChunkOps, Cbo);
-			EmitSnapshot("write", CidStoreStats.AddChunkOps, Cbo);
-			//		EmitSnapshot("exists", CidStoreStats.ContainChunkOps, Cbo);
+			Cbo << "hits" << DetailedCidStoreStats.HitCount << "misses" << DetailedCidStoreStats.MissCount << "writes"
+				<< DetailedCidStoreStats.WriteCount;
+			EmitSnapshot("read", DetailedCidStoreStats.FindChunkOps, Cbo);
+			EmitSnapshot("write", DetailedCidStoreStats.AddChunkOps, Cbo);
 			Cbo.EndObject();
 		}
 	}
diff --git a/src/zenserver/storage/cache/httpstructuredcache.h b/src/zenserver/storage/cache/httpstructuredcache.h
index 5a795c215..d462415d4 100644
--- a/src/zenserver/storage/cache/httpstructuredcache.h
+++ b/src/zenserver/storage/cache/httpstructuredcache.h
@@ -102,11 +102,12 @@ private:
 	void HandleRpcRequest(HttpServerRequest& Request, std::string_view UriNamespace);
 	void HandleDetailsRequest(HttpServerRequest& Request);
 
-	void		 HandleCacheRequest(HttpServerRequest& Request);
-	void		 HandleCacheNamespaceRequest(HttpServerRequest& Request, std::string_view Namespace);
-	void		 HandleCacheBucketRequest(HttpServerRequest& Request, std::string_view Namespace, std::string_view Bucket);
-	virtual void HandleStatsRequest(HttpServerRequest& Request) override;
-	virtual void HandleStatusRequest(HttpServerRequest& Request) override;
+	void			 HandleCacheRequest(HttpServerRequest& Request);
+	void			 HandleCacheNamespaceRequest(HttpServerRequest& Request, std::string_view Namespace);
+	void			 HandleCacheBucketRequest(HttpServerRequest& Request, std::string_view Namespace, std::string_view Bucket);
+	virtual CbObject CollectStats() override;
+	virtual void	 HandleStatsRequest(HttpServerRequest& Request) override;
+	virtual void	 HandleStatusRequest(HttpServerRequest& Request) override;
 
 	bool AreDiskWritesAllowed() const;
 
diff --git a/src/zenserver/storage/projectstore/httpprojectstore.cpp b/src/zenserver/storage/projectstore/httpprojectstore.cpp
index fe32fa15b..836d84292 100644
--- a/src/zenserver/storage/projectstore/httpprojectstore.cpp
+++ b/src/zenserver/storage/projectstore/httpprojectstore.cpp
@@ -13,7 +13,12 @@
 #include <zencore/scopeguard.h>
 #include <zencore/stream.h>
 #include <zencore/trace.h>
+#include <zenhttp/httpclientauth.h>
 #include <zenhttp/packageformat.h>
+#include <zenremotestore/builds/buildstoragecache.h>
+#include <zenremotestore/builds/buildstorageutil.h>
+#include <zenremotestore/jupiter/jupiterhost.h>
+#include <zenremotestore/operationlogoutput.h>
 #include <zenremotestore/projectstore/buildsremoteprojectstore.h>
 #include <zenremotestore/projectstore/fileremoteprojectstore.h>
 #include <zenremotestore/projectstore/jupiterremoteprojectstore.h>
@@ -244,6 +249,22 @@ namespace {
 	{
 		std::shared_ptr<RemoteProjectStore> Store;
 		std::string							Description;
+		double								LatencySec				= -1.0;
+		uint64_t							MaxRangeCountPerRequest = 1;
+
+		struct Cache
+		{
+			std::unique_ptr<HttpClient>		   Http;
+			std::unique_ptr<BuildStorageCache> Cache;
+			Oid								   BuildsId = Oid::Zero;
+			std::string						   Description;
+			double							   LatencySec			   = -1.0;
+			uint64_t						   MaxRangeCountPerRequest = 1;
+			BuildStorageCache::Statistics	   Stats;
+			bool							   Populate = false;
+		};
+
+		std::unique_ptr<Cache> OptionalCache;
 	};
 
 	CreateRemoteStoreResult CreateRemoteStore(LoggerRef					   InLog,
@@ -260,7 +281,7 @@ namespace {
 
 		using namespace std::literals;
 
-		std::shared_ptr<RemoteProjectStore> RemoteStore;
+		CreateRemoteStoreResult Result;
 
 		if (CbObjectView File = Params["file"sv].AsObjectView(); File)
 		{
@@ -285,7 +306,9 @@ namespace {
 				std::string(OptionalBaseName),
 				ForceDisableBlocks,
 				ForceEnableTempBlocks};
-			RemoteStore = CreateFileRemoteStore(Log(), Options);
+			Result.Store				   = CreateFileRemoteStore(Log(), Options);
+			Result.LatencySec			   = 0.5 / 1000.0;	// 0.5 ms
+			Result.MaxRangeCountPerRequest = 1024u;
 		}
 
 		if (CbObjectView Cloud = Params["cloud"sv].AsObjectView(); Cloud)
@@ -363,21 +386,32 @@ namespace {
 			bool ForceDisableTempBlocks = Cloud["disabletempblocks"sv].AsBool(false);
 			bool AssumeHttp2			= Cloud["assumehttp2"sv].AsBool(false);
 
-			JupiterRemoteStoreOptions Options = {
-				RemoteStoreOptions{.MaxBlockSize = MaxBlockSize, .MaxChunksPerBlock = 1000, .MaxChunkEmbedSize = MaxChunkEmbedSize},
-				Url,
-				std::string(Namespace),
-				std::string(Bucket),
-				Key,
-				BaseKey,
-				std::string(OpenIdProvider),
-				AccessToken,
-				AuthManager,
-				OidcExePath,
-				ForceDisableBlocks,
-				ForceDisableTempBlocks,
-				AssumeHttp2};
-			RemoteStore = CreateJupiterRemoteStore(Log(), Options, TempFilePath, /*Quiet*/ false, /*Unattended*/ false, /*Hidden*/ true);
+			if (JupiterEndpointTestResult TestResult = TestJupiterEndpoint(Url, AssumeHttp2, /*Verbose*/ false); TestResult.Success)
+			{
+				Result.LatencySec			   = TestResult.LatencySeconds;
+				Result.MaxRangeCountPerRequest = TestResult.MaxRangeCountPerRequest;
+
+				JupiterRemoteStoreOptions Options = {
+					RemoteStoreOptions{.MaxBlockSize = MaxBlockSize, .MaxChunksPerBlock = 1000, .MaxChunkEmbedSize = MaxChunkEmbedSize},
+					Url,
+					std::string(Namespace),
+					std::string(Bucket),
+					Key,
+					BaseKey,
+					std::string(OpenIdProvider),
+					AccessToken,
+					AuthManager,
+					OidcExePath,
+					ForceDisableBlocks,
+					ForceDisableTempBlocks,
+					AssumeHttp2};
+				Result.Store =
+					CreateJupiterRemoteStore(Log(), Options, TempFilePath, /*Quiet*/ false, /*Unattended*/ false, /*Hidden*/ true);
+			}
+			else
+			{
+				return {nullptr, fmt::format("Unable to connect to jupiter host '{}'", Url)};
+			}
 		}
 
 		if (CbObjectView Zen = Params["zen"sv].AsObjectView(); Zen)
@@ -393,12 +427,13 @@ namespace {
 			{
 				return {nullptr, "Missing oplog"};
 			}
+
 			ZenRemoteStoreOptions Options = {
 				RemoteStoreOptions{.MaxBlockSize = MaxBlockSize, .MaxChunksPerBlock = 1000, .MaxChunkEmbedSize = MaxChunkEmbedSize},
 				std::string(Url),
 				std::string(Project),
 				std::string(Oplog)};
-			RemoteStore = CreateZenRemoteStore(Log(), Options, TempFilePath);
+			Result.Store = CreateZenRemoteStore(Log(), Options, TempFilePath);
 		}
 
 		if (CbObjectView Builds = Params["builds"sv].AsObjectView(); Builds)
@@ -471,11 +506,76 @@ namespace {
 			MemoryView MetaDataSection = Builds["metadata"sv].AsBinaryView();
 			IoBuffer   MetaData(IoBuffer::Wrap, MetaDataSection.GetData(), MetaDataSection.GetSize());
 
+			auto EnsureHttps = [](const std::string& Host, std::string_view PreferredProtocol) {
+				if (!Host.empty() && Host.find("://"sv) == std::string::npos)
+				{
+					// Assume https URL
+					return fmt::format("{}://{}"sv, PreferredProtocol, Host);
+				}
+				return Host;
+			};
+
+			Host		 = EnsureHttps(Host, "https");
+			OverrideHost = EnsureHttps(OverrideHost, "https");
+			ZenHost		 = EnsureHttps(ZenHost, "http");
+
+			std::function<HttpClientAccessToken()> TokenProvider;
+			if (!OpenIdProvider.empty())
+			{
+				TokenProvider = httpclientauth::CreateFromOpenIdProvider(AuthManager, OpenIdProvider);
+			}
+			else if (!AccessToken.empty())
+			{
+				TokenProvider = httpclientauth::CreateFromStaticToken(AccessToken);
+			}
+			else if (!OidcExePath.empty())
+			{
+				if (auto TokenProviderMaybe = httpclientauth::CreateFromOidcTokenExecutable(OidcExePath,
+																							Host.empty() ? OverrideHost : Host,
+																							/*Quiet*/ false,
+																							/*Unattended*/ false,
+																							/*Hidden*/ true);
+					TokenProviderMaybe)
+				{
+					TokenProvider = TokenProviderMaybe.value();
+				}
+			}
+
+			if (!TokenProvider)
+			{
+				TokenProvider = httpclientauth::CreateFromDefaultOpenIdProvider(AuthManager);
+			}
+
+			BuildStorageResolveResult ResolveResult;
+			{
+				HttpClientSettings ClientSettings{.LogCategory		   = "httpbuildsclient",
+												  .AccessTokenProvider = TokenProvider,
+												  .AssumeHttp2		   = AssumeHttp2,
+												  .AllowResume		   = true,
+												  .RetryCount		   = 2};
+
+				std::unique_ptr<OperationLogOutput> Output(CreateStandardLogOutput(Log()));
+
+				try
+				{
+					ResolveResult = ResolveBuildStorage(*Output,
+														ClientSettings,
+														Host,
+														OverrideHost,
+														ZenHost,
+														ZenCacheResolveMode::Discovery,
+														/*Verbose*/ false);
+				}
+				catch (const std::exception& Ex)
+				{
+					return {nullptr, fmt::format("Failed resolving storage host and cache. Reason: '{}'", Ex.what())};
+				}
+			}
+			Result.LatencySec			   = ResolveResult.Cloud.LatencySec;
+			Result.MaxRangeCountPerRequest = ResolveResult.Cloud.Caps.MaxRangeCountPerRequest;
+
 			BuildsRemoteStoreOptions Options = {
 				RemoteStoreOptions{.MaxBlockSize = MaxBlockSize, .MaxChunksPerBlock = 1000, .MaxChunkEmbedSize = MaxChunkEmbedSize},
-				Host,
-				OverrideHost,
-				ZenHost,
 				std::string(Namespace),
 				std::string(Bucket),
 				BuildId,
@@ -485,25 +585,43 @@ namespace {
 				OidcExePath,
 				ForceDisableBlocks,
 				ForceDisableTempBlocks,
-				AssumeHttp2,
-				PopulateCache,
 				MetaData,
 				MaximumInMemoryDownloadSize};
-			RemoteStore = CreateJupiterBuildsRemoteStore(Log(),
-														 Options,
-														 TempFilePath,
-														 /*Quiet*/ false,
-														 /*Unattended*/ false,
-														 /*Hidden*/ true,
-														 GetTinyWorkerPool(EWorkloadType::Background));
+			Result.Store = CreateJupiterBuildsRemoteStore(Log(), ResolveResult, std::move(TokenProvider), Options, TempFilePath);
+
+			if (!ResolveResult.Cache.Address.empty())
+			{
+				Result.OptionalCache = std::make_unique<CreateRemoteStoreResult::Cache>();
+
+				HttpClientSettings CacheClientSettings{.LogCategory					= "httpcacheclient",
+													   .ConnectTimeout				= std::chrono::milliseconds{3000},
+													   .Timeout						= std::chrono::milliseconds{30000},
+													   .AssumeHttp2					= ResolveResult.Cache.AssumeHttp2,
+													   .AllowResume					= true,
+													   .RetryCount					= 0,
+													   .MaximumInMemoryDownloadSize = MaximumInMemoryDownloadSize};
+
+				Result.OptionalCache->Http		 = std::make_unique<HttpClient>(ResolveResult.Cache.Address, CacheClientSettings);
+				Result.OptionalCache->Cache		 = CreateZenBuildStorageCache(*Result.OptionalCache->Http,
+																		  Result.OptionalCache->Stats,
+																		  Namespace,
+																		  Bucket,
+																		  TempFilePath,
+																		  GetTinyWorkerPool(EWorkloadType::Background));
+				Result.OptionalCache->BuildsId	 = BuildId;
+				Result.OptionalCache->LatencySec = ResolveResult.Cache.LatencySec;
+				Result.OptionalCache->MaxRangeCountPerRequest = ResolveResult.Cache.Caps.MaxRangeCountPerRequest;
+				Result.OptionalCache->Populate				  = PopulateCache;
+				Result.OptionalCache->Description =
+					fmt::format("[zenserver] {} namespace {} bucket {}", ResolveResult.Cache.Address, Namespace, Bucket);
+			}
 		}
-
-		if (!RemoteStore)
+		if (!Result.Store)
 		{
 			return {nullptr, "Unknown remote store type"};
 		}
 
-		return {std::move(RemoteStore), ""};
+		return Result;
 	}
 
 	std::pair<HttpResponseCode, std::string> ConvertResult(const RemoteProjectStore::Result& Result)
@@ -714,8 +832,8 @@ HttpProjectService::HandleRequest(HttpServerRequest& Request)
 	}
 }
 
-void
-HttpProjectService::HandleStatsRequest(HttpServerRequest& HttpReq)
+CbObject
+HttpProjectService::CollectStats()
 {
 	ZEN_TRACE_CPU("ProjectService::Stats");
 
@@ -781,7 +899,13 @@ HttpProjectService::HandleStatsRequest(HttpServerRequest& HttpReq)
 	}
 	Cbo.EndObject();
 
-	return HttpReq.WriteResponse(HttpResponseCode::OK, Cbo.Save());
+	return Cbo.Save();
+}
+
+void
+HttpProjectService::HandleStatsRequest(HttpServerRequest& HttpReq)
+{
+	HttpReq.WriteResponse(HttpResponseCode::OK, CollectStats());
 }
 
 void
@@ -2373,15 +2497,19 @@ HttpProjectService::HandleOplogSaveRequest(HttpRouterRequest& Req)
 		tsl::robin_set<IoHash, IoHash::Hasher> Attachments;
 
 		auto HasAttachment = [this](const IoHash& RawHash) { return m_CidStore.ContainsChunk(RawHash); };
-		auto OnNeedBlock   = [&AttachmentsLock, &Attachments](const IoHash& BlockHash, const std::vector<IoHash>&& ChunkHashes) {
+		auto OnNeedBlock   = [&AttachmentsLock, &Attachments](ThinChunkBlockDescription&& ThinBlockDescription,
+															  std::vector<uint32_t>&&	  NeededChunkIndexes) {
 			  RwLock::ExclusiveLockScope _(AttachmentsLock);
-			  if (BlockHash != IoHash::Zero)
+			  if (ThinBlockDescription.BlockHash != IoHash::Zero)
 			  {
-				  Attachments.insert(BlockHash);
+				  Attachments.insert(ThinBlockDescription.BlockHash);
 			  }
 			  else
 			  {
-				  Attachments.insert(ChunkHashes.begin(), ChunkHashes.end());
+				  for (uint32_t ChunkIndex : NeededChunkIndexes)
+				  {
+					  Attachments.insert(ThinBlockDescription.ChunkRawHashes[ChunkIndex]);
+				  }
 			  }
 		};
 		auto OnNeedAttachment = [&AttachmentsLock, &Attachments](const IoHash& RawHash) {
@@ -2687,36 +2815,39 @@ HttpProjectService::HandleRpcRequest(HttpRouterRequest& Req)
 				bool		 CleanOplog				  = Params["clean"].AsBool(false);
 				bool		 BoostWorkerCount		  = Params["boostworkercount"].AsBool(false);
 				bool		 BoostWorkerMemory		  = Params["boostworkermemory"sv].AsBool(false);
-
-				CreateRemoteStoreResult RemoteStoreResult = CreateRemoteStore(Log(),
-																			  Params,
-																			  m_AuthMgr,
-																			  MaxBlockSize,
-																			  MaxChunkEmbedSize,
-																			  GetMaxMemoryBufferSize(MaxBlockSize, BoostWorkerMemory),
-																			  Oplog->TempPath());
-
-				if (RemoteStoreResult.Store == nullptr)
+				EPartialBlockRequestMode PartialBlockRequestMode =
+					PartialBlockRequestModeFromString(Params["partialblockrequestmode"sv].AsString("true"));
+
+				std::shared_ptr<CreateRemoteStoreResult> RemoteStoreResult =
+					std::make_shared<CreateRemoteStoreResult>(CreateRemoteStore(Log(),
+																				Params,
+																				m_AuthMgr,
+																				MaxBlockSize,
+																				MaxChunkEmbedSize,
+																				GetMaxMemoryBufferSize(MaxBlockSize, BoostWorkerMemory),
+																				Oplog->TempPath()));
+
+				if (RemoteStoreResult->Store == nullptr)
 				{
-					return HttpReq.WriteResponse(HttpResponseCode::BadRequest, HttpContentType::kText, RemoteStoreResult.Description);
+					return HttpReq.WriteResponse(HttpResponseCode::BadRequest, HttpContentType::kText, RemoteStoreResult->Description);
 				}
-				std::shared_ptr<RemoteProjectStore> RemoteStore = std::move(RemoteStoreResult.Store);
-				RemoteProjectStore::RemoteStoreInfo StoreInfo	= RemoteStore->GetInfo();
 
 				JobId JobId = m_JobQueue.QueueJob(
 					fmt::format("Import oplog '{}/{}'", Project->Identifier, Oplog->OplogId()),
 					[this,
-					 ChunkStore		   = &m_CidStore,
-					 ActualRemoteStore = std::move(RemoteStore),
+					 RemoteStoreResult = std::move(RemoteStoreResult),
 					 Oplog,
 					 Force,
 					 IgnoreMissingAttachments,
 					 CleanOplog,
+					 PartialBlockRequestMode,
 					 BoostWorkerCount](JobContext& Context) {
-						Context.ReportMessage(fmt::format("Loading oplog '{}/{}' from {}",
-														  Oplog->GetOuterProjectIdentifier(),
-														  Oplog->OplogId(),
-														  ActualRemoteStore->GetInfo().Description));
+						Context.ReportMessage(
+							fmt::format("Loading oplog '{}/{}'\n    Host: {}\n    Cache: {}",
+										Oplog->GetOuterProjectIdentifier(),
+										Oplog->OplogId(),
+										RemoteStoreResult->Store->GetInfo().Description,
+										RemoteStoreResult->OptionalCache ? RemoteStoreResult->OptionalCache->Description : "<none>"));
 
 						Ref<TransferThreadWorkers> Workers = GetThreadWorkers(BoostWorkerCount, /*SingleThreaded*/ false);
 
@@ -2724,16 +2855,26 @@ HttpProjectService::HandleRpcRequest(HttpRouterRequest& Req)
 						WorkerThreadPool& NetworkWorkerPool = Workers->GetNetworkPool();
 
 						Context.ReportMessage(fmt::format("{}", Workers->GetWorkersInfo()));
-
-						RemoteProjectStore::Result Result	= LoadOplog(m_CidStore,
-																		*ActualRemoteStore,
-																		*Oplog,
-																		NetworkWorkerPool,
-																		WorkerPool,
-																		Force,
-																		IgnoreMissingAttachments,
-																		CleanOplog,
-																		&Context);
+						RemoteProjectStore::Result Result	= LoadOplog(LoadOplogContext{
+							  .ChunkStore	 = m_CidStore,
+							  .RemoteStore	 = *RemoteStoreResult->Store,
+							  .OptionalCache = RemoteStoreResult->OptionalCache ? RemoteStoreResult->OptionalCache->Cache.get() : nullptr,
+							  .CacheBuildId	 = RemoteStoreResult->OptionalCache ? RemoteStoreResult->OptionalCache->BuildsId : Oid::Zero,
+							  .OptionalCacheStats = RemoteStoreResult->OptionalCache ? &RemoteStoreResult->OptionalCache->Stats : nullptr,
+							  .Oplog			  = *Oplog,
+							  .NetworkWorkerPool  = NetworkWorkerPool,
+							  .WorkerPool		  = WorkerPool,
+							  .ForceDownload	  = Force,
+							  .IgnoreMissingAttachments = IgnoreMissingAttachments,
+							  .CleanOplog				= CleanOplog,
+							  .PartialBlockRequestMode	= PartialBlockRequestMode,
+							  .PopulateCache   = RemoteStoreResult->OptionalCache ? RemoteStoreResult->OptionalCache->Populate : false,
+							  .StoreLatencySec = RemoteStoreResult->LatencySec,
+							  .StoreMaxRangeCountPerRequest = RemoteStoreResult->MaxRangeCountPerRequest,
+							  .CacheLatencySec = RemoteStoreResult->OptionalCache ? RemoteStoreResult->OptionalCache->LatencySec : -1.0,
+							  .CacheMaxRangeCountPerRequest =
+								  RemoteStoreResult->OptionalCache ? RemoteStoreResult->OptionalCache->MaxRangeCountPerRequest : 0,
+							  .OptionalJobContext = &Context});
 						auto					   Response = ConvertResult(Result);
 						ZEN_INFO("LoadOplog: Status: {} '{}'", ToString(Response.first), Response.second);
 						if (!IsHttpSuccessCode(Response.first))
diff --git a/src/zenserver/storage/projectstore/httpprojectstore.h b/src/zenserver/storage/projectstore/httpprojectstore.h
index 1d71329b1..a1f649ed6 100644
--- a/src/zenserver/storage/projectstore/httpprojectstore.h
+++ b/src/zenserver/storage/projectstore/httpprojectstore.h
@@ -51,8 +51,9 @@ public:
 	virtual const char* BaseUri() const override;
 	virtual void		HandleRequest(HttpServerRequest& Request) override;
 
-	virtual void HandleStatsRequest(HttpServerRequest& Request) override;
-	virtual void HandleStatusRequest(HttpServerRequest& Request) override;
+	virtual CbObject CollectStats() override;
+	virtual void	 HandleStatsRequest(HttpServerRequest& Request) override;
+	virtual void	 HandleStatusRequest(HttpServerRequest& Request) override;
 
 private:
 	struct ProjectStats
diff --git a/src/zenserver/storage/storageconfig.cpp b/src/zenserver/storage/storageconfig.cpp
index 99d0f89d7..ad1fb88ea 100644
--- a/src/zenserver/storage/storageconfig.cpp
+++ b/src/zenserver/storage/storageconfig.cpp
@@ -804,6 +804,7 @@ ZenStorageServerCmdLineOptions::AddCacheOptions(cxxopts::Options& options, ZenSt
 					   cxxopts::value<uint64_t>(ServerOptions.StructuredCacheConfig.MemMaxAgeSeconds)->default_value("86400"),
 					   "");
 
+	options.add_option("compute", "", "lie-cpus", "Lie to upstream about CPU capabilities", cxxopts::value<int>(ServerOptions.LieCpu), "");
 	options.add_option("cache",
 					   "",
 					   "cache-bucket-maxblocksize",
diff --git a/src/zenserver/storage/storageconfig.h b/src/zenserver/storage/storageconfig.h
index bc2dc78c9..d935ed8b3 100644
--- a/src/zenserver/storage/storageconfig.h
+++ b/src/zenserver/storage/storageconfig.h
@@ -1,4 +1,5 @@
 // Copyright Epic Games, Inc. All Rights Reserved.
+#pragma once
 
 #include "config/config.h"
 
@@ -156,6 +157,7 @@ struct ZenStorageServerConfig : public ZenServerConfig
 	ZenWorkspacesConfig		 WorksSpacesConfig;
 	std::filesystem::path	 PluginsConfigFile;	 // Path to plugins config file
 	bool					 ObjectStoreEnabled = false;
+	bool					 ComputeEnabled		= true;
 	std::string				 ScrubOptions;
 	bool					 RestrictContentTypes = false;
 };
diff --git a/src/zenserver/storage/workspaces/httpworkspaces.cpp b/src/zenserver/storage/workspaces/httpworkspaces.cpp
index dc4cc7e69..785dd62f0 100644
--- a/src/zenserver/storage/workspaces/httpworkspaces.cpp
+++ b/src/zenserver/storage/workspaces/httpworkspaces.cpp
@@ -110,8 +110,8 @@ HttpWorkspacesService::HandleRequest(HttpServerRequest& Request)
 	}
 }
 
-void
-HttpWorkspacesService::HandleStatsRequest(HttpServerRequest& HttpReq)
+CbObject
+HttpWorkspacesService::CollectStats()
 {
 	ZEN_TRACE_CPU("WorkspacesService::Stats");
 	CbObjectWriter Cbo;
@@ -150,7 +150,13 @@ HttpWorkspacesService::HandleStatsRequest(HttpServerRequest& HttpReq)
 	}
 	Cbo.EndObject();
 
-	return HttpReq.WriteResponse(HttpResponseCode::OK, Cbo.Save());
+	return Cbo.Save();
+}
+
+void
+HttpWorkspacesService::HandleStatsRequest(HttpServerRequest& HttpReq)
+{
+	HttpReq.WriteResponse(HttpResponseCode::OK, CollectStats());
 }
 
 void
diff --git a/src/zenserver/storage/workspaces/httpworkspaces.h b/src/zenserver/storage/workspaces/httpworkspaces.h
index 888a34b4d..7c5ddeff1 100644
--- a/src/zenserver/storage/workspaces/httpworkspaces.h
+++ b/src/zenserver/storage/workspaces/httpworkspaces.h
@@ -29,8 +29,9 @@ public:
 	virtual const char* BaseUri() const override;
 	virtual void		HandleRequest(HttpServerRequest& Request) override;
 
-	virtual void HandleStatsRequest(HttpServerRequest& Request) override;
-	virtual void HandleStatusRequest(HttpServerRequest& Request) override;
+	virtual CbObject CollectStats() override;
+	virtual void	 HandleStatsRequest(HttpServerRequest& Request) override;
+	virtual void	 HandleStatusRequest(HttpServerRequest& Request) override;
 
 private:
 	struct WorkspacesStats
diff --git a/src/zenserver/storage/zenstorageserver.cpp b/src/zenserver/storage/zenstorageserver.cpp
index ea05bd155..f43bb9987 100644
--- a/src/zenserver/storage/zenstorageserver.cpp
+++ b/src/zenserver/storage/zenstorageserver.cpp
@@ -33,6 +33,7 @@
 #include <zenutil/service.h>
 #include <zenutil/workerpools.h>
 #include <zenutil/zenserverprocess.h>
+#include "../sessions/sessions.h"
 
 #if ZEN_PLATFORM_WINDOWS
 #	include <zencore/windows.h>
@@ -133,7 +134,6 @@ void
 ZenStorageServer::RegisterServices()
 {
 	m_Http->RegisterService(*m_AuthService);
-	m_Http->RegisterService(m_StatsService);
 	m_Http->RegisterService(m_TestService);	 // NOTE: this is intentionally not limited to test mode as it's useful for diagnostics
 
 #if ZEN_WITH_TESTS
@@ -160,6 +160,11 @@ ZenStorageServer::RegisterServices()
 		m_Http->RegisterService(*m_HttpWorkspacesService);
 	}
 
+	if (m_HttpSessionsService)
+	{
+		m_Http->RegisterService(*m_HttpSessionsService);
+	}
+
 	m_FrontendService = std::make_unique<HttpFrontendService>(m_ContentRoot, m_StatusService);
 
 	if (m_FrontendService)
@@ -182,6 +187,18 @@ ZenStorageServer::RegisterServices()
 #endif	// ZEN_WITH_VFS
 
 	m_Http->RegisterService(*m_AdminService);
+
+	if (m_ApiService)
+	{
+		m_Http->RegisterService(*m_ApiService);
+	}
+
+#if ZEN_WITH_COMPUTE_SERVICES
+	if (m_HttpComputeService)
+	{
+		m_Http->RegisterService(*m_HttpComputeService);
+	}
+#endif
 }
 
 void
@@ -227,6 +244,11 @@ ZenStorageServer::InitializeServices(const ZenStorageServerConfig& ServerOptions
 									  *m_Workspaces));
 	}
 
+	{
+		m_SessionsService	  = std::make_unique<SessionsService>();
+		m_HttpSessionsService = std::make_unique<HttpSessionsService>(m_StatusService, m_StatsService, *m_SessionsService);
+	}
+
 	if (ServerOptions.BuildStoreConfig.Enabled)
 	{
 		CidStoreConfiguration BuildCidConfig;
@@ -273,6 +295,16 @@ ZenStorageServer::InitializeServices(const ZenStorageServerConfig& ServerOptions
 		m_BuildStoreService = std::make_unique<HttpBuildStoreService>(m_StatusService, m_StatsService, *m_BuildStore);
 	}
 
+#if ZEN_WITH_COMPUTE_SERVICES
+	if (ServerOptions.ComputeEnabled)
+	{
+		ZEN_OTEL_SPAN("InitializeComputeService");
+
+		m_HttpComputeService =
+			std::make_unique<compute::HttpComputeService>(*m_CidStore, m_StatsService, ServerOptions.DataDir / "functions");
+	}
+#endif
+
 #if ZEN_WITH_VFS
 	m_VfsServiceImpl = std::make_unique<VfsServiceImpl>();
 	m_VfsServiceImpl->AddService(Ref<ProjectStore>(m_ProjectStore));
@@ -305,13 +337,15 @@ ZenStorageServer::InitializeServices(const ZenStorageServerConfig& ServerOptions
 							   .AttachmentPassCount				  = ServerOptions.GcConfig.AttachmentPassCount};
 	m_GcScheduler.Initialize(GcConfig);
 
+	m_ApiService = std::make_unique<HttpApiService>(*m_Http);
+
 	// 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(),
 		[this]() { Flush(); },
-		HttpAdminService::LogPaths{.AbsLogPath	 = ServerOptions.AbsLogFile,
+		HttpAdminService::LogPaths{.AbsLogPath	 = ServerOptions.LoggingConfig.AbsLogFile,
 								   .HttpLogPath	 = ServerOptions.DataDir / "logs" / "http.log",
 								   .CacheLogPath = ServerOptions.DataDir / "logs" / "z$.log"},
 		ServerOptions);
@@ -689,6 +723,15 @@ ZenStorageServer::Run()
 
 	ZEN_INFO(ZEN_APP_NAME " now running (pid: {})", GetCurrentProcessId());
 
+	if (m_FrontendService)
+	{
+		ZEN_INFO("frontend link: {}", m_Http->GetServiceUri(m_FrontendService.get()));
+	}
+	else
+	{
+		ZEN_INFO("frontend service disabled");
+	}
+
 #if ZEN_PLATFORM_WINDOWS
 	if (zen::windows::IsRunningOnWine())
 	{
@@ -796,6 +839,8 @@ ZenStorageServer::Cleanup()
 			m_IoRunner.join();
 		}
 
+		ShutdownServices();
+
 		if (m_Http)
 		{
 			m_Http->Close();
@@ -811,6 +856,10 @@ ZenStorageServer::Cleanup()
 
 		Flush();
 
+#if ZEN_WITH_COMPUTE_SERVICES
+		m_HttpComputeService.reset();
+#endif
+
 		m_AdminService.reset();
 		m_VfsService.reset();
 		m_VfsServiceImpl.reset();
@@ -826,6 +875,8 @@ ZenStorageServer::Cleanup()
 		m_UpstreamCache.reset();
 		m_CacheStore = {};
 
+		m_HttpSessionsService.reset();
+		m_SessionsService.reset();
 		m_HttpWorkspacesService.reset();
 		m_Workspaces.reset();
 		m_HttpProjectService.reset();
diff --git a/src/zenserver/storage/zenstorageserver.h b/src/zenserver/storage/zenstorageserver.h
index 5ccb587d6..d625f869c 100644
--- a/src/zenserver/storage/zenstorageserver.h
+++ b/src/zenserver/storage/zenstorageserver.h
@@ -6,11 +6,13 @@
 
 #include <zenhttp/auth/authmgr.h>
 #include <zenhttp/auth/authservice.h>
+#include <zenhttp/httpapiservice.h>
 #include <zenhttp/httptest.h>
 #include <zenstore/cache/structuredcachestore.h>
 #include <zenstore/gc.h>
 #include <zenstore/projectstore.h>
 
+#include "../sessions/httpsessions.h"
 #include "admin/admin.h"
 #include "buildstore/httpbuildstore.h"
 #include "cache/httpstructuredcache.h"
@@ -23,6 +25,10 @@
 #include "vfs/vfsservice.h"
 #include "workspaces/httpworkspaces.h"
 
+#if ZEN_WITH_COMPUTE_SERVICES
+#	include <zencompute/httpcomputeservice.h>
+#endif
+
 namespace zen {
 
 class ZenStorageServer : public ZenServerBase
@@ -34,11 +40,6 @@ public:
 	ZenStorageServer();
 	~ZenStorageServer();
 
-	void SetDedicatedMode(bool State) { m_IsDedicatedMode = State; }
-	void SetTestMode(bool State) { m_TestMode = State; }
-	void SetDataRoot(std::filesystem::path Root) { m_DataRoot = Root; }
-	void SetContentRoot(std::filesystem::path Root) { m_ContentRoot = Root; }
-
 	int	 Initialize(const ZenStorageServerConfig& ServerOptions, ZenServerState::ZenServerEntry* ServerEntry);
 	void Run();
 	void Cleanup();
@@ -48,14 +49,9 @@ private:
 	void InitializeStructuredCache(const ZenStorageServerConfig& ServerOptions);
 	void Flush();
 
-	bool				  m_IsDedicatedMode		   = false;
-	bool				  m_TestMode			   = false;
-	bool				  m_DebugOptionForcedCrash = false;
-	std::string			  m_StartupScrubOptions;
-	CbObject			  m_RootManifest;
-	std::filesystem::path m_DataRoot;
-	std::filesystem::path m_ContentRoot;
-	asio::steady_timer	  m_StateMarkerTimer{m_IoContext};
+	std::string		   m_StartupScrubOptions;
+	CbObject		   m_RootManifest;
+	asio::steady_timer m_StateMarkerTimer{m_IoContext};
 
 	void EnqueueStateMarkerTimer();
 	void CheckStateMarker();
@@ -67,7 +63,6 @@ private:
 	void InitializeServices(const ZenStorageServerConfig& ServerOptions);
 	void RegisterServices();
 
-	HttpStatsService				  m_StatsService;
 	std::unique_ptr<JobQueue>		  m_JobQueue;
 	GcManager						  m_GcManager;
 	GcScheduler						  m_GcScheduler{m_GcManager};
@@ -87,6 +82,8 @@ private:
 	std::unique_ptr<HttpProjectService>			m_HttpProjectService;
 	std::unique_ptr<Workspaces>					m_Workspaces;
 	std::unique_ptr<HttpWorkspacesService>		m_HttpWorkspacesService;
+	std::unique_ptr<SessionsService>			m_SessionsService;
+	std::unique_ptr<HttpSessionsService>		m_HttpSessionsService;
 	std::unique_ptr<UpstreamCache>				m_UpstreamCache;
 	std::unique_ptr<HttpUpstreamService>		m_UpstreamService;
 	std::unique_ptr<HttpStructuredCacheService> m_StructuredCacheService;
@@ -95,6 +92,11 @@ private:
 	std::unique_ptr<HttpBuildStoreService>		m_BuildStoreService;
 	std::unique_ptr<VfsService>					m_VfsService;
 	std::unique_ptr<HttpAdminService>			m_AdminService;
+	std::unique_ptr<HttpApiService>				m_ApiService;
+
+#if ZEN_WITH_COMPUTE_SERVICES
+	std::unique_ptr<compute::HttpComputeService> m_HttpComputeService;
+#endif
 };
 
 struct ZenStorageServerConfigurator;