move all storage-related services into storage tree (#571)

* move all storage-related services into storage tree
* move config into config/
* also move admin service into storage since it mostly has storage related functionality
* header consolidation

1 files changed, 1211 insertions, 0 deletions

diff --git a/src/zenserver/storage/workspaces/httpworkspaces.cpp b/src/zenserver/storage/workspaces/httpworkspaces.cpp
new file mode 100644
index 000000000..3fea46b2f
--- /dev/null
+++ b/src/zenserver/storage/workspaces/httpworkspaces.cpp
@@ -0,0 +1,1211 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "httpworkspaces.h"
+
+#include <zencore/basicfile.h>
+#include <zencore/compactbinarybuilder.h>
+#include <zencore/fmtutils.h>
+#include <zencore/logging.h>
+#include <zencore/trace.h>
+#include <zenstore/workspaces.h>
+#include <zenutil/chunkrequests.h>
+#include <zenutil/workerpools.h>
+
+#include <unordered_set>
+
+namespace zen {
+using namespace std::literals;
+
+ZEN_DEFINE_LOG_CATEGORY_STATIC(LogFs, "fs"sv);
+
+namespace {
+
+	std::filesystem::path GetPathParameter(HttpServerRequest& ServerRequest, std::string_view Name)
+	{
+		if (std::string_view Value = ServerRequest.GetQueryParams().GetValue(Name); !Value.empty())
+		{
+			return std::filesystem::path(HttpServerRequest::Decode(Value));
+		}
+		return {};
+	}
+
+	void WriteWorkspaceConfig(CbWriter& Writer, const Workspaces::WorkspaceConfiguration& Config)
+	{
+		Writer << "id" << Config.Id;
+		Writer << "root_path" << Config.RootPath.string();	// utf8?
+		Writer << "allow_share_creation_from_http" << Config.AllowShareCreationFromHttp;
+	};
+
+	void WriteWorkspaceShareConfig(CbWriter& Writer, const Workspaces::WorkspaceShareConfiguration& Config)
+	{
+		Writer << "id" << Config.Id;
+		Writer << "share_path" << Config.SharePath.string();  // utf8?
+		if (!Config.Alias.empty())
+		{
+			Writer << "alias" << Config.Alias;
+		}
+	};
+
+	void WriteWorkspaceAndSharesConfig(CbWriter& Writer, Workspaces& Workspaces, const Workspaces::WorkspaceConfiguration& WorkspaceConfig)
+	{
+		WriteWorkspaceConfig(Writer, WorkspaceConfig);
+		if (std::optional<std::vector<Oid>> ShareIds = Workspaces.GetWorkspaceShares(WorkspaceConfig.Id); ShareIds)
+		{
+			Writer.BeginArray("shares");
+			{
+				for (const Oid& ShareId : *ShareIds)
+				{
+					if (std::optional<Workspaces::WorkspaceShareConfiguration> WorkspaceShareConfig =
+							Workspaces.GetWorkspaceShareConfiguration(WorkspaceConfig.Id, ShareId);
+						WorkspaceShareConfig)
+					{
+						Writer.BeginObject();
+						{
+							WriteWorkspaceShareConfig(Writer, *WorkspaceShareConfig);
+						}
+						Writer.EndObject();
+					}
+				}
+			}
+			Writer.EndArray();
+		}
+	}
+
+}  // namespace
+
+HttpWorkspacesService::HttpWorkspacesService(HttpStatusService&			  StatusService,
+											 HttpStatsService&			  StatsService,
+											 const WorkspacesServeConfig& Cfg,
+											 Workspaces&				  Workspaces)
+: m_Log(logging::Get("workspaces"))
+, m_StatusService(StatusService)
+, m_StatsService(StatsService)
+, m_Config(Cfg)
+, m_Workspaces(Workspaces)
+{
+	Initialize();
+}
+
+HttpWorkspacesService::~HttpWorkspacesService()
+{
+	m_StatsService.UnregisterHandler("ws", *this);
+	m_StatusService.UnregisterHandler("ws", *this);
+}
+
+const char*
+HttpWorkspacesService::BaseUri() const
+{
+	return "/ws/";
+}
+
+void
+HttpWorkspacesService::HandleRequest(HttpServerRequest& Request)
+{
+	metrics::OperationTiming::Scope $(m_HttpRequests);
+
+	if (m_Router.HandleRequest(Request) == false)
+	{
+		ZEN_LOG_WARN(LogFs, "No route found for {0}", Request.RelativeUri());
+		return Request.WriteResponse(HttpResponseCode::NotFound, HttpContentType::kText, "Not found"sv);
+	}
+}
+
+void
+HttpWorkspacesService::HandleStatsRequest(HttpServerRequest& HttpReq)
+{
+	ZEN_TRACE_CPU("WorkspacesService::Stats");
+	CbObjectWriter Cbo;
+
+	EmitSnapshot("requests", m_HttpRequests, Cbo);
+
+	Cbo.BeginObject("workspaces");
+	{
+		Cbo.BeginObject("workspace");
+		{
+			Cbo << "readcount" << m_WorkspacesStats.WorkspaceReadCount << "writecount" << m_WorkspacesStats.WorkspaceWriteCount
+				<< "deletecount" << m_WorkspacesStats.WorkspaceDeleteCount;
+		}
+		Cbo.EndObject();
+
+		Cbo.BeginObject("workspaceshare");
+		{
+			Cbo << "readcount" << m_WorkspacesStats.WorkspaceShareReadCount << "writecount" << m_WorkspacesStats.WorkspaceShareWriteCount
+				<< "deletecount" << m_WorkspacesStats.WorkspaceShareDeleteCount;
+		}
+		Cbo.EndObject();
+
+		Cbo.BeginObject("chunk");
+		{
+			Cbo << "hitcount" << m_WorkspacesStats.WorkspaceShareChunkHitCount << "misscount"
+				<< m_WorkspacesStats.WorkspaceShareChunkMissCount;
+		}
+		Cbo.EndObject();
+
+		Cbo << "filescount" << m_WorkspacesStats.WorkspaceShareFilesReadCount;
+		Cbo << "entriescount" << m_WorkspacesStats.WorkspaceShareEntriesReadCount;
+		Cbo << "batchcount" << m_WorkspacesStats.WorkspaceShareBatchReadCount;
+
+		Cbo << "requestcount" << m_WorkspacesStats.RequestCount;
+		Cbo << "badrequestcount" << m_WorkspacesStats.BadRequestCount;
+	}
+	Cbo.EndObject();
+
+	return HttpReq.WriteResponse(HttpResponseCode::OK, Cbo.Save());
+}
+
+void
+HttpWorkspacesService::HandleStatusRequest(HttpServerRequest& Request)
+{
+	ZEN_TRACE_CPU("HttpWorkspacesService::Status");
+	CbObjectWriter Cbo;
+	Cbo << "ok" << true;
+	Request.WriteResponse(HttpResponseCode::OK, Cbo.Save());
+}
+
+void
+HttpWorkspacesService::Initialize()
+{
+	using namespace std::literals;
+
+	ZEN_LOG_INFO(LogFs, "Initializing Workspaces Service");
+
+	m_Router.AddPattern("workspace_id", "([[:xdigit:]]{24})");
+	m_Router.AddPattern("share_id", "([[:xdigit:]]{24})");
+	m_Router.AddPattern("chunk", "([[:xdigit:]]{24})");
+	m_Router.AddPattern("share_alias", "([[:alnum:]_.\\+\\-\\[\\]]+)");
+
+	m_Router.RegisterRoute(
+		"{workspace_id}/{share_id}/files",
+		[this](HttpRouterRequest& Req) { FilesRequest(Req); },
+		HttpVerb::kGet);
+
+	m_Router.RegisterRoute(
+		"{workspace_id}/{share_id}/{chunk}/info",
+		[this](HttpRouterRequest& Req) { ChunkInfoRequest(Req); },
+		HttpVerb::kGet);
+
+	m_Router.RegisterRoute(
+		"{workspace_id}/{share_id}/batch",
+		[this](HttpRouterRequest& Req) { BatchRequest(Req); },
+		HttpVerb::kPost);
+
+	m_Router.RegisterRoute(
+		"{workspace_id}/{share_id}/entries",
+		[this](HttpRouterRequest& Req) { EntriesRequest(Req); },
+		HttpVerb::kGet);
+
+	m_Router.RegisterRoute(
+		"{workspace_id}/{share_id}/{chunk}",
+		[this](HttpRouterRequest& Req) { ChunkRequest(Req); },
+		HttpVerb::kGet | HttpVerb::kHead);
+
+	m_Router.RegisterRoute(
+		"share/{share_alias}/files",
+		[this](HttpRouterRequest& Req) { ShareAliasFilesRequest(Req); },
+		HttpVerb::kGet);
+
+	m_Router.RegisterRoute(
+		"share/{share_alias}/{chunk}/info",
+		[this](HttpRouterRequest& Req) { ShareAliasChunkInfoRequest(Req); },
+		HttpVerb::kGet);
+
+	m_Router.RegisterRoute(
+		"share/{share_alias}/batch",
+		[this](HttpRouterRequest& Req) { ShareAliasBatchRequest(Req); },
+		HttpVerb::kPost);
+
+	m_Router.RegisterRoute(
+		"share/{share_alias}/entries",
+		[this](HttpRouterRequest& Req) { ShareAliasEntriesRequest(Req); },
+		HttpVerb::kGet);
+
+	m_Router.RegisterRoute(
+		"share/{share_alias}/{chunk}",
+		[this](HttpRouterRequest& Req) { ShareAliasChunkRequest(Req); },
+		HttpVerb::kGet | HttpVerb::kHead);
+
+	m_Router.RegisterRoute(
+		"share/{share_alias}",
+		[this](HttpRouterRequest& Req) { ShareAliasRequest(Req); },
+		HttpVerb::kPut | HttpVerb::kGet | HttpVerb::kDelete);
+
+	m_Router.RegisterRoute(
+		"{workspace_id}/{share_id}",
+		[this](HttpRouterRequest& Req) { ShareRequest(Req); },
+		HttpVerb::kPut | HttpVerb::kGet | HttpVerb::kDelete);
+
+	m_Router.RegisterRoute(
+		"{workspace_id}",
+		[this](HttpRouterRequest& Req) { WorkspaceRequest(Req); },
+		HttpVerb::kPut | HttpVerb::kGet | HttpVerb::kDelete);
+
+	m_Router.RegisterRoute(
+		"refresh",
+		[this](HttpRouterRequest& Req) { RefreshRequest(Req); },
+		HttpVerb::kGet);
+
+	m_Router.RegisterRoute(
+		"",
+		[this](HttpRouterRequest& Req) { WorkspacesRequest(Req); },
+		HttpVerb::kGet);
+
+	RefreshState();
+
+	m_StatsService.RegisterHandler("ws", *this);
+	m_StatusService.RegisterHandler("ws", *this);
+}
+
+std::filesystem::path
+HttpWorkspacesService::GetStatePath() const
+{
+	return m_Config.SystemRootDir / "workspaces";
+}
+
+void
+HttpWorkspacesService::RefreshState()
+{
+	if (!m_Config.SystemRootDir.empty())
+	{
+		m_Workspaces.RefreshState(GetStatePath());
+	}
+}
+
+bool
+HttpWorkspacesService::MayChangeConfiguration(const HttpServerRequest& Req) const
+{
+	ZEN_UNUSED(Req);
+	return m_Config.AllowConfigurationChanges;
+}
+
+void
+HttpWorkspacesService::RefreshRequest(HttpRouterRequest& Req)
+{
+	HttpServerRequest& ServerRequest = Req.ServerRequest();
+	RefreshState();
+	return ServerRequest.WriteResponse(HttpResponseCode::OK);
+}
+
+void
+HttpWorkspacesService::WorkspacesRequest(HttpRouterRequest& Req)
+{
+	HttpServerRequest& ServerRequest = Req.ServerRequest();
+
+	std::vector<Oid> WorkspaceIds = m_Workspaces.GetWorkspaces();
+	CbObjectWriter	 Response;
+	Response.BeginArray("workspaces");
+	for (const Oid& WorkspaceId : WorkspaceIds)
+	{
+		if (std::optional<Workspaces::WorkspaceConfiguration> WorkspaceConfig = m_Workspaces.GetWorkspaceConfiguration(WorkspaceId);
+			WorkspaceConfig)
+		{
+			Response.BeginObject();
+			{
+				WriteWorkspaceAndSharesConfig(Response, m_Workspaces, *WorkspaceConfig);
+			}
+			Response.EndObject();
+		}
+	}
+	Response.EndArray();
+
+	return ServerRequest.WriteResponse(HttpResponseCode::OK, Response.Save());
+}
+
+void
+HttpWorkspacesService::FilesRequest(HttpRouterRequest& Req)
+{
+	HttpServerRequest& ServerRequest = Req.ServerRequest();
+	const Oid		   WorkspaceId	 = Oid::TryFromHexString(Req.GetCapture(1));
+	if (WorkspaceId == Oid::Zero)
+	{
+		m_WorkspacesStats.BadRequestCount++;
+		return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+										   HttpContentType::kText,
+										   fmt::format("Invalid workspace id '{}'", Req.GetCapture(1)));
+	}
+	const Oid ShareId = Oid::TryFromHexString(Req.GetCapture(2));
+	if (ShareId == Oid::Zero)
+	{
+		m_WorkspacesStats.BadRequestCount++;
+		return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+										   HttpContentType::kText,
+										   fmt::format("Invalid share id '{}'", Req.GetCapture(2)));
+	}
+	FilesRequest(Req, WorkspaceId, ShareId);
+}
+
+void
+HttpWorkspacesService::ChunkInfoRequest(HttpRouterRequest& Req)
+{
+	HttpServerRequest& ServerRequest = Req.ServerRequest();
+	const Oid		   WorkspaceId	 = Oid::TryFromHexString(Req.GetCapture(1));
+	if (WorkspaceId == Oid::Zero)
+	{
+		m_WorkspacesStats.BadRequestCount++;
+		return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+										   HttpContentType::kText,
+										   fmt::format("Invalid workspace id '{}'", Req.GetCapture(1)));
+	}
+	const Oid ShareId = Oid::TryFromHexString(Req.GetCapture(2));
+	if (ShareId == Oid::Zero)
+	{
+		m_WorkspacesStats.BadRequestCount++;
+		return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+										   HttpContentType::kText,
+										   fmt::format("Invalid share id '{}'", Req.GetCapture(2)));
+	}
+	const Oid ChunkId = Oid::TryFromHexString(Req.GetCapture(3));
+	if (ChunkId == Oid::Zero)
+	{
+		m_WorkspacesStats.BadRequestCount++;
+		return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+										   HttpContentType::kText,
+										   fmt::format("Invalid chunk id '{}'", Req.GetCapture(3)));
+	}
+	ChunkInfoRequest(Req, WorkspaceId, ShareId, ChunkId);
+}
+
+void
+HttpWorkspacesService::BatchRequest(HttpRouterRequest& Req)
+{
+	HttpServerRequest& ServerRequest = Req.ServerRequest();
+	const Oid		   WorkspaceId	 = Oid::TryFromHexString(Req.GetCapture(1));
+	if (WorkspaceId == Oid::Zero)
+	{
+		m_WorkspacesStats.BadRequestCount++;
+		return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+										   HttpContentType::kText,
+										   fmt::format("Invalid workspace id '{}'", Req.GetCapture(1)));
+	}
+	const Oid ShareId = Oid::TryFromHexString(Req.GetCapture(2));
+	if (ShareId == Oid::Zero)
+	{
+		m_WorkspacesStats.BadRequestCount++;
+		return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+										   HttpContentType::kText,
+										   fmt::format("Invalid share id '{}'", Req.GetCapture(2)));
+	}
+	BatchRequest(Req, WorkspaceId, ShareId);
+}
+
+void
+HttpWorkspacesService::EntriesRequest(HttpRouterRequest& Req)
+{
+	HttpServerRequest& ServerRequest = Req.ServerRequest();
+	const Oid		   WorkspaceId	 = Oid::TryFromHexString(Req.GetCapture(1));
+	if (WorkspaceId == Oid::Zero)
+	{
+		m_WorkspacesStats.BadRequestCount++;
+		return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+										   HttpContentType::kText,
+										   fmt::format("Invalid workspace id '{}'", Req.GetCapture(1)));
+	}
+	const Oid ShareId = Oid::TryFromHexString(Req.GetCapture(2));
+	if (ShareId == Oid::Zero)
+	{
+		m_WorkspacesStats.BadRequestCount++;
+		return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+										   HttpContentType::kText,
+										   fmt::format("Invalid share id '{}'", Req.GetCapture(2)));
+	}
+	EntriesRequest(Req, WorkspaceId, ShareId);
+}
+
+void
+HttpWorkspacesService::ChunkRequest(HttpRouterRequest& Req)
+{
+	HttpServerRequest& ServerRequest = Req.ServerRequest();
+	const Oid		   WorkspaceId	 = Oid::TryFromHexString(Req.GetCapture(1));
+	if (WorkspaceId == Oid::Zero)
+	{
+		m_WorkspacesStats.BadRequestCount++;
+		return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+										   HttpContentType::kText,
+										   fmt::format("Invalid workspace id '{}'", Req.GetCapture(1)));
+	}
+	const Oid ShareId = Oid::TryFromHexString(Req.GetCapture(2));
+	if (ShareId == Oid::Zero)
+	{
+		m_WorkspacesStats.BadRequestCount++;
+		return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+										   HttpContentType::kText,
+										   fmt::format("Invalid share id '{}'", Req.GetCapture(2)));
+	}
+	const Oid ChunkId = Oid::TryFromHexString(Req.GetCapture(3));
+	if (ChunkId == Oid::Zero)
+	{
+		m_WorkspacesStats.BadRequestCount++;
+		return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+										   HttpContentType::kText,
+										   fmt::format("Invalid chunk id '{}'", Req.GetCapture(3)));
+	}
+	ChunkRequest(Req, WorkspaceId, ShareId, ChunkId);
+}
+
+void
+HttpWorkspacesService::ShareRequest(HttpRouterRequest& Req)
+{
+	HttpServerRequest& ServerRequest = Req.ServerRequest();
+	const Oid		   WorkspaceId	 = Oid::TryFromHexString(Req.GetCapture(1));
+	if (WorkspaceId == Oid::Zero)
+	{
+		m_WorkspacesStats.BadRequestCount++;
+		return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+										   HttpContentType::kText,
+										   fmt::format("Invalid workspace id '{}'", Req.GetCapture(1)));
+	}
+	Oid ShareId = Oid::Zero;
+	if (Req.GetCapture(2) != Oid::Zero.ToString())
+	{
+		ShareId = Oid::TryFromHexString(Req.GetCapture(2));
+		if (ShareId == Oid::Zero)
+		{
+			m_WorkspacesStats.BadRequestCount++;
+			return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+											   HttpContentType::kText,
+											   fmt::format("Invalid share id '{}'", Req.GetCapture(2)));
+		}
+	}
+	ShareRequest(Req, WorkspaceId, ShareId);
+}
+
+void
+HttpWorkspacesService::WorkspaceRequest(HttpRouterRequest& Req)
+{
+	HttpServerRequest& ServerRequest = Req.ServerRequest();
+	Oid				   WorkspaceId	 = Oid::TryFromHexString(Req.GetCapture(1));
+	switch (ServerRequest.RequestVerb())
+	{
+		case HttpVerb::kPut:
+			{
+				std::filesystem::path WorkspacePath = GetPathParameter(ServerRequest, "root_path"sv);
+				if (WorkspacePath.empty())
+				{
+					m_WorkspacesStats.BadRequestCount++;
+					return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+													   HttpContentType::kText,
+													   "Invalid 'root_path' parameter");
+				}
+
+				if (Req.GetCapture(1) == Oid::Zero.ToString())
+				{
+					// Synthesize Id
+					WorkspaceId = Workspaces::PathToId(WorkspacePath);
+					ZEN_INFO("Generated workspace id from path '{}': {}", WorkspacePath, WorkspaceId);
+				}
+				else if (WorkspaceId == Oid::Zero)
+				{
+					m_WorkspacesStats.BadRequestCount++;
+					return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+													   HttpContentType::kText,
+													   fmt::format("Invalid workspace id '{}'", Req.GetCapture(1)));
+				}
+
+				if (!MayChangeConfiguration(ServerRequest))
+				{
+					return ServerRequest.WriteResponse(HttpResponseCode::Unauthorized,
+													   HttpContentType::kText,
+													   fmt::format("Adding workspace {} is not allowed", WorkspaceId));
+				}
+				bool AllowShareCreationFromHttp = false;
+				if (std::string_view Value = ServerRequest.GetQueryParams().GetValue("allow_share_creation_from_http"); Value == "true"sv)
+				{
+					AllowShareCreationFromHttp = true;
+				}
+
+				m_WorkspacesStats.WorkspaceWriteCount++;
+				Workspaces::WorkspaceConfiguration OldConfig = Workspaces::FindWorkspace(Log(), GetStatePath(), WorkspaceId);
+				Workspaces::WorkspaceConfiguration NewConfig = {.Id							= WorkspaceId,
+																.RootPath					= WorkspacePath,
+																.AllowShareCreationFromHttp = AllowShareCreationFromHttp};
+				if (OldConfig.Id == WorkspaceId && (OldConfig != NewConfig))
+				{
+					return ServerRequest.WriteResponse(
+						HttpResponseCode::Conflict,
+						HttpContentType::kText,
+						fmt::format("Workspace {} already exists with root path '{}'", WorkspaceId, OldConfig.RootPath));
+				}
+				else if (OldConfig.Id == Oid::Zero)
+				{
+					if (Workspaces::WorkspaceConfiguration ConfigWithSameRoot =
+							Workspaces::FindWorkspace(Log(), GetStatePath(), WorkspacePath);
+						ConfigWithSameRoot.Id != Oid::Zero)
+					{
+						return ServerRequest.WriteResponse(
+							HttpResponseCode::Conflict,
+							HttpContentType::kText,
+							fmt::format("Workspace {} already exists with same root path '{}'", ConfigWithSameRoot.Id, WorkspacePath));
+					}
+				}
+
+				bool Created = Workspaces::AddWorkspace(Log(), GetStatePath(), NewConfig);
+				if (Created)
+				{
+					ZEN_ASSERT(OldConfig.Id == Oid::Zero);
+					RefreshState();
+					return ServerRequest.WriteResponse(HttpResponseCode::Created, HttpContentType::kText, fmt::format("{}", WorkspaceId));
+				}
+				else
+				{
+					return ServerRequest.WriteResponse(HttpResponseCode::OK, HttpContentType::kText, fmt::format("{}", WorkspaceId));
+				}
+			}
+		case HttpVerb::kGet:
+			{
+				if (WorkspaceId == Oid::Zero)
+				{
+					m_WorkspacesStats.BadRequestCount++;
+					return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+													   HttpContentType::kText,
+													   fmt::format("Invalid workspace id '{}'", Req.GetCapture(1)));
+				}
+				m_WorkspacesStats.WorkspaceReadCount++;
+				std::optional<Workspaces::WorkspaceConfiguration> Workspace = m_Workspaces.GetWorkspaceConfiguration(WorkspaceId);
+				if (Workspace)
+				{
+					CbObjectWriter Response;
+					WriteWorkspaceAndSharesConfig(Response, m_Workspaces, *Workspace);
+					return ServerRequest.WriteResponse(HttpResponseCode::OK, Response.Save());
+				}
+				else
+				{
+					return ServerRequest.WriteResponse(HttpResponseCode::NotFound);
+				}
+			}
+		case HttpVerb::kDelete:
+			{
+				if (WorkspaceId == Oid::Zero)
+				{
+					m_WorkspacesStats.BadRequestCount++;
+					return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+													   HttpContentType::kText,
+													   fmt::format("Invalid workspace id '{}'", Req.GetCapture(1)));
+				}
+
+				if (!MayChangeConfiguration(ServerRequest))
+				{
+					return ServerRequest.WriteResponse(HttpResponseCode::Unauthorized,
+													   HttpContentType::kText,
+													   fmt::format("Removing workspace {} is not allowed", WorkspaceId));
+				}
+
+				m_WorkspacesStats.WorkspaceDeleteCount++;
+				bool Deleted = Workspaces::RemoveWorkspace(Log(), GetStatePath(), WorkspaceId);
+				if (Deleted)
+				{
+					RefreshState();
+					return ServerRequest.WriteResponse(HttpResponseCode::OK);
+				}
+				return ServerRequest.WriteResponse(HttpResponseCode::NotFound);
+			}
+	}
+}
+
+void
+HttpWorkspacesService::ShareAliasFilesRequest(HttpRouterRequest& Req)
+{
+	HttpServerRequest& ServerRequest = Req.ServerRequest();
+	std::string_view   Alias		 = Req.GetCapture(1);
+	if (Alias.empty())
+	{
+		return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+										   HttpContentType::kText,
+										   fmt::format("Invalid alias '{}'", Req.GetCapture(1)));
+	}
+	std::optional<Workspaces::ShareAlias> WorkspaceAndShareId = m_Workspaces.GetShareAlias(Alias);
+	if (!WorkspaceAndShareId.has_value())
+	{
+		return ServerRequest.WriteResponse(HttpResponseCode::NotFound);
+	}
+	FilesRequest(Req, WorkspaceAndShareId.value().WorkspaceId, WorkspaceAndShareId.value().ShareId);
+}
+
+void
+HttpWorkspacesService::ShareAliasChunkInfoRequest(HttpRouterRequest& Req)
+{
+	HttpServerRequest& ServerRequest = Req.ServerRequest();
+	std::string_view   Alias		 = Req.GetCapture(1);
+	if (Alias.empty())
+	{
+		return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+										   HttpContentType::kText,
+										   fmt::format("Invalid alias '{}'", Req.GetCapture(1)));
+	}
+	std::optional<Workspaces::ShareAlias> WorkspaceAndShareId = m_Workspaces.GetShareAlias(Alias);
+	if (!WorkspaceAndShareId.has_value())
+	{
+		return ServerRequest.WriteResponse(HttpResponseCode::NotFound);
+	}
+	const Oid ChunkId = Oid::TryFromHexString(Req.GetCapture(2));
+	if (ChunkId == Oid::Zero)
+	{
+		m_WorkspacesStats.BadRequestCount++;
+		return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+										   HttpContentType::kText,
+										   fmt::format("Invalid chunk id '{}'", Req.GetCapture(2)));
+	}
+	ChunkInfoRequest(Req, WorkspaceAndShareId.value().WorkspaceId, WorkspaceAndShareId.value().ShareId, ChunkId);
+}
+
+void
+HttpWorkspacesService::ShareAliasBatchRequest(HttpRouterRequest& Req)
+{
+	HttpServerRequest& ServerRequest = Req.ServerRequest();
+	std::string_view   Alias		 = Req.GetCapture(1);
+	if (Alias.empty())
+	{
+		return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+										   HttpContentType::kText,
+										   fmt::format("Invalid alias '{}'", Req.GetCapture(1)));
+	}
+	std::optional<Workspaces::ShareAlias> WorkspaceAndShareId = m_Workspaces.GetShareAlias(Alias);
+	if (!WorkspaceAndShareId.has_value())
+	{
+		return ServerRequest.WriteResponse(HttpResponseCode::NotFound);
+	}
+	BatchRequest(Req, WorkspaceAndShareId.value().WorkspaceId, WorkspaceAndShareId.value().ShareId);
+}
+
+void
+HttpWorkspacesService::ShareAliasEntriesRequest(HttpRouterRequest& Req)
+{
+	HttpServerRequest& ServerRequest = Req.ServerRequest();
+	std::string_view   Alias		 = Req.GetCapture(1);
+	if (Alias.empty())
+	{
+		return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+										   HttpContentType::kText,
+										   fmt::format("Invalid alias '{}'", Req.GetCapture(1)));
+	}
+	std::optional<Workspaces::ShareAlias> WorkspaceAndShareId = m_Workspaces.GetShareAlias(Alias);
+	if (!WorkspaceAndShareId.has_value())
+	{
+		return ServerRequest.WriteResponse(HttpResponseCode::NotFound);
+	}
+	EntriesRequest(Req, WorkspaceAndShareId.value().WorkspaceId, WorkspaceAndShareId.value().ShareId);
+}
+
+void
+HttpWorkspacesService::ShareAliasChunkRequest(HttpRouterRequest& Req)
+{
+	HttpServerRequest& ServerRequest = Req.ServerRequest();
+	std::string_view   Alias		 = Req.GetCapture(1);
+	if (Alias.empty())
+	{
+		return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+										   HttpContentType::kText,
+										   fmt::format("Invalid alias '{}'", Req.GetCapture(1)));
+	}
+	std::optional<Workspaces::ShareAlias> WorkspaceAndShareId = m_Workspaces.GetShareAlias(Alias);
+	if (!WorkspaceAndShareId.has_value())
+	{
+		return ServerRequest.WriteResponse(HttpResponseCode::NotFound);
+	}
+	const Oid ChunkId = Oid::TryFromHexString(Req.GetCapture(2));
+	if (ChunkId == Oid::Zero)
+	{
+		m_WorkspacesStats.BadRequestCount++;
+		return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+										   HttpContentType::kText,
+										   fmt::format("Invalid chunk id '{}'", Req.GetCapture(2)));
+	}
+	ChunkRequest(Req, WorkspaceAndShareId.value().WorkspaceId, WorkspaceAndShareId.value().ShareId, ChunkId);
+}
+
+void
+HttpWorkspacesService::ShareAliasRequest(HttpRouterRequest& Req)
+{
+	HttpServerRequest& ServerRequest = Req.ServerRequest();
+	std::string_view   Alias		 = Req.GetCapture(1);
+	if (Alias.empty())
+	{
+		return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+										   HttpContentType::kText,
+										   fmt::format("Invalid alias '{}'", Req.GetCapture(1)));
+	}
+	std::optional<Workspaces::ShareAlias> WorkspaceAndShareId = m_Workspaces.GetShareAlias(Alias);
+	if (!WorkspaceAndShareId.has_value())
+	{
+		return ServerRequest.WriteResponse(HttpResponseCode::NotFound);
+	}
+	ShareRequest(Req, WorkspaceAndShareId.value().WorkspaceId, WorkspaceAndShareId.value().ShareId);
+}
+
+void
+HttpWorkspacesService::FilesRequest(HttpRouterRequest& Req, const Oid& WorkspaceId, const Oid& ShareId)
+{
+	HttpServerRequest& ServerRequest = Req.ServerRequest();
+
+	m_WorkspacesStats.WorkspaceShareFilesReadCount++;
+
+	std::unordered_set<std::string> WantedFieldNames;
+	if (auto FieldFilter = HttpServerRequest::Decode(ServerRequest.GetQueryParams().GetValue("fieldnames")); !FieldFilter.empty())
+	{
+		if (FieldFilter != "*")	 // Get all - empty FieldFilter equal getting all fields
+		{
+			ForEachStrTok(FieldFilter, ',', [&](std::string_view FieldName) {
+				WantedFieldNames.insert(std::string(FieldName));
+				return true;
+			});
+		}
+	}
+	else
+	{
+		const bool FilterClient = ServerRequest.GetQueryParams().GetValue("filter"sv) == "client"sv;
+		WantedFieldNames.insert("id");
+		WantedFieldNames.insert("clientpath");
+		if (!FilterClient)
+		{
+			WantedFieldNames.insert("serverpath");
+		}
+	}
+
+	bool Refresh = false;
+	if (auto RefreshStr = ServerRequest.GetQueryParams().GetValue("refresh"); !RefreshStr.empty())
+	{
+		Refresh = StrCaseCompare(std::string(RefreshStr).c_str(), "true") == 0;
+	}
+
+	const bool WantsAllFields = WantedFieldNames.empty();
+
+	const bool WantsIdField			= WantsAllFields || WantedFieldNames.contains("id");
+	const bool WantsClientPathField = WantsAllFields || WantedFieldNames.contains("clientpath");
+	const bool WantsServerPathField = WantsAllFields || WantedFieldNames.contains("serverpath");
+	const bool WantsRawSizeField	= WantsAllFields || WantedFieldNames.contains("rawsize");
+	const bool WantsSizeField		= WantsAllFields || WantedFieldNames.contains("size");
+
+	std::optional<std::vector<Workspaces::ShareFile>> Files =
+		m_Workspaces.GetWorkspaceShareFiles(WorkspaceId, ShareId, Refresh, GetSmallWorkerPool(EWorkloadType::Burst));
+	if (!Files.has_value())
+	{
+		return ServerRequest.WriteResponse(HttpResponseCode::NotFound);
+	}
+
+	CbObjectWriter Response;
+	Response.BeginArray("files"sv);
+	{
+		for (const Workspaces::ShareFile& Entry : Files.value())
+		{
+			Response.BeginObject();
+			if (WantsIdField)
+			{
+				Response << "id"sv << Entry.Id;
+			}
+			if (WantsServerPathField)
+			{
+				Response << "serverpath"sv << Entry.RelativePath;
+			}
+			if (WantsClientPathField)
+			{
+				Response << "clientpath"sv << Entry.RelativePath;
+			}
+			if (WantsSizeField)
+			{
+				Response << "size"sv << Entry.Size;
+			}
+			if (WantsRawSizeField)
+			{
+				Response << "rawsize"sv << Entry.Size;
+			}
+			Response.EndObject();
+		}
+	}
+	Response.EndArray();
+
+	return ServerRequest.WriteResponse(HttpResponseCode::OK, Response.Save());
+}
+
+void
+HttpWorkspacesService::ChunkInfoRequest(HttpRouterRequest& Req, const Oid& WorkspaceId, const Oid& ShareId, const Oid& ChunkId)
+{
+	HttpServerRequest&	  ServerRequest = Req.ServerRequest();
+	Workspaces::ShareFile File =
+		m_Workspaces.GetWorkspaceShareChunkInfo(WorkspaceId, ShareId, ChunkId, GetSmallWorkerPool(EWorkloadType::Burst));
+	if (File.Id != Oid::Zero)
+	{
+		CbObjectWriter Response;
+		Response << "size"sv << File.Size;
+		m_WorkspacesStats.WorkspaceShareChunkHitCount++;
+		return ServerRequest.WriteResponse(HttpResponseCode::OK, Response.Save());
+	}
+	m_WorkspacesStats.WorkspaceShareChunkMissCount++;
+	return ServerRequest.WriteResponse(HttpResponseCode::NotFound);
+}
+
+void
+HttpWorkspacesService::BatchRequest(HttpRouterRequest& Req, const Oid& WorkspaceId, const Oid& ShareId)
+{
+	HttpServerRequest&							  ServerRequest = Req.ServerRequest();
+	IoBuffer									  Payload		= ServerRequest.ReadPayload();
+	std::optional<std::vector<RequestChunkEntry>> ChunkRequests = ParseChunkBatchRequest(Payload);
+	if (!ChunkRequests.has_value())
+	{
+		m_WorkspacesStats.BadRequestCount++;
+		return ServerRequest.WriteResponse(HttpResponseCode::BadRequest, HttpContentType::kText, "batch payload malformed");
+	}
+	m_WorkspacesStats.WorkspaceShareBatchReadCount++;
+	std::vector<Workspaces::ChunkRequest> Requests;
+	Requests.reserve(ChunkRequests.value().size());
+	std::transform(ChunkRequests.value().begin(),
+				   ChunkRequests.value().end(),
+				   std::back_inserter(Requests),
+				   [](const RequestChunkEntry& Entry) {
+					   return Workspaces::ChunkRequest{.ChunkId = Entry.ChunkId, .Offset = Entry.Offset, .Size = Entry.RequestBytes};
+				   });
+	std::vector<IoBuffer> Chunks =
+		m_Workspaces.GetWorkspaceShareChunks(WorkspaceId, ShareId, Requests, GetSmallWorkerPool(EWorkloadType::Burst));
+	if (Chunks.empty())
+	{
+		return ServerRequest.WriteResponse(HttpResponseCode::NotFound);
+	}
+	for (const IoBuffer& Buffer : Chunks)
+	{
+		if (Buffer)
+		{
+			m_WorkspacesStats.WorkspaceShareChunkHitCount++;
+		}
+		else
+		{
+			m_WorkspacesStats.WorkspaceShareChunkMissCount++;
+		}
+	}
+	std::vector<IoBuffer> Response = BuildChunkBatchResponse(ChunkRequests.value(), Chunks);
+	if (!Response.empty())
+	{
+		return ServerRequest.WriteResponse(HttpResponseCode::OK, HttpContentType::kBinary, Response);
+	}
+	return ServerRequest.WriteResponse(HttpResponseCode::InternalServerError,
+									   HttpContentType::kText,
+									   fmt::format("failed formatting response for batch of {} chunks", Chunks.size()));
+}
+
+void
+HttpWorkspacesService::EntriesRequest(HttpRouterRequest& Req, const Oid& WorkspaceId, const Oid& ShareId)
+{
+	HttpServerRequest& ServerRequest = Req.ServerRequest();
+	std::string_view   OpKey		 = ServerRequest.GetQueryParams().GetValue("opkey"sv);
+	if (!OpKey.empty() && OpKey != "file_manifest")
+	{
+		m_WorkspacesStats.BadRequestCount++;
+		return ServerRequest.WriteResponse(HttpResponseCode::NotFound);
+	}
+	std::unordered_set<std::string> WantedFieldNames;
+	if (auto FieldFilter = HttpServerRequest::Decode(ServerRequest.GetQueryParams().GetValue("fieldfilter")); !FieldFilter.empty())
+	{
+		if (FieldFilter != "*")	 // Get all - empty FieldFilter equal getting all fields
+		{
+			ForEachStrTok(FieldFilter, ',', [&](std::string_view FieldName) {
+				WantedFieldNames.insert(std::string(FieldName));
+				return true;
+			});
+		}
+	}
+
+	bool Refresh = false;
+	if (auto RefreshStr = ServerRequest.GetQueryParams().GetValue("refresh"); !RefreshStr.empty())
+	{
+		Refresh = StrCaseCompare(std::string(RefreshStr).c_str(), "true") == 0;
+	}
+
+	m_WorkspacesStats.WorkspaceShareEntriesReadCount++;
+	std::optional<std::vector<Workspaces::ShareFile>> Files =
+		m_Workspaces.GetWorkspaceShareFiles(WorkspaceId, ShareId, Refresh, GetSmallWorkerPool(EWorkloadType::Burst));
+	if (!Files.has_value())
+	{
+		return ServerRequest.WriteResponse(HttpResponseCode::NotFound);
+	}
+	const bool WantsAllFields = WantedFieldNames.empty();
+
+	const bool WantsIdField			= WantsAllFields || WantedFieldNames.contains("id");
+	const bool WantsClientPathField = WantsAllFields || WantedFieldNames.contains("clientpath");
+	const bool WantsServerPathField = WantsAllFields || WantedFieldNames.contains("serverpath");
+
+	CbObjectWriter Response;
+
+	if (OpKey.empty())
+	{
+		Response.BeginArray("entries"sv);
+		Response.BeginObject();
+	}
+	else
+	{
+		Response.BeginObject("entry"sv);
+	}
+	{
+		// Synthesize a fake op
+		Response << "key"
+				 << "file_manifest";
+
+		Response.BeginArray("files");
+		{
+			for (const Workspaces::ShareFile& Entry : Files.value())
+			{
+				Response.BeginObject();
+				{
+					if (WantsIdField)
+					{
+						Response << "id"sv << Entry.Id;
+					}
+					if (WantsServerPathField)
+					{
+						Response << "serverpath"sv << Entry.RelativePath;
+					}
+					if (WantsClientPathField)
+					{
+						Response << "clientpath"sv << Entry.RelativePath;
+					}
+				}
+				Response.EndObject();
+			}
+		}
+		Response.EndArray();
+	}
+
+	if (OpKey.empty())
+	{
+		Response.EndObject();
+		Response.EndArray();
+	}
+	else
+	{
+		Response.EndObject();
+	}
+
+	return ServerRequest.WriteResponse(HttpResponseCode::OK, Response.Save());
+}
+
+void
+HttpWorkspacesService::ChunkRequest(HttpRouterRequest& Req, const Oid& WorkspaceId, const Oid& ShareId, const Oid& ChunkId)
+{
+	HttpServerRequest& ServerRequest = Req.ServerRequest();
+
+	uint64_t Offset = 0;
+	uint64_t Size	= ~(0ull);
+	if (auto OffsetParm = ServerRequest.GetQueryParams().GetValue("offset"); OffsetParm.empty() == false)
+	{
+		if (auto OffsetVal = ParseInt<uint64_t>(OffsetParm))
+		{
+			Offset = OffsetVal.value();
+		}
+		else
+		{
+			m_WorkspacesStats.BadRequestCount++;
+			return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+											   HttpContentType::kText,
+											   fmt::format("Invalid offset parameter '{}'", OffsetParm));
+		}
+	}
+
+	if (auto SizeParm = ServerRequest.GetQueryParams().GetValue("size"); SizeParm.empty() == false)
+	{
+		if (auto SizeVal = ParseInt<uint64_t>(SizeParm))
+		{
+			Size = SizeVal.value();
+		}
+		else
+		{
+			m_WorkspacesStats.BadRequestCount++;
+			return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+											   HttpContentType::kText,
+											   fmt::format("Invalid size parameter '{}'", SizeParm));
+		}
+	}
+
+	std::vector<IoBuffer> Response = m_Workspaces.GetWorkspaceShareChunks(
+		WorkspaceId,
+		ShareId,
+		std::vector<Workspaces::ChunkRequest>{Workspaces::ChunkRequest{.ChunkId = ChunkId, .Offset = Offset, .Size = Size}},
+		GetSmallWorkerPool(EWorkloadType::Burst));
+	if (!Response.empty() && Response[0])
+	{
+		m_WorkspacesStats.WorkspaceShareChunkHitCount++;
+		if (Response[0].GetSize() == 0)
+		{
+			return ServerRequest.WriteResponse(HttpResponseCode::OK);
+		}
+		return ServerRequest.WriteResponse(HttpResponseCode::OK, Response[0].GetContentType(), Response);
+	}
+	m_WorkspacesStats.WorkspaceShareChunkMissCount++;
+	return ServerRequest.WriteResponse(HttpResponseCode::NotFound);
+}
+
+void
+HttpWorkspacesService::ShareRequest(HttpRouterRequest& Req, const Oid& WorkspaceId, const Oid& InShareId)
+{
+	Oid ShareId = InShareId;
+
+	HttpServerRequest& ServerRequest = Req.ServerRequest();
+	switch (ServerRequest.RequestVerb())
+	{
+		case HttpVerb::kPut:
+			{
+				std::filesystem::path SharePath = GetPathParameter(ServerRequest, "share_path"sv);
+				if (SharePath.empty())
+				{
+					m_WorkspacesStats.BadRequestCount++;
+					return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+													   HttpContentType::kText,
+													   "Invalid 'share_path' parameter");
+				}
+
+				if (ShareId == Oid::Zero)
+				{
+					// Synthesize Id
+					ShareId = Workspaces::PathToId(SharePath);
+					ZEN_INFO("Generated workspace id from path '{}': {}", SharePath, ShareId);
+				}
+
+				std::string Alias = HttpServerRequest::Decode(ServerRequest.GetQueryParams().GetValue("alias"sv));
+				if (!AsciiSet::HasOnly(Alias, Workspaces::ValidAliasCharactersSet))
+				{
+					return ServerRequest.WriteResponse(HttpResponseCode::BadRequest, HttpContentType::kText, "Invalid 'alias' parameter");
+				}
+
+				Workspaces::WorkspaceConfiguration Workspace = Workspaces::FindWorkspace(Log(), GetStatePath(), WorkspaceId);
+				if (Workspace.Id == Oid::Zero)
+				{
+					return ServerRequest.WriteResponse(HttpResponseCode::NotFound,
+													   HttpContentType::kText,
+													   fmt::format("Workspace '{}' does not exist", WorkspaceId));
+				}
+
+				if (!Workspace.AllowShareCreationFromHttp)
+				{
+					if (!MayChangeConfiguration(ServerRequest))
+					{
+						return ServerRequest.WriteResponse(
+							HttpResponseCode::Unauthorized,
+							HttpContentType::kText,
+							fmt::format("Adding workspace share {} in workspace {} is not allowed", WorkspaceId, ShareId));
+					}
+				}
+
+				m_WorkspacesStats.WorkspaceShareWriteCount++;
+
+				const Workspaces::WorkspaceShareConfiguration OldConfig =
+					Workspaces::FindWorkspaceShare(Log(), Workspace.RootPath, ShareId);
+				const Workspaces::WorkspaceShareConfiguration NewConfig = {.Id		  = ShareId,
+																		   .SharePath = SharePath,
+																		   .Alias	  = std::string(Alias)};
+
+				if (OldConfig.Id == ShareId && (OldConfig != NewConfig))
+				{
+					return ServerRequest.WriteResponse(
+						HttpResponseCode::Conflict,
+						HttpContentType::kText,
+						fmt::format("Workspace share '{}' already exist in workspace '{}' with share path '{}' and alias '{}'",
+									ShareId,
+									WorkspaceId,
+									OldConfig.SharePath,
+									OldConfig.Alias));
+				}
+				else if (OldConfig.Id == Oid::Zero)
+				{
+					if (Workspaces::WorkspaceShareConfiguration ConfigWithSamePath =
+							Workspaces::FindWorkspaceShare(Log(), Workspace.RootPath, SharePath);
+						ConfigWithSamePath.Id != Oid::Zero)
+					{
+						return ServerRequest.WriteResponse(
+							HttpResponseCode::Conflict,
+							HttpContentType::kText,
+							fmt::format("Workspace share '{}' already exist in workspace '{}' with same share path '{}' and alias '{}'",
+										ShareId,
+										WorkspaceId,
+										OldConfig.SharePath,
+										OldConfig.Alias));
+					}
+				}
+
+				if (!IsDir(Workspace.RootPath / NewConfig.SharePath))
+				{
+					return ServerRequest.WriteResponse(HttpResponseCode::NotFound,
+													   HttpContentType::kText,
+													   fmt::format("directory {} does not exist in workspace {} root '{}'",
+																   NewConfig.SharePath,
+																   WorkspaceId,
+																   Workspace.RootPath));
+				}
+
+				bool Created = Workspaces::AddWorkspaceShare(Log(), Workspace.RootPath, NewConfig);
+				if (Created)
+				{
+					RefreshState();
+					return ServerRequest.WriteResponse(HttpResponseCode::Created, HttpContentType::kText, fmt::format("{}", ShareId));
+				}
+				return ServerRequest.WriteResponse(HttpResponseCode::OK, HttpContentType::kText, fmt::format("{}", ShareId));
+			}
+		case HttpVerb::kGet:
+			{
+				if (WorkspaceId == Oid::Zero)
+				{
+					m_WorkspacesStats.BadRequestCount++;
+					return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+													   HttpContentType::kText,
+													   fmt::format("Invalid workspace id '{}'", Req.GetCapture(1)));
+				}
+				if (ShareId == Oid::Zero)
+				{
+					m_WorkspacesStats.BadRequestCount++;
+					return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+													   HttpContentType::kText,
+													   fmt::format("Invalid share id '{}'", ShareId));
+				}
+
+				m_WorkspacesStats.WorkspaceShareReadCount++;
+				std::optional<Workspaces::WorkspaceShareConfiguration> Config =
+					m_Workspaces.GetWorkspaceShareConfiguration(WorkspaceId, ShareId);
+				if (!Config)
+				{
+					return ServerRequest.WriteResponse(HttpResponseCode::NotFound);
+				}
+
+				CbObjectWriter Response;
+				WriteWorkspaceShareConfig(Response, *Config);
+				return ServerRequest.WriteResponse(HttpResponseCode::OK, Response.Save());
+			}
+		case HttpVerb::kDelete:
+			{
+				if (WorkspaceId == Oid::Zero)
+				{
+					m_WorkspacesStats.BadRequestCount++;
+					return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+													   HttpContentType::kText,
+													   fmt::format("Invalid workspace id '{}'", Req.GetCapture(1)));
+				}
+				if (ShareId == Oid::Zero)
+				{
+					m_WorkspacesStats.BadRequestCount++;
+					return ServerRequest.WriteResponse(HttpResponseCode::BadRequest,
+													   HttpContentType::kText,
+													   fmt::format("Invalid share id '{}'", ShareId));
+				}
+
+				Workspaces::WorkspaceConfiguration Workspace = Workspaces::FindWorkspace(Log(), GetStatePath(), WorkspaceId);
+				if (Workspace.Id == Oid::Zero)
+				{
+					return ServerRequest.WriteResponse(HttpResponseCode::NotFound);
+				}
+
+				if (!Workspace.AllowShareCreationFromHttp)
+				{
+					if (!MayChangeConfiguration(ServerRequest))
+					{
+						return ServerRequest.WriteResponse(
+							HttpResponseCode::Unauthorized,
+							HttpContentType::kText,
+							fmt::format("Removing workspace share {} in workspace {} is not allowed", WorkspaceId, ShareId));
+					}
+				}
+
+				m_WorkspacesStats.WorkspaceShareDeleteCount++;
+				bool Deleted = Workspaces::RemoveWorkspaceShare(Log(), Workspace.RootPath, ShareId);
+				if (Deleted)
+				{
+					RefreshState();
+					return ServerRequest.WriteResponse(HttpResponseCode::OK);
+				}
+				return ServerRequest.WriteResponse(HttpResponseCode::NotFound);
+			}
+	}
+}
+
+}  // namespace zen