new handler to return tablet info by scheme object

6 files changed, 174 insertions, 51 deletions

diff --git a/ydb/core/mind/hive/hive_impl.cpp b/ydb/core/mind/hive/hive_impl.cpp
index 7b374f60e85..c266f41e71b 100644
--- a/ydb/core/mind/hive/hive_impl.cpp
+++ b/ydb/core/mind/hive/hive_impl.cpp
@@ -1808,8 +1808,12 @@ void THive::Handle(TEvHive::TEvRequestHiveDomainStats::TPtr& ev) {
 }
 
 void THive::Handle(TEvHive::TEvRequestHiveNodeStats::TPtr& ev) {
+    const auto& request(ev->Get()->Record);
     THolder<TEvHive::TEvResponseHiveNodeStats> response = MakeHolder<TEvHive::TEvResponseHiveNodeStats>();
     auto& record = response->Record;
+    if (request.GetReturnExtendedTabletInfo()) {
+        record.SetExtendedTabletInfo(true);
+    }
     for (auto it = Nodes.begin(); it != Nodes.end(); ++it) {
         auto& nodeStats = *record.AddNodeStats();
         const TNodeInfo& node = it->second;
@@ -1817,14 +1821,66 @@ void THive::Handle(TEvHive::TEvRequestHiveNodeStats::TPtr& ev) {
         if (!node.ServicedDomains.empty()) {
             nodeStats.MutableNodeDomain()->CopyFrom(node.ServicedDomains.front());
         }
-        for (const auto& [state, set] : node.Tablets) {
-            if (!set.empty()) {
-                auto* stateStats = nodeStats.AddStateStats();
-                stateStats->SetVolatileState(state);
-                stateStats->SetCount(set.size());
+        if (request.GetReturnExtendedTabletInfo()) {
+            if (request.HasFilterTabletsByPathId()) {
+                auto itTabletsOfObject = node.TabletsOfObject.find(request.GetFilterTabletsByPathId());
+                if (itTabletsOfObject != node.TabletsOfObject.end()) {
+                    std::vector<std::vector<ui32>> tabletStateToTypeToCount;
+                    tabletStateToTypeToCount.resize(NKikimrHive::ETabletVolatileState_ARRAYSIZE);
+                    for (const TTabletInfo* tablet : itTabletsOfObject->second) {
+                        NKikimrHive::ETabletVolatileState state = tablet->GetVolatileState();
+                        if (state > NKikimrHive::ETabletVolatileState_MAX) {
+                            continue;
+                        }
+                        std::vector<ui32>& tabletTypeToCount(tabletStateToTypeToCount[state]);
+                        TTabletTypes::EType type = tablet->GetTabletType();
+                        if (static_cast<size_t>(type) >= tabletTypeToCount.size()) {
+                            tabletTypeToCount.resize(type + 1);
+                        }
+                        tabletTypeToCount[type]++;
+                    }
+                    for (unsigned int state = 0; state < tabletStateToTypeToCount.size(); ++state) {
+                        const std::vector<ui32>& tabletTypeToCount(tabletStateToTypeToCount[state]);
+                        for (unsigned int type = 0; type < tabletTypeToCount.size(); ++type) {
+                            if (tabletTypeToCount[type] > 0) {
+                                auto* stateStats = nodeStats.AddStateStats();
+                                stateStats->SetVolatileState(static_cast<NKikimrHive::ETabletVolatileState>(state));
+                                stateStats->SetTabletType(static_cast<TTabletTypes::EType>(type));
+                                stateStats->SetCount(tabletTypeToCount[type]);
+                            }
+                        }
+                    }
+                }
+            } else {
+                for (const auto& [state, set] : node.Tablets) {
+                    std::vector<ui32> tabletTypeToCount;
+                    for (const TTabletInfo* tablet : set) {
+                        TTabletTypes::EType type = tablet->GetTabletType();
+                        if (static_cast<size_t>(type) >= tabletTypeToCount.size()) {
+                            tabletTypeToCount.resize(type + 1);
+                        }
+                        tabletTypeToCount[type]++;
+                    }
+                    for (unsigned int type = 0; type < tabletTypeToCount.size(); ++type) {
+                        if (tabletTypeToCount[type] > 0) {
+                            auto* stateStats = nodeStats.AddStateStats();
+                            stateStats->SetVolatileState(state);
+                            stateStats->SetTabletType(static_cast<TTabletTypes::EType>(type));
+                            stateStats->SetCount(tabletTypeToCount[type]);
+                        }
+                    }
+                }
+            }
+        } else {
+            for (const auto& [state, set] : node.Tablets) {
+                if (!set.empty()) {
+                    auto* stateStats = nodeStats.AddStateStats();
+                    stateStats->SetVolatileState(state);
+                    stateStats->SetCount(set.size());
+                }
             }
         }
-        if (ev->Get()->Record.GetReturnMetrics()) {
+        if (request.GetReturnMetrics()) {
             nodeStats.MutableMetrics()->CopyFrom(MetricsFromResourceRawValues(node.GetResourceCurrentValues()));
         }
         if (!node.IsAlive()) {
diff --git a/ydb/core/protos/hive.proto b/ydb/core/protos/hive.proto
index 7fe7f53e70c..a3aaf1a0dac 100644
--- a/ydb/core/protos/hive.proto
+++ b/ydb/core/protos/hive.proto
@@ -282,6 +282,7 @@ message TEvRequestHiveDomainStats {
 message THiveDomainStatsStateCount {
     optional ETabletVolatileState VolatileState = 1;
     optional uint32 Count = 2;
+    optional NKikimrTabletBase.TTabletTypes.EType TabletType = 3; // only for extended tablet info
 }
 
 message THiveDomainStats {
@@ -299,6 +300,8 @@ message TEvResponseHiveDomainStats {
 
 message TEvRequestHiveNodeStats {
     optional bool ReturnMetrics = 5;
+    optional bool ReturnExtendedTabletInfo = 6;
+    optional uint64 FilterTabletsByPathId = 7;
 }
 
 message THiveNodeStats {
@@ -312,6 +315,7 @@ message THiveNodeStats {
 
 message TEvResponseHiveNodeStats {
     repeated THiveNodeStats NodeStats = 1;
+    optional bool ExtendedTabletInfo = 2;
 }
 
 message TEvRequestHiveStorageStats {
diff --git a/ydb/core/viewer/json_compute.h b/ydb/core/viewer/json_compute.h
index 92c8b12d3ff..92d9c9f8557 100644
--- a/ydb/core/viewer/json_compute.h
+++ b/ydb/core/viewer/json_compute.h
@@ -28,6 +28,7 @@ class TJsonCompute : public TViewerPipeClient<TJsonCompute> {
     THashMap<TString, NKikimrViewer::TTenant> TenantByPath;
     THashMap<TPathId, NKikimrViewer::TTenant> TenantBySubDomainKey;
     THashMap<TPathId, TTabletId> HiveBySubDomainKey;
+    THashMap<TString, TPathId> SubDomainKeyByPath;
     THashMap<TString, THolder<NSchemeCache::TSchemeCacheNavigate>> NavigateResult;
     THashMap<TTabletId, THolder<TEvHive::TEvResponseHiveDomainStats>> HiveDomainStats;
     THashMap<TTabletId, THolder<TEvHive::TEvResponseHiveNodeStats>> HiveNodeStats;
@@ -40,6 +41,7 @@ class TJsonCompute : public TViewerPipeClient<TJsonCompute> {
     ui32 Timeout = 0;
     TString User;
     TString Path;
+    TString DomainPath;
     TPathId FilterSubDomain;
     bool Tablets = true;
     TTabletId RootHiveId = 0;
@@ -60,6 +62,22 @@ public:
         return TStringBuilder() << pathId.OwnerId << '-' << pathId.LocalPathId;
     }
 
+    bool IsFitsToPath(const TString& path) const {
+        if (Path.empty()) {
+            return true;
+        }
+        if (Path == path) {
+            return true;
+        }
+        if (Path == DomainPath) {
+            return false;
+        }
+        if (Path.StartsWith(path)) {
+            return true;
+        }
+        return false;
+    }
+
     void Bootstrap(const TActorContext& ) {
         const auto& params(Event->Get()->Request.GetParams());
         JsonSettings.EnumAsNumbers = !FromStringWithDefault<bool>(params.Get("enums"), true);
@@ -76,13 +94,13 @@ public:
 
         RequestConsoleListTenants();
 
-        TString domainPath = "/" + domain->Name;
-        if (Path.empty() || domainPath == Path) {
-            NKikimrViewer::TTenant& tenant = TenantByPath[domainPath];
-            tenant.SetName(domainPath);
+        DomainPath = "/" + domain->Name;
+        if (Path.empty() || DomainPath == Path) {
+            NKikimrViewer::TTenant& tenant = TenantByPath[DomainPath];
+            tenant.SetName(DomainPath);
             tenant.SetState(Ydb::Cms::GetDatabaseStatusResult::RUNNING);
             tenant.SetType(NKikimrViewer::Domain);
-            RequestSchemeCacheNavigate(domainPath);
+            RequestSchemeCacheNavigate(DomainPath);
         }
         RootHiveId = domains->GetHive(domain->DefaultHiveUid);
         if (Requests == 0) {
@@ -124,11 +142,11 @@ public:
         Ydb::Cms::ListDatabasesResult listTenantsResult;
         ev->Get()->Record.GetResponse().operation().result().UnpackTo(&listTenantsResult);
         for (const TString& path : listTenantsResult.paths()) {
-            if (!Path.empty() && path != Path) {
-                continue;
+            if (IsFitsToPath(path)) {
+                TString p(Path.empty() ? path : Path);
+                TenantByPath[p];
+                RequestSchemeCacheNavigate(p);
             }
-            TenantByPath[path];
-            RequestSchemeCacheNavigate(path);
         }
         RequestDone();
     }
@@ -148,43 +166,59 @@ public:
             tenant.MutableMetrics()->CopyFrom(hiveStat.GetMetrics());
             tenant.MutableNodeIds()->CopyFrom(hiveStat.GetNodeIds());
             tenant.SetAliveNodes(hiveStat.GetAliveNodes());
-
-            for (TNodeId nodeId : hiveStat.GetNodeIds()) {
-                if (NodeIds.insert(nodeId).second) {
-                    TActorId whiteboardServiceId = MakeNodeWhiteboardServiceId(nodeId);
-                    THolder<NNodeWhiteboard::TEvWhiteboard::TEvSystemStateRequest> request = MakeHolder<NNodeWhiteboard::TEvWhiteboard::TEvSystemStateRequest>();
-                    SendRequest(whiteboardServiceId, request.Release(), IEventHandle::FlagTrackDelivery | IEventHandle::FlagSubscribeOnSession, nodeId);
-                    if (Tablets) {
-                        THolder<NNodeWhiteboard::TEvWhiteboard::TEvTabletStateRequest> request = MakeHolder<NNodeWhiteboard::TEvWhiteboard::TEvTabletStateRequest>();
-                        SendRequest(whiteboardServiceId, request.Release(), IEventHandle::FlagTrackDelivery | IEventHandle::FlagSubscribeOnSession, nodeId);
-                    }
-                }
-            }
         }
         HiveDomainStats[ev->Cookie] = std::move(ev->Release());
         RequestDone();
     }
 
     void Handle(TEvHive::TEvResponseHiveNodeStats::TPtr& ev) {
+        for (const NKikimrHive::THiveNodeStats& nodeStat : ev->Get()->Record.GetNodeStats()) {
+            auto nodeId = nodeStat.GetNodeId();
+            if (NodeIds.insert(nodeId).second) {
+                TActorId whiteboardServiceId = MakeNodeWhiteboardServiceId(nodeId);
+                THolder<NNodeWhiteboard::TEvWhiteboard::TEvSystemStateRequest> request = MakeHolder<NNodeWhiteboard::TEvWhiteboard::TEvSystemStateRequest>();
+                SendRequest(whiteboardServiceId, request.Release(), IEventHandle::FlagTrackDelivery | IEventHandle::FlagSubscribeOnSession, nodeId);
+                if (Tablets && !ev->Get()->Record.GetExtendedTabletInfo()) {
+                    THolder<NNodeWhiteboard::TEvWhiteboard::TEvTabletStateRequest> request = MakeHolder<NNodeWhiteboard::TEvWhiteboard::TEvTabletStateRequest>();
+                    SendRequest(whiteboardServiceId, request.Release(), IEventHandle::FlagTrackDelivery | IEventHandle::FlagSubscribeOnSession, nodeId);
+                }
+            }
+        }
         HiveNodeStats[ev->Cookie] = std::move(ev->Release());
         RequestDone();
     }
 
     void Handle(TEvTxProxySchemeCache::TEvNavigateKeySetResult::TPtr& ev) {
         if (ev->Get()->Request->ResultSet.size() == 1 && ev->Get()->Request->ResultSet.begin()->Status == NSchemeCache::TSchemeCacheNavigate::EStatus::Ok) {
-            auto domainInfo = ev->Get()->Request->ResultSet.begin()->DomainInfo;
+            const NSchemeCache::TSchemeCacheNavigate::TEntry& result(ev->Get()->Request->ResultSet.front());
+            ui64 pathId = 0;
+            if (!Path.empty() && result.Self) {
+                switch (result.Self->Info.GetPathType()) {
+                    case NKikimrSchemeOp::EPathTypeTable:
+                    case NKikimrSchemeOp::EPathTypePersQueueGroup:
+                    case NKikimrSchemeOp::EPathTypeTableIndex:
+                    case NKikimrSchemeOp::EPathTypeColumnTable:
+                    case NKikimrSchemeOp::EPathTypeColumnStore:
+                    case NKikimrSchemeOp::EPathTypeCdcStream:
+                    case NKikimrSchemeOp::EPathTypeKesus:
+                        pathId = result.Self->Info.GetPathId();
+                        break;
+                    default:
+                        break;
+                }
+            }
+            auto domainInfo = result.DomainInfo;
             ui64 hiveId = domainInfo->Params.GetHive();
-            if (hiveId) {
-                RequestHiveDomainStats(hiveId);
-                RequestHiveNodeStats(hiveId);
-                HiveBySubDomainKey[domainInfo->DomainKey] = hiveId;
-            } else {
+            if (hiveId == 0) {
                 if (!RootHiveRequested) {
-                    RequestHiveDomainStats(RootHiveId);
-                    RequestHiveNodeStats(RootHiveId);
+                    hiveId = RootHiveId;
                     RootHiveRequested = true;
                 }
-                HiveBySubDomainKey[domainInfo->DomainKey] = RootHiveId;
+            }
+            if (hiveId) {
+                RequestHiveDomainStats(hiveId);
+                RequestHiveNodeStats(hiveId, pathId);
+                HiveBySubDomainKey[domainInfo->DomainKey] = hiveId;
             }
             if (domainInfo->ResourcesDomainKey != domainInfo->DomainKey) {
                 TenantBySubDomainKey[domainInfo->ResourcesDomainKey].SetType(NKikimrViewer::Shared);
@@ -192,9 +226,10 @@ public:
                 TenantBySubDomainKey[domainInfo->DomainKey].SetResourceId(GetDomainId(domainInfo->ResourcesDomainKey));
             }
 
-            TString path = CanonizePath(ev->Get()->Request->ResultSet.begin()->Path);
+            TString path = CanonizePath(result.Path);
+            SubDomainKeyByPath[path] = domainInfo->DomainKey;
             NavigateResult[path] = std::move(ev->Get()->Request);
-            if (Path && Path == path) {
+            if (IsFitsToPath(path)) {
                 FilterSubDomain = domainInfo->DomainKey;
             }
         }
@@ -227,14 +262,7 @@ public:
         }
     }
 
-    void Disconnected(TEvInterconnect::TEvNodeDisconnected::TPtr& ev) {
-        ui32 nodeId = ev->Get()->NodeId;
-        if (NodeSysInfo.emplace(nodeId, NKikimrWhiteboard::TEvSystemStateResponse{}).second) {
-            RequestDone();
-        }
-        if (NodeTabletInfo.emplace(nodeId, NKikimrWhiteboard::TEvTabletStateResponse{}).second) {
-            RequestDone();
-        }
+    void Disconnected(TEvInterconnect::TEvNodeDisconnected::TPtr&) {
     }
 
     void ReplyAndPassAway() {
@@ -262,10 +290,9 @@ public:
             const TString& path = prTenant.first;
             NKikimrViewer::TComputeTenantInfo& computeTenantInfo = *Result.AddTenants();
             computeTenantInfo.SetName(path);
-            auto itNavigate = NavigateResult.find(path);
-            if (itNavigate != NavigateResult.end()) {
-                NSchemeCache::TSchemeCacheNavigate::TEntry entry = itNavigate->second->ResultSet.front();
-                TPathId subDomainKey(entry.DomainInfo->DomainKey);
+            auto itSubDomainKey = SubDomainKeyByPath.find(path);
+            if (itSubDomainKey != SubDomainKeyByPath.end()) {
+                TPathId subDomainKey(itSubDomainKey->second);
                 const NKikimrViewer::TTenant& tenantBySubDomainKey(TenantBySubDomainKey[subDomainKey]);
                 for (TNodeId nodeId : tenantBySubDomainKey.GetNodeIds()) {
                     NKikimrViewer::TComputeNodeInfo& computeNodeInfo = *computeTenantInfo.AddNodes();
@@ -337,6 +364,15 @@ public:
                     auto itHiveNodeStats = hiveNodeStatsIndex.find(nodeId);
                     if (itHiveNodeStats != hiveNodeStatsIndex.end()) {
                         computeNodeInfo.MutableMetrics()->CopyFrom(itHiveNodeStats->second->GetMetrics());
+                        for (const auto& state : itHiveNodeStats->second->GetStateStats()) {
+                            if (state.HasTabletType()) {
+                                NKikimrViewer::TTabletStateInfo& tablet = *computeNodeInfo.AddTablets();
+                                tablet.SetType(NKikimrTabletBase::TTabletTypes::EType_Name(state.GetTabletType()));
+                                tablet.SetCount(state.GetCount());
+                                NKikimrViewer::EFlag flag = GetFlagFromTabletState(state.GetVolatileState());
+                                tablet.SetState(flag);
+                            }
+                        }
                     }
                 }
             }
diff --git a/ydb/core/viewer/json_pipe_req.h b/ydb/core/viewer/json_pipe_req.h
index fbbe2e01603..76f0f44f902 100644
--- a/ydb/core/viewer/json_pipe_req.h
+++ b/ydb/core/viewer/json_pipe_req.h
@@ -102,10 +102,14 @@ protected:
         SendRequestToPipe(pipeClient, request.Release(), hiveId);
     }
 
-    void RequestHiveNodeStats(NNodeWhiteboard::TTabletId hiveId) {
+    void RequestHiveNodeStats(NNodeWhiteboard::TTabletId hiveId, ui64 pathId) {
         TActorId pipeClient = ConnectTabletPipe(hiveId);
         THolder<TEvHive::TEvRequestHiveNodeStats> request = MakeHolder<TEvHive::TEvRequestHiveNodeStats>();
         request->Record.SetReturnMetrics(Metrics);
+        if (pathId) {
+            request->Record.SetReturnExtendedTabletInfo(true);
+            request->Record.SetFilterTabletsByPathId(pathId);
+        }
         SendRequestToPipe(pipeClient, request.Release(), hiveId);
     }
 
diff --git a/ydb/core/viewer/viewer.cpp b/ydb/core/viewer/viewer.cpp
index 4d24e78f98d..06f6deba7d0 100644
--- a/ydb/core/viewer/viewer.cpp
+++ b/ydb/core/viewer/viewer.cpp
@@ -491,6 +491,28 @@ NKikimrViewer::EFlag GetFlagFromTabletState(NKikimrWhiteboard::TTabletStateInfo:
     return flag;
 }
 
+NKikimrViewer::EFlag GetFlagFromTabletState(NKikimrHive::ETabletVolatileState state) {
+    NKikimrViewer::EFlag flag = NKikimrViewer::EFlag::Grey;
+    switch (state) {
+        case NKikimrHive::ETabletVolatileState::TABLET_VOLATILE_STATE_STOPPED:
+            flag = NKikimrViewer::EFlag::Red;
+            break;
+        case NKikimrHive::ETabletVolatileState::TABLET_VOLATILE_STATE_BOOTING:
+            flag = NKikimrViewer::EFlag::Orange;
+            break;
+        case NKikimrHive::ETabletVolatileState::TABLET_VOLATILE_STATE_STARTING:
+            flag = NKikimrViewer::EFlag::Yellow;
+            break;
+        case NKikimrHive::ETabletVolatileState::TABLET_VOLATILE_STATE_RUNNING:
+            flag = NKikimrViewer::EFlag::Green;
+            break;
+        default:
+            flag = NKikimrViewer::EFlag::Red;
+            break;
+    }
+    return flag;
+}
+
 NKikimrViewer::EFlag GetFlagFromUsage(double usage) {
     NKikimrViewer::EFlag flag = NKikimrViewer::EFlag::Grey;
     if (usage >= 0.94) {
diff --git a/ydb/core/viewer/viewer.h b/ydb/core/viewer/viewer.h
index 4a9a6a170bc..3d0971696b4 100644
--- a/ydb/core/viewer/viewer.h
+++ b/ydb/core/viewer/viewer.h
@@ -214,6 +214,7 @@ void SplitIds(TStringBuf source, char delim, std::unordered_set<ValueType>& valu
 TString GetHTTPOKJSON();
 TString GetHTTPGATEWAYTIMEOUT();
 NKikimrViewer::EFlag GetFlagFromTabletState(NKikimrWhiteboard::TTabletStateInfo::ETabletState state);
+NKikimrViewer::EFlag GetFlagFromTabletState(NKikimrHive::ETabletVolatileState state);
 NKikimrViewer::EFlag GetPDiskStateFlag(const NKikimrWhiteboard::TPDiskStateInfo& info);
 NKikimrViewer::EFlag GetPDiskOverallFlag(const NKikimrWhiteboard::TPDiskStateInfo& info);
 NKikimrViewer::EFlag GetVDiskOverallFlag(const NKikimrWhiteboard::TVDiskStateInfo& info);