handlers check equality while sorting

4 files changed, 52 insertions, 99 deletions

diff --git a/ydb/core/viewer/json_compute.h b/ydb/core/viewer/json_compute.h
index 1262fe857b0..b2d8624e86a 100644
--- a/ydb/core/viewer/json_compute.h
+++ b/ydb/core/viewer/json_compute.h
@@ -13,6 +13,7 @@
 #include <ydb/core/viewer/protos/viewer.pb.h>
 #include <ydb/core/viewer/json/json.h>
 #include "viewer.h"
+#include "viewer_helper.h"
 #include "json_pipe_req.h"
 #include "wb_aggregate.h"
 #include "wb_merge.h"
@@ -372,52 +373,33 @@ public:
     }
 
     void PaginateNodes(::google::protobuf::RepeatedPtrField<NKikimrViewer::TComputeNodeInfo>& nodes) {
-        bool reverse = ReverseSort;
         switch (Sort) {
             case ESort::NodeId:
-                ::Sort(nodes, [reverse](const NKikimrViewer::TComputeNodeInfo& a, const NKikimrViewer::TComputeNodeInfo& b) {
-                    return reverse ^ (a.GetNodeId() < b.GetNodeId());
-                });
+                SortCollection(nodes, [](const NKikimrViewer::TComputeNodeInfo& node) { return node.GetNodeId();}, ReverseSort);
                 break;
             case ESort::Host:
-                ::Sort(nodes, [reverse](const NKikimrViewer::TComputeNodeInfo& a, const NKikimrViewer::TComputeNodeInfo& b) {
-                    return reverse ^ (a.GetHost() < b.GetHost());
-                });
+                SortCollection(nodes, [](const NKikimrViewer::TComputeNodeInfo& node) { return node.GetHost();}, ReverseSort);
                 break;
             case ESort::DC:
-                ::Sort(nodes, [reverse](const NKikimrViewer::TComputeNodeInfo& a, const NKikimrViewer::TComputeNodeInfo& b) {
-                    return reverse ^ (a.GetDataCenter() < b.GetDataCenter());
-                });
+                SortCollection(nodes, [](const NKikimrViewer::TComputeNodeInfo& node) { return node.GetDataCenter();}, ReverseSort);
                 break;
             case ESort::Rack:
-                ::Sort(nodes, [reverse](const NKikimrViewer::TComputeNodeInfo& a, const NKikimrViewer::TComputeNodeInfo& b) {
-                    return reverse ^ (a.GetRack() < b.GetRack());
-                });
+                SortCollection(nodes, [](const NKikimrViewer::TComputeNodeInfo& node) { return node.GetRack();}, ReverseSort);
                 break;
             case ESort::Version:
-                ::Sort(nodes, [reverse](const NKikimrViewer::TComputeNodeInfo& a, const NKikimrViewer::TComputeNodeInfo& b) {
-                    return reverse ^ (a.GetVersion() < b.GetVersion());
-                });
+                SortCollection(nodes, [](const NKikimrViewer::TComputeNodeInfo& node) { return node.GetVersion();}, ReverseSort);
                 break;
             case ESort::Uptime:
-                ::Sort(nodes, [reverse](const NKikimrViewer::TComputeNodeInfo& a, const NKikimrViewer::TComputeNodeInfo& b) {
-                    return reverse ^ !(a.GetStartTime() < b.GetStartTime());
-                });
+                SortCollection(nodes, [](const NKikimrViewer::TComputeNodeInfo& node) { return node.GetStartTime();}, ReverseSort);
                 break;
             case ESort::Memory:
-                ::Sort(nodes, [reverse](const NKikimrViewer::TComputeNodeInfo& a, const NKikimrViewer::TComputeNodeInfo& b) {
-                    return reverse ^ (a.GetMemoryUsed() < b.GetMemoryUsed());
-                });
+                SortCollection(nodes, [](const NKikimrViewer::TComputeNodeInfo& node) { return node.GetMemoryUsed();}, ReverseSort);
                 break;
             case ESort::CPU:
-                ::Sort(nodes, [reverse](const NKikimrViewer::TComputeNodeInfo& a, const NKikimrViewer::TComputeNodeInfo& b) {
-                    return reverse ^ (GetCPU(a) < GetCPU(b));
-                });
+                SortCollection(nodes, [](const NKikimrViewer::TComputeNodeInfo& node) { return GetCPU(node);}, ReverseSort);
                 break;
             case ESort::LoadAverage:
-                ::Sort(nodes, [reverse](const NKikimrViewer::TComputeNodeInfo& a, const NKikimrViewer::TComputeNodeInfo& b) {
-                    return reverse ^ (GetLoadAverage(a) < GetLoadAverage(b));
-                });
+                SortCollection(nodes, [](const NKikimrViewer::TComputeNodeInfo& node) { return GetLoadAverage(node);}, ReverseSort);
                 break;
         }
 
diff --git a/ydb/core/viewer/json_nodes.h b/ydb/core/viewer/json_nodes.h
index b6948069d00..a66e895e561 100644
--- a/ydb/core/viewer/json_nodes.h
+++ b/ydb/core/viewer/json_nodes.h
@@ -8,6 +8,7 @@
 #include <ydb/core/protos/node_whiteboard.pb.h>
 #include <ydb/core/viewer/protos/viewer.pb.h>
 #include "viewer.h"
+#include "viewer_helper.h"
 #include "json_pipe_req.h"
 #include "json_sysinfo.h"
 #include "json_pdiskinfo.h"
@@ -251,40 +252,27 @@ public:
 
     void ProcessNodeIds() {
         BLOG_TRACE("ProcessNodeIds()");
-        bool reverse = ReverseSort;
-        std::function<void(TVector<TEvInterconnect::TNodeInfo>&)> sortFunc;
+
         switch (Sort) {
             case ESort::NodeId: {
-                sortFunc = [=](TVector<TEvInterconnect::TNodeInfo>& nodes) {
-                    ::Sort(nodes, [=](const TEvInterconnect::TNodeInfo& a, const TEvInterconnect::TNodeInfo& b) {
-                        return reverse ^ (a.NodeId < b.NodeId);
-                    });
-                };
+                SortCollection(NodesInfo->Nodes, [](const TEvInterconnect::TNodeInfo& node) { return node.NodeId;}, ReverseSort);
+                SortedNodeList = true;
                 break;
             }
             case ESort::Host: {
-                sortFunc = [=](TVector<TEvInterconnect::TNodeInfo>& nodes) {
-                    ::Sort(nodes, [=](const TEvInterconnect::TNodeInfo& a, const TEvInterconnect::TNodeInfo& b) {
-                        return reverse ^ (a.Host < b.Host);
-                    });
-                };
+                SortCollection(NodesInfo->Nodes, [](const TEvInterconnect::TNodeInfo& node) { return node.Host;}, ReverseSort);
+                SortedNodeList = true;
                 break;
             }
             case ESort::DC: {
-                sortFunc = [=](TVector<TEvInterconnect::TNodeInfo>& nodes) {
-                    ::Sort(nodes, [=](const TEvInterconnect::TNodeInfo& a, const TEvInterconnect::TNodeInfo& b) {
-                        return reverse ^ (a.Location.GetDataCenterId() < b.Location.GetDataCenterId());
-                    });
-                };
+                SortCollection(NodesInfo->Nodes, [](const TEvInterconnect::TNodeInfo& node) { return node.Location.GetDataCenterId();}, ReverseSort);
+                SortedNodeList = true;
                 break;
             }
             default:
                 break;
         }
-        if (sortFunc) {
-            sortFunc(NodesInfo->Nodes);
-            SortedNodeList = true;
-        }
+
         for (const auto& ni : NodesInfo->Nodes) {
             if ((FilterNodeIds.empty() || FilterNodeIds.count(ni.NodeId) > 0) && ni.NodeId >= MinAllowedNodeId && ni.NodeId <= MaxAllowedNodeId) {
                 SendNodeRequest(ni.NodeId);
@@ -634,7 +622,6 @@ public:
 
         ui64 totalNodes = PassedNodeIds.size();
         ui64 foundNodes;
-        bool reverse = ReverseSort;
 
         if (With == EWith::Everything) {
             foundNodes = totalNodes;
@@ -650,34 +637,22 @@ public:
                     // already sorted
                     break;
                 case ESort::Rack:
-                    ::Sort(*result.MutableNodes(), [reverse](const NKikimrViewer::TNodeInfo& a, const NKikimrViewer::TNodeInfo& b) {
-                        return reverse ^ (a.GetSystemState().GetRack() < b.GetSystemState().GetRack());
-                    });
+                    SortCollection(*result.MutableNodes(), [](const NKikimrViewer::TNodeInfo& node) { return node.GetSystemState().GetRack();}, ReverseSort);
                     break;
                 case ESort::Version:
-                    ::Sort(*result.MutableNodes(), [reverse](const NKikimrViewer::TNodeInfo& a, const NKikimrViewer::TNodeInfo& b) {
-                        return reverse ^ (a.GetSystemState().GetVersion() < b.GetSystemState().GetVersion());
-                    });
+                    SortCollection(*result.MutableNodes(), [](const NKikimrViewer::TNodeInfo& node) { return node.GetSystemState().GetVersion();}, ReverseSort);
                     break;
                 case ESort::Uptime:
-                    ::Sort(*result.MutableNodes(), [reverse](const NKikimrViewer::TNodeInfo& a, const NKikimrViewer::TNodeInfo& b) {
-                        return reverse ^ !(a.GetSystemState().GetStartTime() < b.GetSystemState().GetStartTime());
-                    });
+                    SortCollection(*result.MutableNodes(), [](const NKikimrViewer::TNodeInfo& node) { return node.GetSystemState().GetStartTime();}, ReverseSort);
                     break;
                 case ESort::Memory:
-                    ::Sort(*result.MutableNodes(), [reverse](const NKikimrViewer::TNodeInfo& a, const NKikimrViewer::TNodeInfo& b) {
-                        return reverse ^ (a.GetSystemState().GetMemoryUsed() < b.GetSystemState().GetMemoryUsed());
-                    });
+                    SortCollection(*result.MutableNodes(), [](const NKikimrViewer::TNodeInfo& node) { return node.GetSystemState().GetMemoryUsed();}, ReverseSort);
                     break;
                 case ESort::CPU:
-                    ::Sort(*result.MutableNodes(), [reverse](const NKikimrViewer::TNodeInfo& a, const NKikimrViewer::TNodeInfo& b) {
-                        return reverse ^ (GetCPU(a.GetSystemState()) < GetCPU(b.GetSystemState()));
-                    });
+                    SortCollection(*result.MutableNodes(), [](const NKikimrViewer::TNodeInfo& node) { return GetCPU(node.GetSystemState());}, ReverseSort);
                     break;
                 case ESort::LoadAverage:
-                    ::Sort(*result.MutableNodes(), [reverse](const NKikimrViewer::TNodeInfo& a, const NKikimrViewer::TNodeInfo& b) {
-                        return reverse ^ (GetLoadAverage(a.GetSystemState()) < GetLoadAverage(b.GetSystemState()));
-                    });
+                    SortCollection(*result.MutableNodes(), [](const NKikimrViewer::TNodeInfo& node) { return GetLoadAverage(node.GetSystemState());}, ReverseSort);
                     break;
             }
         }
diff --git a/ydb/core/viewer/json_storage.h b/ydb/core/viewer/json_storage.h
index 91c898c428e..3620e06a3f8 100644
--- a/ydb/core/viewer/json_storage.h
+++ b/ydb/core/viewer/json_storage.h
@@ -8,6 +8,7 @@
 #include <ydb/core/protos/node_whiteboard.pb.h>
 #include <ydb/core/viewer/protos/viewer.pb.h>
 #include "viewer.h"
+#include "viewer_helper.h"
 #include "json_pipe_req.h"
 #include "json_vdiskinfo.h"
 #include "json_pdiskinfo.h"
@@ -824,57 +825,36 @@ public:
                 }
             }
 
-            bool reverse = ReverseSort;
             switch (GroupSort) {
                 case EGroupSort::PoolName:
-                    ::Sort(GroupRows, [reverse](const TGroupRow& a, const TGroupRow& b) {
-                        return reverse ^ (a.PoolName < b.PoolName);
-                    });
+                    SortCollection(GroupRows, [](const TGroupRow& node) { return node.PoolName;}, ReverseSort);
                     break;
                 case EGroupSort::GroupId:
-                    ::Sort(GroupRows, [reverse](const TGroupRow& a, const TGroupRow& b) {
-                        return reverse ^ (a.GroupId < b.GroupId);
-                    });
+                    SortCollection(GroupRows, [](const TGroupRow& node) { return node.GroupId;}, ReverseSort);
                     break;
                 case EGroupSort::Kind:
-                    ::Sort(GroupRows, [reverse](const TGroupRow& a, const TGroupRow& b) {
-                        return reverse ^ (a.Kind < b.Kind);
-                    });
+                    SortCollection(GroupRows, [](const TGroupRow& node) { return node.Kind;}, ReverseSort);
                     break;
                 case EGroupSort::Erasure:
-                    ::Sort(GroupRows, [reverse](const TGroupRow& a, const TGroupRow& b) {
-                        return reverse ^ (a.Erasure < b.Erasure);
-                    });
+                    SortCollection(GroupRows, [](const TGroupRow& node) { return node.Erasure;}, ReverseSort);
                     break;
                 case EGroupSort::Degraded:
-                    ::Sort(GroupRows, [reverse](const TGroupRow& a, const TGroupRow& b) {
-                        return reverse ^ (a.Degraded < b.Degraded);
-                    });
+                    SortCollection(GroupRows, [](const TGroupRow& node) { return node.Degraded;}, ReverseSort);
                     break;
                 case EGroupSort::Usage:
-                    ::Sort(GroupRows, [reverse](const TGroupRow& a, const TGroupRow& b) {
-                        return reverse ^ (a.Usage < b.Usage);
-                    });
+                    SortCollection(GroupRows, [](const TGroupRow& node) { return node.Usage;}, ReverseSort);
                     break;
                 case EGroupSort::Used:
-                    ::Sort(GroupRows, [reverse](const TGroupRow& a, const TGroupRow& b) {
-                        return reverse ^ (a.Used < b.Used);
-                    });
+                    SortCollection(GroupRows, [](const TGroupRow& node) { return node.Used;}, ReverseSort);
                     break;
                 case EGroupSort::Limit:
-                    ::Sort(GroupRows, [reverse](const TGroupRow& a, const TGroupRow& b) {
-                        return reverse ^ (a.Limit < b.Limit);
-                    });
+                    SortCollection(GroupRows, [](const TGroupRow& node) { return node.Limit;}, ReverseSort);
                     break;
                 case EGroupSort::Read:
-                    ::Sort(GroupRows, [reverse](const TGroupRow& a, const TGroupRow& b) {
-                        return reverse ^ (a.Read < b.Read);
-                    });
+                    SortCollection(GroupRows, [](const TGroupRow& node) { return node.Read;}, ReverseSort);
                     break;
                 case EGroupSort::Write:
-                    ::Sort(GroupRows, [reverse](const TGroupRow& a, const TGroupRow& b) {
-                        return reverse ^ (a.Write < b.Write);
-                    });
+                    SortCollection(GroupRows, [](const TGroupRow& node) { return node.Write;}, ReverseSort);
                     break;
             }
 
diff --git a/ydb/core/viewer/viewer_helper.h b/ydb/core/viewer/viewer_helper.h
new file mode 100644
index 00000000000..1d92ac7570f
--- /dev/null
+++ b/ydb/core/viewer/viewer_helper.h
@@ -0,0 +1,16 @@
+#pragma once
+
+#include <util/generic/algorithm.h>
+
+namespace NKikimr::NViewer {
+    template<typename TCollection, typename TFunc>
+    void SortCollection(TCollection& collection, TFunc&& func, bool ReverseSort = false) {
+        using TItem = typename TCollection::value_type;
+        bool reverse = ReverseSort;
+        ::Sort(collection, [reverse, func](const TItem& a, const TItem& b) {
+            auto valueA = func(a);
+            auto valueB = func(b);
+            return valueA == valueB ? false : reverse ^ (valueA < valueB);
+        });
+    }
+}