issue-6608: Implement quota usage aggregation across shards

Author: debnatkh

cloud/filestore/libs/storage/service/service_ut_sharding.cpp

@@ -620,6 +620,74 @@ Y_UNIT_TEST_SUITE(TStorageServiceShardingTest)
         }
     }
 
+    SERVICE_TEST(ShouldAggregateQuotaUsageAcrossShards)
+    {
+        TShardedFileSystemConfig fsConfig;
+        CREATE_ENV_AND_SHARDED_FILESYSTEM();
+
+        {
+            NProtoPrivate::TSetQuotaRequest request;
+            request.SetFileSystemId(fsConfig.FsId);
+            request.SetQuotaId(42);
+            request.SetMaxBytes(1_GB);
+            request.SetMaxNodes(100);
+
+            TString buf;
+            google::protobuf::util::MessageToJsonString(request, &buf);
+            service.ExecuteAction("setquota", buf);
+        }
+
+        auto headers = service.InitSession(fsConfig.FsId, "client");
+
+        // attach the quota to a directory on main - files are regular nodes,
+        // so main auto-routes their creation into shards (round-robin) and
+        // forwards the inherited QuotaId along with each one; the directory
+        // itself stays on main and its own attach bumps main's own local
+        // usage by 1
+        auto dirId = service
+                         .CreateNode(
+                             headers,
+                             TCreateNodeArgs::Directory(RootNodeId, "dir"))
+                         ->Record.GetNode()
+                         .GetId();
+        service.SetNodeAttr(
+            headers,
+            fsConfig.FsId,
+            TSetNodeAttrArgs(dirId).SetQuotaId(42));
+
+        constexpr ui32 fileCount = 4;
+        for (ui32 i = 0; i < fileCount; ++i) {
+            service.CreateNode(
+                headers,
+                TCreateNodeArgs::File(dirId, "file" + ToString(i)));
+        }
+
+        // each shard should have received at least one of the files -
+        // otherwise this test wouldn't actually be exercising cross-shard
+        // aggregation
+        for (const auto& shardId: fsConfig.ShardIds()) {
+            const auto stats = GetStorageStats(service, shardId);
+            const auto& usages = stats.GetStats().GetQuotaUsages();
+            UNIT_ASSERT_VALUES_EQUAL_C(1, usages.size(), shardId);
+            UNIT_ASSERT_VALUES_EQUAL_C(42u, usages[0].GetQuotaId(), shardId);
+            UNIT_ASSERT_C(usages[0].GetUsedNodes() > 0, shardId);
+        }
+
+        // forcing main to fan out and aggregate should sum main's own local
+        // usage (the directory attach point) and both shards' contributions
+        // (the files) together
+        const auto aggregate = GetStorageStats(
+            service,
+            fsConfig.FsId,
+            0 /* cacheTTL */,
+            NProtoPrivate::STATS_REQUEST_MODE_FORCE_FETCH_SHARDS);
+        const auto& usages = aggregate.GetStats().GetQuotaUsages();
+        UNIT_ASSERT_VALUES_EQUAL(1, usages.size());
+        UNIT_ASSERT_VALUES_EQUAL(42u, usages[0].GetQuotaId());
+        UNIT_ASSERT_VALUES_EQUAL(1 + fileCount, usages[0].GetUsedNodes());
+        UNIT_ASSERT_VALUES_EQUAL(0u, usages[0].GetUsedBytes());
+    }
+
     SERVICE_TEST(ShouldCheckForShardsInAdapterModeUponSessionCreationInShards)
     {
         //

cloud/filestore/libs/storage/tablet/tablet_actor_counters.cpp

@@ -17,6 +17,31 @@ using namespace NMetrics;
 
 namespace {
 
+////////////////////////////////////////////////////////////////////////////////
+
+void MergeQuotaUsages(
+    NProtoPrivate::TStorageStats& dst,
+    const NProtoPrivate::TStorageStats& src)
+{
+    for (const auto& srcUsage: src.GetQuotaUsages()) {
+        NProtoPrivate::TQuotaUsage* dstUsage = nullptr;
+        for (auto& usage: *dst.MutableQuotaUsages()) {
+            if (usage.GetQuotaId() == srcUsage.GetQuotaId()) {
+                dstUsage = &usage;
+                break;
+            }
+        }
+        if (!dstUsage) {
+            dstUsage = dst.AddQuotaUsages();
+            dstUsage->SetQuotaId(srcUsage.GetQuotaId());
+        }
+        dstUsage->SetUsedBytes(
+            dstUsage->GetUsedBytes() + srcUsage.GetUsedBytes());
+        dstUsage->SetUsedNodes(
+            dstUsage->GetUsedNodes() + srcUsage.GetUsedNodes());
+    }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // TAggregateStatsActor always replies with
 // TAggregateStatsCompleted to a TIndexTabletActor that created the actor.
@@ -230,6 +255,8 @@ void TAggregateStatsActor::HandleGetStorageStatsResponse(
     dst.SetSevenBytesHandlesCount(
         dst.GetSevenBytesHandlesCount() + src.GetSevenBytesHandlesCount());
 
+    MergeQuotaUsages(dst, src);
+
     LOG_DEBUG(
         ctx,
         TFileStoreComponents::TABLET_WORKER,
@@ -810,6 +837,13 @@ void TIndexTabletActor::FillSelfStorageStats(
     stats->SetUnconfirmedDataCount(
         UnconfirmedData.size() + UnconfirmedDataInProgress.size());
     stats->SetConfirmedDataCount(ConfirmedData.size());
+
+    for (const auto& usage: GetQuotaUsages()) {
+        auto* proto = stats->AddQuotaUsages();
+        proto->SetQuotaId(usage.QuotaId);
+        proto->SetUsedBytes(usage.UsedBytes);
+        proto->SetUsedNodes(usage.UsedNodes);
+    }
 }
 
 void TIndexTabletActor::HandleGetStorageStats(

cloud/filestore/libs/storage/tablet/tablet_actor_monitoring.cpp

@@ -1356,15 +1356,24 @@ void TIndexTabletActor::RenderHttpInfo_QuotasTab(IOutputStream& out)
                         TABLEH() { out << "QuotaId"; }
                         TABLEH() { out << "MaxBytes"; }
                         TABLEH() { out << "MaxNodes"; }
+                        TABLEH() { out << "UsedBytes"; }
+                        TABLEH() { out << "UsedNodes"; }
                         TABLEH() { out << "CreatedAt"; }
                     }
                 }
 
                 for (const auto& quota: quotas) {
+                    const auto* usage = FindQuotaUsage(quota.GetQuotaId());
                     TABLER() {
                         TABLED() { out << quota.GetQuotaId(); }
                         TABLED() { out << FormatByteSize(quota.GetMaxBytes()); }
                         TABLED() { out << quota.GetMaxNodes(); }
+                        TABLED() {
+                            out << (usage
+                                ? FormatByteSize(usage->UsedBytes)
+                                : FormatByteSize(0));
+                        }
+                        TABLED() { out << (usage ? usage->UsedNodes : 0); }
                         TABLED() {
                             out << TInstant::MicroSeconds(
                                 quota.GetCreationTimestampUs());

cloud/filestore/libs/storage/tablet/tablet_state.h

@@ -1370,6 +1370,8 @@ FILESTORE_DUPCACHE_REQUESTS(FILESTORE_DECLARE_DUPCACHE)
 
     void LoadQuotaUsages(const TVector<TQuotaUsage>& usages);
 
+    const TQuotaUsage* FindQuotaUsage(ui32 quotaId) const;
+
     TVector<TQuotaUsage> GetQuotaUsages() const;
 
     //

cloud/filestore/libs/storage/tablet/tablet_state_quotas.cpp

@@ -63,6 +63,11 @@ void TIndexTabletState::LoadQuotaUsages(const TVector<TQuotaUsage>& usages)
     }
 }
 
+const TQuotaUsage* TIndexTabletState::FindQuotaUsage(ui32 quotaId) const
+{
+    return Impl->Quotas.FindUsage(quotaId);
+}
+
 TVector<TQuotaUsage> TIndexTabletState::GetQuotaUsages() const
 {
     return Impl->Quotas.GetUsages();

cloud/filestore/private/api/protos/tablet.proto

@@ -176,6 +176,10 @@ message TStorageStats
     repeated TNodeStats NodeStats = 7001;
 
     repeated TNodeLatencyStats LatencyStats = 8001;
+
+    // aggregated usage per quota, summed across this tablet and (once
+    // fanned out and merged by TAggregateStatsActor) every shard
+    repeated TQuotaUsage QuotaUsages = 9001;
 }
 
 enum EStatsRequestMode