refactor: extract and encapsulate the aggregation process of single-table statistics for reuse (#2318)

Both shell and HTTP interfaces now support displaying a table's statistics in
multiple sections. Since the logic for this was largely duplicated, a lot of
redundant code existed. This PR extracts the common logic and introduces
an `add_app_info` interface to encapsulate it, allowing a table’s statistics to
be added to a `multi_printer` in multiple sections for later output.

Additionally, a `resolve` interface is introduced for `host_port` itself, replacing
`replication_ddl_client::node_name`.

Author: empiredan

src/client/replication_ddl_client.cpp

@@ -35,7 +35,6 @@
 #include <fstream>
 #include <iomanip>
 #include <iostream>
-#include <type_traits>
 
 #include "backup_types.h"
 #include "common//duplication_common.h"
@@ -531,15 +530,6 @@ struct list_nodes_helper
     }
 };
 
-std::string replication_ddl_client::node_name(const host_port &hp, bool resolve_ip)
-{
-    if (!resolve_ip) {
-        return hp.to_string();
-    }
-
-    return dns_resolver::instance().resolve_address(hp).to_string();
-}
-
 dsn::error_code replication_ddl_client::cluster_name(int64_t timeout_ms, std::string &cluster_name)
 {
     auto req = std::make_shared<configuration_cluster_info_request>();
@@ -614,123 +604,35 @@ replication_ddl_client::cluster_info(const std::string &file_name, bool resolve_
 dsn::error_code replication_ddl_client::list_app(const std::string &app_name,
                                                  bool detailed,
                                                  bool json,
-                                                 const std::string &file_name,
+                                                 const std::string &output_file,
                                                  bool resolve_ip)
 {
-    dsn::utils::multi_table_printer mtp;
-    dsn::utils::table_printer tp_params("parameters");
-    if (!(app_name.empty() && file_name.empty())) {
-        if (!app_name.empty())
-            tp_params.add_row_name_and_data("app_name", app_name);
-        if (!file_name.empty())
-            tp_params.add_row_name_and_data("out_file", file_name);
-    }
-    tp_params.add_row_name_and_data("detailed", detailed);
-    mtp.add(std::move(tp_params));
-    int32_t app_id = 0;
-    int32_t partition_count = 0;
-    int32_t max_replica_count = 0;
+    utils::table_printer params_printer("parameters");
+    if (!app_name.empty()) {
+        params_printer.add_row_name_and_data("app_name", app_name);
+    }
+    if (!output_file.empty()) {
+        params_printer.add_row_name_and_data("out_file", output_file);
+    }
+
+    params_printer.add_row_name_and_data("detailed", detailed);
+
+    utils::multi_table_printer multi_printer;
+    multi_printer.add(std::move(params_printer));
+
+    int32_t app_id{0};
+    int32_t partition_count{0};
     std::vector<partition_configuration> pcs;
-    dsn::error_code err = list_app(app_name, app_id, partition_count, pcs);
+    const auto err = list_app(app_name, app_id, partition_count, pcs);
     if (err != dsn::ERR_OK) {
         return err;
     }
-    if (!pcs.empty()) {
-        max_replica_count = pcs[0].max_replica_count;
-    }
 
-    // print query_cfg_response
-    std::streambuf *buf;
-    std::ofstream of;
+    add_app_info(app_name, app_id, partition_count, pcs, detailed, resolve_ip, "", multi_printer);
 
-    if (!file_name.empty()) {
-        of.open(file_name);
-        buf = of.rdbuf();
-    } else {
-        buf = std::cout.rdbuf();
-    }
-    std::ostream out(buf);
+    utils::output(output_file, json, multi_printer);
 
-    dsn::utils::table_printer tp_general("general");
-    tp_general.add_row_name_and_data("app_name", app_name);
-    tp_general.add_row_name_and_data("app_id", app_id);
-    tp_general.add_row_name_and_data("partition_count", partition_count);
-    tp_general.add_row_name_and_data("max_replica_count", max_replica_count);
-    mtp.add(std::move(tp_general));
-
-    if (detailed) {
-        dsn::utils::table_printer tp_details("replicas");
-        tp_details.add_title("pidx");
-        tp_details.add_column("ballot");
-        tp_details.add_column("replica_count");
-        tp_details.add_column("primary");
-        tp_details.add_column("secondaries");
-        std::map<host_port, std::pair<int, int>> node_stat;
-
-        int total_prim_count = 0;
-        int total_sec_count = 0;
-        int fully_healthy = 0;
-        int write_unhealthy = 0;
-        int read_unhealthy = 0;
-        for (const auto &pc : pcs) {
-            int replica_count = 0;
-            if (pc.hp_primary) {
-                replica_count++;
-                node_stat[pc.hp_primary].first++;
-                total_prim_count++;
-            }
-            replica_count += pc.hp_secondaries.size();
-            total_sec_count += pc.hp_secondaries.size();
-            if (pc.hp_primary) {
-                if (replica_count >= pc.max_replica_count) {
-                    fully_healthy++;
-                } else if (replica_count < 2) {
-                    write_unhealthy++;
-                }
-            } else {
-                write_unhealthy++;
-                read_unhealthy++;
-            }
-            for (const auto &secondary : pc.hp_secondaries) {
-                node_stat[secondary].second++;
-            }
-            tp_details.add_row(pc.pid.get_partition_index());
-            tp_details.append_data(pc.ballot);
-            tp_details.append_data(fmt::format("{}/{}", replica_count, pc.max_replica_count));
-            tp_details.append_data(pc.hp_primary ? pc.hp_primary.to_string() : "-");
-            tp_details.append_data(fmt::format("[{}]", fmt::join(pc.hp_secondaries, ",")));
-        }
-        mtp.add(std::move(tp_details));
-
-        // 'node' section.
-        dsn::utils::table_printer tp_nodes("nodes");
-        tp_nodes.add_title("node");
-        tp_nodes.add_column("primary");
-        tp_nodes.add_column("secondary");
-        tp_nodes.add_column("total");
-        for (const auto &[hp, pri_and_sec_rep_cnts] : node_stat) {
-            tp_nodes.add_row(node_name(hp, resolve_ip));
-            tp_nodes.append_data(pri_and_sec_rep_cnts.first);
-            tp_nodes.append_data(pri_and_sec_rep_cnts.second);
-            tp_nodes.append_data(pri_and_sec_rep_cnts.first + pri_and_sec_rep_cnts.second);
-        }
-        tp_nodes.add_row("");
-        tp_nodes.append_data(total_prim_count);
-        tp_nodes.append_data(total_sec_count);
-        tp_nodes.append_data(total_prim_count + total_sec_count);
-        mtp.add(std::move(tp_nodes));
-
-        // healthy partition count section.
-        dsn::utils::table_printer tp_hpc("healthy");
-        tp_hpc.add_row_name_and_data("fully_healthy_partition_count", fully_healthy);
-        tp_hpc.add_row_name_and_data("unhealthy_partition_count", partition_count - fully_healthy);
-        tp_hpc.add_row_name_and_data("write_unhealthy_partition_count", write_unhealthy);
-        tp_hpc.add_row_name_and_data("read_unhealthy_partition_count", read_unhealthy);
-        mtp.add(std::move(tp_hpc));
-    }
-    mtp.output(out, json ? tp_output_format::kJsonPretty : tp_output_format::kTabular);
     return dsn::ERR_OK;
-#undef RESOLVE
 }
 
 dsn::error_code replication_ddl_client::list_app(const std::string &app_name,

src/client/replication_ddl_client.h

@@ -156,8 +156,8 @@ class replication_ddl_client
     dsn::error_code list_app(const std::string &app_name,
                              bool detailed,
                              bool json,
-                             const std::string &file_name,
-                             bool resolve_ip = false);
+                             const std::string &output_file,
+                             bool resolve_ip);
 
     dsn::error_code list_app(const std::string &app_name,
                              int32_t &app_id,
@@ -317,10 +317,12 @@ class replication_ddl_client
     void set_max_wait_app_ready_secs(uint32_t max_wait_secs) { _max_wait_secs = max_wait_secs; }
     void set_meta_servers_leader();
 
-    static error_s validate_app_name(const std::string &app_name, bool allow_empty_name = false);
+    static error_s validate_app_name(const std::string &app_name, bool allow_empty_name);
 
-    // Resolve the host:port 'hp' to ip:port if 'resolve_ip' is true.
-    static std::string node_name(const host_port &hp, bool resolve_ip);
+    static error_s validate_app_name(const std::string &app_name)
+    {
+        return validate_app_name(app_name, false);
+    }
 
 private:
     void end_meta_request(const rpc_response_task_ptr &callback,
@@ -528,7 +530,6 @@ class replication_ddl_client
         }
     }
 
-private:
     dsn::host_port _meta_server;
     dsn::task_tracker _tracker;
     uint32_t _max_wait_secs = 3600; // Wait at most 1 hour by default.

src/common/replication_common.cpp

@@ -26,21 +26,26 @@
 
 #include "common/replication_common.h"
 
-#include <string.h>
+#include <cstring>
 #include <fstream>
+#include <map>
 #include <memory>
+#include <type_traits>
+#include <utility>
 
 #include "common/gpid.h"
 #include "common/replication_other_types.h"
 #include "dsn.layer2_types.h"
 #include "fmt/core.h"
+#include "fmt/format.h"
 #include "rpc/dns_resolver.h" // IWYU pragma: keep
 #include "rpc/rpc_address.h"
 #include "runtime/service_app.h"
 #include "utils/config_api.h"
 #include "utils/filesystem.h"
 #include "utils/flags.h"
 #include "utils/fmt_logging.h"
+#include "utils/output_utils.h"
 #include "utils/strings.h"
 #include "utils/utils.h"
 
@@ -112,8 +117,8 @@ DSN_DEFINE_string(meta_server,
                   "",
                   "Comma-separated list of MetaServers in the Pegasus cluster");
 
-namespace dsn {
-namespace replication {
+namespace dsn::replication {
+
 const std::string replication_options::kRepsDir = "reps";
 const std::string replication_options::kReplicaAppType = "replica";
 
@@ -333,5 +338,113 @@ replication_options::check_if_in_black_list(const std::vector<std::string> &blac
     return false;
 }
 
-} // namespace replication
-} // namespace dsn
+void add_app_info(const std::string &app_name,
+                  int32_t app_id,
+                  int32_t partition_count,
+                  const std::vector<partition_configuration> &pcs,
+                  bool detailed,
+                  bool resolve_ip,
+                  std::string_view total_row_name,
+                  utils::multi_table_printer &multi_printer)
+{
+    // "general" section.
+    utils::table_printer general_printer("general");
+    general_printer.add_row_name_and_data("app_name", app_name);
+    general_printer.add_row_name_and_data("app_id", app_id);
+    general_printer.add_row_name_and_data("partition_count", partition_count);
+    general_printer.add_row_name_and_data("max_replica_count",
+                                          pcs.empty() ? 0 : pcs[0].max_replica_count);
+
+    multi_printer.add(std::move(general_printer));
+
+    if (!detailed) {
+        return;
+    }
+
+    // "replicas" section.
+    utils::table_printer partitions_printer("replicas");
+    partitions_printer.add_title("pidx");
+    partitions_printer.add_column("ballot");
+    partitions_printer.add_column("replica_count");
+    partitions_printer.add_column("primary");
+    partitions_printer.add_column("secondaries");
+
+    struct node_stat
+    {
+        int primary_count{0};
+        int secondary_count{0};
+    };
+    std::map<host_port, node_stat> node_stats;
+
+    int total_prim_count = 0;
+    int total_sec_count = 0;
+    int fully_healthy = 0;
+    int write_unhealthy = 0;
+    int read_unhealthy = 0;
+    for (const auto &pc : pcs) {
+        int replica_count = 0;
+        if (pc.hp_primary) {
+            ++replica_count;
+            ++node_stats[pc.hp_primary].primary_count;
+            ++total_prim_count;
+        }
+        replica_count += static_cast<int>(pc.hp_secondaries.size());
+        total_sec_count += static_cast<int>(pc.hp_secondaries.size());
+
+        if (pc.hp_primary) {
+            if (replica_count >= pc.max_replica_count) {
+                ++fully_healthy;
+            } else if (replica_count < 2) {
+                ++write_unhealthy;
+            }
+        } else {
+            ++write_unhealthy;
+            ++read_unhealthy;
+        }
+
+        partitions_printer.add_row(pc.pid.get_partition_index());
+        partitions_printer.append_data(pc.ballot);
+        partitions_printer.append_data(fmt::format("{}/{}", replica_count, pc.max_replica_count));
+        partitions_printer.append_data(pc.hp_primary ? pc.hp_primary.to_string() : "-");
+        partitions_printer.append_data(fmt::format("[{}]", fmt::join(pc.hp_secondaries, ",")));
+
+        for (const auto &secondary : pc.hp_secondaries) {
+            ++node_stats[secondary].secondary_count;
+        }
+    }
+
+    multi_printer.add(std::move(partitions_printer));
+
+    // "nodes" section.
+    utils::table_printer nodes_printer("nodes");
+    nodes_printer.add_title("node");
+    nodes_printer.add_column("primary");
+    nodes_printer.add_column("secondary");
+    nodes_printer.add_column("total");
+
+    for (const auto &[addr, stat] : node_stats) {
+        nodes_printer.add_row(addr.resolve(resolve_ip));
+        nodes_printer.append_data(stat.primary_count);
+        nodes_printer.append_data(stat.secondary_count);
+        nodes_printer.append_data(stat.primary_count + stat.secondary_count);
+    }
+
+    nodes_printer.add_row(total_row_name);
+    nodes_printer.append_data(total_prim_count);
+    nodes_printer.append_data(total_sec_count);
+    nodes_printer.append_data(total_prim_count + total_sec_count);
+
+    multi_printer.add(std::move(nodes_printer));
+
+    // "healthy" partition count section.
+    utils::table_printer healthy_printer("healthy");
+    healthy_printer.add_row_name_and_data("fully_healthy_partition_count", fully_healthy);
+    healthy_printer.add_row_name_and_data("unhealthy_partition_count",
+                                          partition_count - fully_healthy);
+    healthy_printer.add_row_name_and_data("write_unhealthy_partition_count", write_unhealthy);
+    healthy_printer.add_row_name_and_data("read_unhealthy_partition_count", read_unhealthy);
+
+    multi_printer.add(std::move(healthy_printer));
+}
+
+} // namespace dsn::replication