projectstore refactor (#531)

* convert ProjectStore::GetProjectFiles to not use http return codes

* convert ProjectStore::GetProjectChunkInfos to not use http return codes

* convert ProjectStore::GetChunkInfo to not use http return codes

* convert ProjectStore::GetChunkRange to not use http return codes

* convert ProjectStore::GetChunk to not use http return codes

* convert ProjectStore::PutChunk to not use http return codes

* convert ProjectStore::WriteOplog to not use http return codes

* convert ProjectStore::ReadOplog to not use http return codes

1 files changed, 310 insertions, 172 deletions

diff --git a/src/zenserver/projectstore/httpprojectstore.cpp b/src/zenserver/projectstore/httpprojectstore.cpp
index 48086b863..2a1bf9a5e 100644
--- a/src/zenserver/projectstore/httpprojectstore.cpp
+++ b/src/zenserver/projectstore/httpprojectstore.cpp
@@ -4,6 +4,7 @@
 
 #include "oplogreferencedset.h"
 #include "projectstore.h"
+#include "remoteprojectstore.h"
 
 #include <zencore/compactbinarybuilder.h>
 #include <zencore/compactbinarypackage.h>
@@ -667,38 +668,35 @@ HttpProjectService::HandleFilesRequest(HttpRouterRequest& Req)
 		}
 	}
 
-	CbObject								 ResponsePayload;
-	std::pair<HttpResponseCode, std::string> Result =
-		m_ProjectStore->GetProjectFiles(ProjectId, OplogId, WantedFieldNames, ResponsePayload);
-	if (Result.first == HttpResponseCode::OK)
+	Ref<ProjectStore::Project> Project = m_ProjectStore->OpenProject(ProjectId);
+	if (!Project)
 	{
-		if (HttpReq.AcceptContentType() == HttpContentType::kCompressedBinary)
-		{
-			CompositeBuffer Payload = CompressedBuffer::Compress(ResponsePayload.GetBuffer()).GetCompressed();
-			return HttpReq.WriteResponse(HttpResponseCode::OK, HttpContentType::kCompressedBinary, Payload);
-		}
-		else
-		{
-			return HttpReq.WriteResponse(HttpResponseCode::OK, ResponsePayload);
-		}
+		return HttpReq.WriteResponse(HttpResponseCode::NotFound,
+									 HttpContentType::kText,
+									 fmt::format("Project files request for unknown project '{}'", ProjectId));
 	}
-	else
+	Project->TouchProject();
+
+	Ref<ProjectStore::Oplog> FoundLog = Project->OpenOplog(OplogId, /*AllowCompact*/ true, /*VerifyPathOnDisk*/ true);
+	if (!FoundLog)
 	{
-		if (Result.first == HttpResponseCode::BadRequest)
-		{
-			m_ProjectStats.BadRequestCount++;
-		}
-		ZEN_DEBUG("Request {}: '{}' failed with {}. Reason: `{}`",
-				  ToString(HttpReq.RequestVerb()),
-				  HttpReq.QueryString(),
-				  static_cast<int>(Result.first),
-				  Result.second);
+		return HttpReq.WriteResponse(HttpResponseCode::NotFound,
+									 HttpContentType::kText,
+									 fmt::format("Project files for unknown oplog '{}/{}'", ProjectId, OplogId));
+	}
+	Project->TouchOplog(OplogId);
+
+	CbObject ResponsePayload = ProjectStore::GetProjectFiles(Log(), *Project, *FoundLog, WantedFieldNames);
+
+	if (HttpReq.AcceptContentType() == HttpContentType::kCompressedBinary)
+	{
+		CompositeBuffer Payload = CompressedBuffer::Compress(ResponsePayload.GetBuffer()).GetCompressed();
+		return HttpReq.WriteResponse(HttpResponseCode::OK, HttpContentType::kCompressedBinary, Payload);
 	}
-	if (Result.second.empty())
+	else
 	{
-		return HttpReq.WriteResponse(Result.first);
+		return HttpReq.WriteResponse(HttpResponseCode::OK, ResponsePayload);
 	}
-	return HttpReq.WriteResponse(Result.first, HttpContentType::kText, Result.second);
 }
 
 void
@@ -731,38 +729,34 @@ HttpProjectService::HandleChunkInfosRequest(HttpRouterRequest& Req)
 		WantedFieldNames.insert("rawsize");
 	}
 
-	CbObject								 ResponsePayload;
-	std::pair<HttpResponseCode, std::string> Result =
-		m_ProjectStore->GetProjectChunkInfos(ProjectId, OplogId, WantedFieldNames, ResponsePayload);
-	if (Result.first == HttpResponseCode::OK)
+	Ref<ProjectStore::Project> Project = m_ProjectStore->OpenProject(ProjectId);
+	if (!Project)
+	{
+		return HttpReq.WriteResponse(HttpResponseCode::NotFound,
+									 HttpContentType::kText,
+									 fmt::format("Chunk infos request for unknown project '{}'", ProjectId));
+	}
+	Project->TouchProject();
+
+	Ref<ProjectStore::Oplog> FoundLog = Project->OpenOplog(OplogId, /*AllowCompact*/ true, /*VerifyPathOnDisk*/ true);
+	if (!FoundLog)
 	{
-		if (HttpReq.AcceptContentType() == HttpContentType::kCompressedBinary)
-		{
-			CompositeBuffer Payload = CompressedBuffer::Compress(ResponsePayload.GetBuffer()).GetCompressed();
-			return HttpReq.WriteResponse(HttpResponseCode::OK, HttpContentType::kCompressedBinary, Payload);
-		}
-		else
-		{
-			return HttpReq.WriteResponse(HttpResponseCode::OK, ResponsePayload);
-		}
+		return HttpReq.WriteResponse(HttpResponseCode::NotFound,
+									 HttpContentType::kText,
+									 fmt::format("Chunk infos for unknown oplog '{}/{}'", ProjectId, OplogId));
 	}
-	else
+	Project->TouchOplog(OplogId);
+
+	CbObject ResponsePayload = ProjectStore::GetProjectChunkInfos(Log(), *Project, *FoundLog, WantedFieldNames);
+	if (HttpReq.AcceptContentType() == HttpContentType::kCompressedBinary)
 	{
-		if (Result.first == HttpResponseCode::BadRequest)
-		{
-			m_ProjectStats.BadRequestCount++;
-		}
-		ZEN_DEBUG("Request {}: '{}' failed with {}. Reason: `{}`",
-				  ToString(HttpReq.RequestVerb()),
-				  HttpReq.QueryString(),
-				  static_cast<int>(Result.first),
-				  Result.second);
+		CompositeBuffer Payload = CompressedBuffer::Compress(ResponsePayload.GetBuffer()).GetCompressed();
+		return HttpReq.WriteResponse(HttpResponseCode::OK, HttpContentType::kCompressedBinary, Payload);
 	}
-	if (Result.second.empty())
+	else
 	{
-		return HttpReq.WriteResponse(Result.first);
+		return HttpReq.WriteResponse(HttpResponseCode::OK, ResponsePayload);
 	}
-	return HttpReq.WriteResponse(Result.first, HttpContentType::kText, Result.second);
 }
 
 void
@@ -776,35 +770,48 @@ HttpProjectService::HandleChunkInfoRequest(HttpRouterRequest& Req)
 	const auto& OplogId	  = Req.GetCapture(2);
 	const auto& ChunkId	  = Req.GetCapture(3);
 
-	CbObject								 ResponsePayload;
-	std::pair<HttpResponseCode, std::string> Result = m_ProjectStore->GetChunkInfo(ProjectId, OplogId, ChunkId, ResponsePayload);
-	if (Result.first == HttpResponseCode::OK)
+	Ref<ProjectStore::Project> Project = m_ProjectStore->OpenProject(ProjectId);
+	if (!Project)
 	{
-		m_ProjectStats.ChunkHitCount++;
-		return HttpReq.WriteResponse(HttpResponseCode::OK, ResponsePayload);
+		return HttpReq.WriteResponse(HttpResponseCode::NotFound,
+									 HttpContentType::kText,
+									 fmt::format("Chunk info request for unknown project '{}'", ProjectId));
 	}
-	else if (Result.first == HttpResponseCode::NotFound)
+	Project->TouchProject();
+
+	Ref<ProjectStore::Oplog> FoundLog = Project->OpenOplog(OplogId, /*AllowCompact*/ true, /*VerifyPathOnDisk*/ true);
+	if (!FoundLog)
 	{
-		m_ProjectStats.ChunkMissCount++;
-		ZEN_DEBUG("chunk - '{}/{}/{}' MISSING", ProjectId, OplogId, ChunkId);
+		return HttpReq.WriteResponse(HttpResponseCode::NotFound,
+									 HttpContentType::kText,
+									 fmt::format("Chunk info for unknown oplog '{}/{}'", ProjectId, OplogId));
 	}
-	else
+	Project->TouchOplog(OplogId);
+
+	if (ChunkId.size() != 2 * sizeof(Oid::OidBits))
 	{
-		if (Result.first == HttpResponseCode::BadRequest)
-		{
-			m_ProjectStats.BadRequestCount++;
-		}
-		ZEN_DEBUG("Request {}: '{}' failed with {}. Reason: `{}`",
-				  ToString(HttpReq.RequestVerb()),
-				  HttpReq.QueryString(),
-				  static_cast<int>(Result.first),
-				  Result.second);
+		m_ProjectStats.BadRequestCount++;
+		return HttpReq.WriteResponse(HttpResponseCode::BadRequest,
+									 HttpContentType::kText,
+									 fmt::format("Chunk info request for invalid chunk id '{}/{}'/'{}'", ProjectId, OplogId, ChunkId));
+	}
+
+	const Oid Obj = Oid::FromHexString(ChunkId);
+
+	CbObject ResponsePayload = ProjectStore::GetChunkInfo(Log(), *Project, *FoundLog, Obj);
+	if (ResponsePayload)
+	{
+		m_ProjectStats.ChunkHitCount++;
+		return HttpReq.WriteResponse(HttpResponseCode::OK, ResponsePayload);
 	}
-	if (Result.second.empty())
+	else
 	{
-		return HttpReq.WriteResponse(Result.first);
+		m_ProjectStats.ChunkMissCount++;
+		ZEN_DEBUG("chunk - '{}/{}/{}' MISSING", ProjectId, OplogId, ChunkId);
+		return HttpReq.WriteResponse(HttpResponseCode::NotFound,
+									 HttpContentType::kText,
+									 fmt::format("Chunk info for unknown chunk '{}/{}/{}'", ProjectId, OplogId, ChunkId));
 	}
-	return HttpReq.WriteResponse(Result.first, HttpContentType::kText, Result.second);
 }
 
 void
@@ -849,40 +856,65 @@ HttpProjectService::HandleChunkByIdRequest(HttpRouterRequest& Req)
 		}
 	}
 
-	HttpContentType AcceptType = HttpReq.AcceptContentType();
-
-	CompositeBuffer							 Chunk;
-	HttpContentType							 ContentType;
-	std::pair<HttpResponseCode, std::string> Result =
-		m_ProjectStore->GetChunkRange(ProjectId, OplogId, ChunkId, Offset, Size, AcceptType, Chunk, ContentType, nullptr);
-	if (Result.first == HttpResponseCode::OK)
+	Ref<ProjectStore::Project> Project = m_ProjectStore->OpenProject(ProjectId);
+	if (!Project)
 	{
-		m_ProjectStats.ChunkHitCount++;
-		ZEN_DEBUG("chunk - '{}/{}/{}' '{}'", ProjectId, OplogId, ChunkId, ToString(ContentType));
-		return HttpReq.WriteResponse(HttpResponseCode::OK, ContentType, Chunk);
+		return HttpReq.WriteResponse(HttpResponseCode::NotFound,
+									 HttpContentType::kText,
+									 fmt::format("Chunk request for unknown project '{}'", ProjectId));
 	}
-	else if (Result.first == HttpResponseCode::NotFound)
+	Project->TouchProject();
+
+	Ref<ProjectStore::Oplog> FoundLog = Project->OpenOplog(OplogId, /*AllowCompact*/ false, /*VerifyPathOnDisk*/ false);
+	if (!FoundLog)
 	{
-		m_ProjectStats.ChunkMissCount++;
-		ZEN_DEBUG("chunk - '{}/{}/{}' MISSING", ProjectId, OplogId, ChunkId);
+		return HttpReq.WriteResponse(HttpResponseCode::NotFound,
+									 HttpContentType::kText,
+									 fmt::format("Chunk request for unknown oplog '{}/{}'", ProjectId, OplogId));
 	}
-	else
+	Project->TouchOplog(OplogId);
+
+	if (ChunkId.size() != 2 * sizeof(Oid::OidBits))
 	{
-		if (Result.first == HttpResponseCode::BadRequest)
-		{
-			m_ProjectStats.BadRequestCount++;
-		}
-		ZEN_DEBUG("Request {}: '{}' failed with {}. Reason: `{}`",
-				  ToString(HttpReq.RequestVerb()),
-				  HttpReq.QueryString(),
-				  static_cast<int>(Result.first),
-				  Result.second);
+		m_ProjectStats.BadRequestCount++;
+		return HttpReq.WriteResponse(HttpResponseCode::BadRequest,
+									 HttpContentType::kText,
+									 fmt::format("Chunk request for invalid chunk id '{}/{}/{}'", ProjectId, OplogId, ChunkId));
 	}
-	if (Result.second.empty())
+
+	const Oid Obj = Oid::FromHexString(ChunkId);
+
+	HttpContentType AcceptType = HttpReq.AcceptContentType();
+
+	ProjectStore::GetChunkRangeResult Result =
+		ProjectStore::GetChunkRange(Log(), *Project, *FoundLog, Obj, Offset, Size, AcceptType, /*OptionalInOutModificationTag*/ nullptr);
+
+	switch (Result.Error)
 	{
-		return HttpReq.WriteResponse(Result.first);
+		case ProjectStore::GetChunkRangeResult::EError::Ok:
+			m_ProjectStats.ChunkHitCount++;
+			ZEN_DEBUG("chunk - '{}/{}/{}' '{}'", ProjectId, OplogId, ChunkId, ToString(Result.ContentType));
+			return HttpReq.WriteResponse(HttpResponseCode::OK, Result.ContentType, Result.Chunk);
+		case ProjectStore::GetChunkRangeResult::EError::NotFound:
+			m_ProjectStats.ChunkMissCount++;
+			ZEN_DEBUG("chunk - '{}/{}/{}' MISSING", ProjectId, OplogId, ChunkId);
+			return HttpReq.WriteResponse(HttpResponseCode::NotFound, Result.ContentType, Result.Chunk);
+		case ProjectStore::GetChunkRangeResult::EError::MalformedContent:
+			return HttpReq.WriteResponse(
+				HttpResponseCode::NotFound,
+				HttpContentType::kText,
+				fmt::format("Get chunk {}/{}/{} failed. Reason: {}", ProjectId, OplogId, ChunkId, Result.ErrorDescription));
+		case ProjectStore::GetChunkRangeResult::EError::OutOfRange:
+			m_ProjectStats.ChunkMissCount++;
+			ZEN_DEBUG("chunk - '{}/{}/{}' OUT OF RANGE", ProjectId, OplogId, ChunkId);
+			return HttpReq.WriteResponse(
+				HttpResponseCode::NotFound,
+				HttpContentType::kText,
+				fmt::format("Get chunk {}/{}/{} failed. Reason: {}", ProjectId, OplogId, ChunkId, Result.ErrorDescription));
+		default:
+			ZEN_ASSERT(false);
+			break;
 	}
-	return HttpReq.WriteResponse(Result.first, HttpContentType::kText, Result.second);
 }
 
 void
@@ -898,13 +930,40 @@ HttpProjectService::HandleChunkByCidRequest(HttpRouterRequest& Req)
 	HttpContentType AcceptType	= HttpReq.AcceptContentType();
 	HttpContentType RequestType = HttpReq.RequestContentType();
 
+	Ref<ProjectStore::Project> Project = m_ProjectStore->OpenProject(ProjectId);
+	if (!Project)
+	{
+		return HttpReq.WriteResponse(HttpResponseCode::NotFound,
+									 HttpContentType::kText,
+									 fmt::format("Chunk request for unknown project '{}'", ProjectId));
+	}
+	Project->TouchProject();
+
+	Ref<ProjectStore::Oplog> FoundLog = Project->OpenOplog(OplogId, /*AllowCompact*/ false, /*VerifyPathOnDisk*/ false);
+	if (!FoundLog)
+	{
+		return HttpReq.WriteResponse(HttpResponseCode::NotFound,
+									 HttpContentType::kText,
+									 fmt::format("Chunk request for unknown oplog '{}/{}'", ProjectId, OplogId));
+	}
+	Project->TouchOplog(OplogId);
+
+	if (Cid.length() != IoHash::StringLength)
+	{
+		m_ProjectStats.BadRequestCount++;
+		return HttpReq.WriteResponse(HttpResponseCode::BadRequest,
+									 HttpContentType::kText,
+									 fmt::format("Chunk request for invalid chunk id '{}/{}/{}'", ProjectId, OplogId, Cid));
+	}
+
+	const IoHash Hash = IoHash::FromHexString(Cid);
+
 	switch (HttpReq.RequestVerb())
 	{
 		case HttpVerb::kGet:
 			{
-				IoBuffer								 Value;
-				std::pair<HttpResponseCode, std::string> Result = m_ProjectStore->GetChunk(ProjectId, OplogId, Cid, Value, nullptr);
-				if (Result.first == HttpResponseCode::OK)
+				IoBuffer Value = m_ProjectStore->GetChunk(*Project, *FoundLog, Hash);
+				if (Value)
 				{
 					if (AcceptType == ZenContentType::kUnknownContentType || AcceptType == ZenContentType::kBinary ||
 						AcceptType == ZenContentType::kJSON || AcceptType == ZenContentType::kYAML ||
@@ -963,28 +1022,12 @@ HttpProjectService::HandleChunkByCidRequest(HttpRouterRequest& Req)
 					m_ProjectStats.ChunkHitCount++;
 					return HttpReq.WriteResponse(HttpResponseCode::OK, Value.GetContentType(), Value);
 				}
-				else if (Result.first == HttpResponseCode::NotFound)
+				else
 				{
 					m_ProjectStats.ChunkMissCount++;
 					ZEN_DEBUG("chunk - '{}/{}/{}' MISSING", ProjectId, OplogId, Cid);
+					return HttpReq.WriteResponse(HttpResponseCode::NotFound);
 				}
-				else
-				{
-					if (Result.first == HttpResponseCode::BadRequest)
-					{
-						m_ProjectStats.BadRequestCount++;
-					}
-					ZEN_DEBUG("Request {}: '{}' failed with {}. Reason: `{}`",
-							  ToString(HttpReq.RequestVerb()),
-							  HttpReq.QueryString(),
-							  static_cast<int>(Result.first),
-							  Result.second);
-				}
-				if (Result.second.empty())
-				{
-					return HttpReq.WriteResponse(Result.first);
-				}
-				return HttpReq.WriteResponse(Result.first, HttpContentType::kText, Result.second);
 			}
 		case HttpVerb::kPost:
 			{
@@ -992,30 +1035,23 @@ HttpProjectService::HandleChunkByCidRequest(HttpRouterRequest& Req)
 				{
 					return HttpReq.WriteResponse(HttpResponseCode::InsufficientStorage);
 				}
-				std::pair<HttpResponseCode, std::string> Result =
-					m_ProjectStore->PutChunk(ProjectId, OplogId, Cid, RequestType, HttpReq.ReadPayload());
-				if (Result.first == HttpResponseCode::OK || Result.first == HttpResponseCode::Created)
-				{
-					m_ProjectStats.ChunkWriteCount++;
-					return HttpReq.WriteResponse(Result.first);
-				}
-				else
-				{
-					if (Result.first == HttpResponseCode::BadRequest)
-					{
-						m_ProjectStats.BadRequestCount++;
-					}
-					ZEN_DEBUG("Request {}: '{}' failed with {}. Reason: `{}`",
-							  ToString(HttpReq.RequestVerb()),
-							  HttpReq.QueryString(),
-							  static_cast<int>(Result.first),
-							  Result.second);
-				}
-				if (Result.second.empty())
+				if (RequestType != HttpContentType::kCompressedBinary)
 				{
-					return HttpReq.WriteResponse(Result.first);
+					m_ProjectStats.BadRequestCount++;
+					return HttpReq.WriteResponse(HttpResponseCode::BadRequest,
+												 HttpContentType::kText,
+												 fmt::format("Chunk request for chunk id '{}/{}'/'{}' as unexpected content type: '{}'",
+															 ProjectId,
+															 OplogId,
+															 Cid,
+															 ToString(RequestType)));
 				}
-				return HttpReq.WriteResponse(Result.first, HttpContentType::kText, Result.second);
+				IoBuffer Payload = HttpReq.ReadPayload();
+				Payload.SetContentType(RequestType);
+				bool IsNew = m_ProjectStore->PutChunk(*Project, *FoundLog, Hash, std::move(Payload));
+
+				m_ProjectStats.ChunkWriteCount++;
+				return HttpReq.WriteResponse(IsNew ? HttpResponseCode::Created : HttpResponseCode::OK);
 			}
 			break;
 	}
@@ -1986,29 +2022,77 @@ HttpProjectService::HandleOplogSaveRequest(HttpRouterRequest& Req)
 	}
 	IoBuffer Payload = HttpReq.ReadPayload();
 
-	CbObject								 Response;
-	std::pair<HttpResponseCode, std::string> Result = m_ProjectStore->WriteOplog(ProjectId, OplogId, std::move(Payload), Response);
-	if (Result.first == HttpResponseCode::OK)
+	Ref<ProjectStore::Project> Project = m_ProjectStore->OpenProject(ProjectId);
+	if (!Project)
 	{
-		return HttpReq.WriteResponse(HttpResponseCode::OK, Response);
+		return HttpReq.WriteResponse(HttpResponseCode::NotFound,
+									 HttpContentType::kText,
+									 fmt::format("Write oplog request for unknown project '{}'", ProjectId));
 	}
-	else
+	Project->TouchProject();
+
+	Ref<ProjectStore::Oplog> Oplog = Project->OpenOplog(OplogId, /*AllowCompact*/ true, /*VerifyPathOnDisk*/ false);
+	if (!Oplog)
+	{
+		return HttpReq.WriteResponse(HttpResponseCode::NotFound,
+									 HttpContentType::kText,
+									 fmt::format("Write oplog request for unknown oplog '{}/{}'", ProjectId, OplogId));
+	}
+	Project->TouchOplog(OplogId);
+
+	CbValidateError ValidateResult;
+	if (CbObject ContainerObject = ValidateAndReadCompactBinaryObject(std::move(Payload), ValidateResult);
+		ValidateResult == CbValidateError::None && ContainerObject)
 	{
-		if (Result.first == HttpResponseCode::BadRequest)
+		ProjectStore::WriteOplogResult Result = m_ProjectStore->WriteOplog(*Project, *Oplog, ContainerObject);
+		if (Result.ErrorCode == 0)
 		{
-			m_ProjectStats.BadRequestCount++;
+			if (Result.Need.empty())
+			{
+				HttpReq.WriteResponse(HttpResponseCode::OK);
+			}
+			else
+			{
+				CbObjectWriter Cbo(1 + 1 + 5 + Result.Need.size() * (1 + sizeof(IoHash::Hash)) + 1);
+				Cbo.BeginArray("need");
+				{
+					for (const IoHash& Hash : Result.Need)
+					{
+						ZEN_DEBUG("Need attachment {}", Hash);
+						Cbo << Hash;
+					}
+				}
+				Cbo.EndArray();	 // "need"
+
+				CbObject ResponsePayload = Cbo.Save();
+				return HttpReq.WriteResponse(HttpResponseCode::OK, ResponsePayload);
+			}
+		}
+		else
+		{
+			ZEN_DEBUG("Request {}: '{}' failed with {}. Reason: `{}`",
+					  ToString(HttpReq.RequestVerb()),
+					  HttpReq.QueryString(),
+					  Result.ErrorCode,
+					  Result.ErrorDescription);
+
+			if (Result.ErrorDescription.empty())
+			{
+				return HttpReq.WriteResponse(HttpResponseCode(Result.ErrorCode));
+			}
+			else
+			{
+				return HttpReq.WriteResponse(HttpResponseCode(Result.ErrorCode), HttpContentType::kText, Result.ErrorDescription);
+			}
 		}
-		ZEN_DEBUG("Request {}: '{}' failed with {}. Reason: `{}`",
-				  ToString(HttpReq.RequestVerb()),
-				  HttpReq.QueryString(),
-				  static_cast<int>(Result.first),
-				  Result.second);
 	}
-	if (Result.second.empty())
+	else
 	{
-		return HttpReq.WriteResponse(Result.first);
+		m_ProjectStats.BadRequestCount++;
+		return HttpReq.WriteResponse(HttpResponseCode::BadRequest,
+									 HttpContentType::kText,
+									 fmt::format("Invalid payload: '{}'", ToString(ValidateResult)));
 	}
-	return HttpReq.WriteResponse(Result.first, HttpContentType::kText, Result.second);
 }
 
 void
@@ -2019,36 +2103,90 @@ HttpProjectService::HandleOplogLoadRequest(HttpRouterRequest& Req)
 	HttpServerRequest& HttpReq	 = Req.ServerRequest();
 	const auto&		   ProjectId = Req.GetCapture(1);
 	const auto&		   OplogId	 = Req.GetCapture(2);
+
+	const HttpServerRequest::QueryParams Params = HttpReq.GetQueryParams();
+
 	if (HttpReq.AcceptContentType() != HttpContentType::kCbObject)
 	{
 		m_ProjectStats.BadRequestCount++;
 		return HttpReq.WriteResponse(HttpResponseCode::BadRequest, HttpContentType::kText, "Invalid accept content type");
 	}
-	IoBuffer Payload = HttpReq.ReadPayload();
 
-	CbObject								 Response;
-	std::pair<HttpResponseCode, std::string> Result = m_ProjectStore->ReadOplog(ProjectId, OplogId, HttpReq.GetQueryParams(), Response);
-	if (Result.first == HttpResponseCode::OK)
+	Ref<ProjectStore::Project> Project = m_ProjectStore->OpenProject(ProjectId);
+	if (!Project)
 	{
-		return HttpReq.WriteResponse(HttpResponseCode::OK, Response);
+		return HttpReq.WriteResponse(HttpResponseCode::NotFound,
+									 HttpContentType::kText,
+									 fmt::format("Read oplog request for unknown project '{}'", ProjectId));
 	}
-	else
+	Project->TouchProject();
+
+	Ref<ProjectStore::Oplog> Oplog = Project->OpenOplog(OplogId, /*AllowCompact*/ true, /*VerifyPathOnDisk*/ true);
+	if (!Oplog)
 	{
-		if (Result.first == HttpResponseCode::BadRequest)
+		return HttpReq.WriteResponse(HttpResponseCode::NotFound,
+									 HttpContentType::kText,
+									 fmt::format("Read oplog request for unknown oplog '{}/{}'", ProjectId, OplogId));
+	}
+	Project->TouchOplog(OplogId);
+
+	size_t MaxBlockSize = RemoteStoreOptions::DefaultMaxBlockSize;
+	if (auto Param = Params.GetValue("maxblocksize"); Param.empty() == false)
+	{
+		if (auto Value = ParseInt<size_t>(Param))
 		{
-			m_ProjectStats.BadRequestCount++;
+			MaxBlockSize = Value.value();
+		}
+	}
+	size_t MaxChunkEmbedSize = RemoteStoreOptions::DefaultMaxChunkEmbedSize;
+	if (auto Param = Params.GetValue("maxchunkembedsize"); Param.empty() == false)
+	{
+		if (auto Value = ParseInt<size_t>(Param))
+		{
+			MaxChunkEmbedSize = Value.value();
+		}
+	}
+	size_t MaxChunksPerBlock = RemoteStoreOptions::DefaultMaxChunksPerBlock;
+	if (auto Param = Params.GetValue("maxchunksperblock"); Param.empty() == false)
+	{
+		if (auto Value = ParseInt<size_t>(Param))
+		{
+			MaxChunksPerBlock = Value.value();
+		}
+	}
+
+	size_t ChunkFileSizeLimit = RemoteStoreOptions::DefaultChunkFileSizeLimit;
+	if (auto Param = Params.GetValue("chunkfilesizelimit"); Param.empty() == false)
+	{
+		if (auto Value = ParseInt<size_t>(Param))
+		{
+			ChunkFileSizeLimit = Value.value();
 		}
+	}
+
+	ProjectStore::ReadOplogResult Result =
+		m_ProjectStore->ReadOplog(*Project, *Oplog, MaxBlockSize, MaxChunkEmbedSize, MaxChunksPerBlock, ChunkFileSizeLimit);
+	if (Result.ErrorCode == 0)
+	{
+		return HttpReq.WriteResponse(HttpResponseCode::OK, Result.ContainerObject);
+	}
+	else
+	{
 		ZEN_DEBUG("Request {}: '{}' failed with {}. Reason: `{}`",
 				  ToString(HttpReq.RequestVerb()),
 				  HttpReq.QueryString(),
-				  static_cast<int>(Result.first),
-				  Result.second);
-	}
-	if (Result.second.empty())
-	{
-		return HttpReq.WriteResponse(Result.first);
+				  Result.ErrorCode,
+				  Result.ErrorDescription);
+
+		if (Result.ErrorDescription.empty())
+		{
+			return HttpReq.WriteResponse(HttpResponseCode(Result.ErrorCode));
+		}
+		else
+		{
+			return HttpReq.WriteResponse(HttpResponseCode(Result.ErrorCode), HttpContentType::kText, Result.ErrorDescription);
+		}
 	}
-	return HttpReq.WriteResponse(Result.first, HttpContentType::kText, Result.second);
 }
 
 void