Add info (GET) endpoints for structured cache (#211)

* Add GET requests on cache/namespace/bucket level
* Add root route for project store requests (same as /list)
* Add markerpath to oplog info object
* Add totalsize, opcount and expired to oplog info
* Changelog

1 files changed, 154 insertions, 5 deletions

diff --git a/zenserver/cache/structuredcachestore.cpp b/zenserver/cache/structuredcachestore.cpp
index de1243ddd..b32497a30 100644
--- a/zenserver/cache/structuredcachestore.cpp
+++ b/zenserver/cache/structuredcachestore.cpp
@@ -334,6 +334,38 @@ ZenCacheNamespace::StorageSize() const
 	return {.DiskSize = m_DiskLayer.TotalSize(), .MemorySize = m_MemLayer.TotalSize()};
 }
 
+ZenCacheNamespace::Info
+ZenCacheNamespace::GetInfo() const
+{
+	ZenCacheNamespace::Info			Info = {.Config			 = {.RootDir = m_RootDir, .DiskLayerThreshold = m_DiskLayerSizeThreshold},
+											.DiskLayerInfo	 = m_DiskLayer.GetInfo(),
+											.MemoryLayerInfo = m_MemLayer.GetInfo()};
+	std::unordered_set<std::string> BucketNames;
+	for (const std::string& BucketName : Info.DiskLayerInfo.BucketNames)
+	{
+		BucketNames.insert(BucketName);
+	}
+	for (const std::string& BucketName : Info.MemoryLayerInfo.BucketNames)
+	{
+		BucketNames.insert(BucketName);
+	}
+	Info.BucketNames.insert(Info.BucketNames.end(), BucketNames.begin(), BucketNames.end());
+	return Info;
+}
+
+std::optional<ZenCacheNamespace::BucketInfo>
+ZenCacheNamespace::GetBucketInfo(std::string_view Bucket) const
+{
+	std::optional<ZenCacheDiskLayer::BucketInfo> DiskBucketInfo = m_DiskLayer.GetBucketInfo(Bucket);
+	if (!DiskBucketInfo.has_value())
+	{
+		return {};
+	}
+	ZenCacheNamespace::BucketInfo Info = {.DiskLayerInfo   = *DiskBucketInfo,
+										  .MemoryLayerInfo = m_MemLayer.GetBucketInfo(Bucket).value_or(ZenCacheMemoryLayer::BucketInfo{})};
+	return Info;
+}
+
 //////////////////////////////////////////////////////////////////////////
 
 ZenCacheMemoryLayer::ZenCacheMemoryLayer()
@@ -484,6 +516,33 @@ ZenCacheMemoryLayer::TotalSize() const
 	return TotalSize;
 }
 
+ZenCacheMemoryLayer::Info
+ZenCacheMemoryLayer::GetInfo() const
+{
+	ZenCacheMemoryLayer::Info Info = {.Config = m_Configuration, .TotalSize = TotalSize()};
+
+	RwLock::SharedLockScope _(m_Lock);
+	Info.BucketNames.reserve(m_Buckets.size());
+	for (auto& Kv : m_Buckets)
+	{
+		Info.BucketNames.push_back(Kv.first);
+		Info.EntryCount += Kv.second->EntryCount();
+	}
+	return Info;
+}
+
+std::optional<ZenCacheMemoryLayer::BucketInfo>
+ZenCacheMemoryLayer::GetBucketInfo(std::string_view Bucket) const
+{
+	RwLock::ExclusiveLockScope _(m_Lock);
+
+	if (auto It = m_Buckets.find(std::string(Bucket)); It != m_Buckets.end())
+	{
+		return ZenCacheMemoryLayer::BucketInfo{.EntryCount = It->second->EntryCount(), .TotalSize = It->second->TotalSize()};
+	}
+	return {};
+}
+
 void
 ZenCacheMemoryLayer::CacheBucket::Scrub(ScrubContext& Ctx)
 {
@@ -582,6 +641,13 @@ ZenCacheMemoryLayer::CacheBucket::Drop()
 	m_TotalSize.store(0);
 }
 
+uint64_t
+ZenCacheMemoryLayer::CacheBucket::EntryCount() const
+{
+	RwLock::SharedLockScope _(m_BucketLock);
+	return static_cast<uint64_t>(m_CacheMap.size());
+}
+
 //////////////////////////////////////////////////////////////////////////
 
 ZenCacheDiskLayer::CacheBucket::CacheBucket(std::string BucketName) : m_BucketName(std::move(BucketName)), m_BucketId(Oid::Zero)
@@ -1601,6 +1667,13 @@ ZenCacheDiskLayer::CacheBucket::UpdateAccessTimes(const std::vector<zen::access_
 	}
 }
 
+uint64_t
+ZenCacheDiskLayer::CacheBucket::EntryCount() const
+{
+	RwLock::SharedLockScope _(m_IndexLock);
+	return static_cast<uint64_t>(m_Index.size());
+}
+
 void
 ZenCacheDiskLayer::CollectGarbage(GcContext& GcCtx)
 {
@@ -2043,15 +2116,38 @@ ZenCacheDiskLayer::TotalSize() const
 	return TotalSize;
 }
 
+ZenCacheDiskLayer::Info
+ZenCacheDiskLayer::GetInfo() const
+{
+	ZenCacheDiskLayer::Info Info = {.Config = {.RootDir = m_RootDir}, .TotalSize = TotalSize()};
+
+	RwLock::SharedLockScope _(m_Lock);
+	Info.BucketNames.reserve(m_Buckets.size());
+	for (auto& Kv : m_Buckets)
+	{
+		Info.BucketNames.push_back(Kv.first);
+		Info.EntryCount += Kv.second->EntryCount();
+	}
+	return Info;
+}
+
+std::optional<ZenCacheDiskLayer::BucketInfo>
+ZenCacheDiskLayer::GetBucketInfo(std::string_view Bucket) const
+{
+	RwLock::ExclusiveLockScope _(m_Lock);
+
+	if (auto It = m_Buckets.find(std::string(Bucket)); It != m_Buckets.end())
+	{
+		return ZenCacheDiskLayer::BucketInfo{.EntryCount = It->second->EntryCount(), .TotalSize = It->second->TotalSize()};
+	}
+	return {};
+}
+
 //////////////////////////// ZenCacheStore
 
 static constexpr std::string_view UE4DDCNamespaceName = "ue4.ddc";
 
-ZenCacheStore::ZenCacheStore(GcManager& Gc, const Configuration& Configuration)
-//: GcStorage(Gc)
-//, GcContributor(Gc)
-: m_Gc(Gc)
-, m_Configuration(Configuration)
+ZenCacheStore::ZenCacheStore(GcManager& Gc, const Configuration& Configuration) : m_Gc(Gc), m_Configuration(Configuration)
 {
 	CreateDirectories(m_Configuration.BasePath);
 
@@ -2186,6 +2282,24 @@ ZenCacheStore::GetNamespace(std::string_view Namespace)
 	return NewNamespace.first->second.get();
 }
 
+const ZenCacheNamespace*
+ZenCacheStore::FindNamespace(std::string_view Namespace) const
+{
+	RwLock::SharedLockScope _(m_NamespacesLock);
+	if (auto It = m_Namespaces.find(std::string(Namespace)); It != m_Namespaces.end())
+	{
+		return It->second.get();
+	}
+	if (Namespace == DefaultNamespace)
+	{
+		if (auto It = m_Namespaces.find(std::string(UE4DDCNamespaceName)); It != m_Namespaces.end())
+		{
+			return It->second.get();
+		}
+	}
+	return nullptr;
+}
+
 void
 ZenCacheStore::IterateNamespaces(const std::function<void(std::string_view Namespace, ZenCacheNamespace& Store)>& Callback) const
 {
@@ -2220,6 +2334,41 @@ ZenCacheStore::StorageSize() const
 	return Size;
 }
 
+ZenCacheStore::Info
+ZenCacheStore::GetInfo() const
+{
+	ZenCacheStore::Info Info = {.Config = m_Configuration, .StorageSize = StorageSize()};
+
+	IterateNamespaces([&Info](std::string_view NamespaceName, ZenCacheNamespace& Namespace) {
+		Info.NamespaceNames.push_back(std::string(NamespaceName));
+		ZenCacheNamespace::Info NamespaceInfo = Namespace.GetInfo();
+		Info.DiskEntryCount += NamespaceInfo.DiskLayerInfo.EntryCount;
+		Info.MemoryEntryCount += NamespaceInfo.MemoryLayerInfo.EntryCount;
+	});
+
+	return Info;
+}
+
+std::optional<ZenCacheNamespace::Info>
+ZenCacheStore::GetNamespaceInfo(std::string_view NamespaceName)
+{
+	if (const ZenCacheNamespace* Namespace = FindNamespace(NamespaceName); Namespace)
+	{
+		return Namespace->GetInfo();
+	}
+	return {};
+}
+
+std::optional<ZenCacheNamespace::BucketInfo>
+ZenCacheStore::GetBucketInfo(std::string_view NamespaceName, std::string_view BucketName)
+{
+	if (const ZenCacheNamespace* Namespace = FindNamespace(NamespaceName); Namespace)
+	{
+		return Namespace->GetBucketInfo(BucketName);
+	}
+	return {};
+}
+
 //////////////////////////////////////////////////////////////////////////
 
 #if ZEN_WITH_TESTS