refactor(fqdn): refactor func maintain_drops to process rpc_address and rpc_hostport

Author: Samunroyu

src/meta/meta_data.h

@@ -549,80 +549,50 @@ inline int count_partitions(const app_mapper &apps)
 
 void when_update_replicas(config_type::type t, const std::function<void(bool)> &func);
 
-#define MAINTAIN_DROP_NODE_IMPL(config, node_value, drops_field, type) \
-    do { \
-        auto action = [&](bool is_adding) { \
-            auto it = std::find(config.drops_field.begin(), config.drops_field.end(), node_value); \
-            if (is_adding) { \
-                if (it != config.drops_field.end()) { \
-                    config.drops_field.erase(it); \
-                } \
-            } else { \
-                CHECK(it == config.drops_field.end(), \
-                      "the node({}) cannot be in drops set before this update", node_value); \
-                config.drops_field.push_back(node_value); \
-                if (config.drops_field.size() > 3) { \
-                    config.drops_field.erase(config.drops_field.begin()); \
-                } \
-            } \
-        }; \
-        when_update_replicas(type, action); \
-    } while (0)
-
-#define MAINTAIN_DROP_NODE(config, node, drops_field, type) \
-    do { \
-        if (config.node) { \
-            MAINTAIN_DROP_NODE_IMPL(config, config.node, drops_field, type); \
-        } \
+#define MAINTAIN_DROP_NODE(obj, field, type)                                \
+    do {                                                                    \
+        auto obj_copy = obj;                                                \
+        if (obj.primary) {                                                  \
+            maintain_drops(obj_copy.field, obj.primary, type);              \
+        }                                                                   \
+        if (obj.__isset.hp_primary && obj.hp_primary) {                     \
+            maintain_drops(obj_copy.hp_##field, obj.hp_primary, type);      \
+        }                                                                   \
     } while (0)
 
 
-#define MAINTAIN_DROP_NODES(config, nodes, drops_field, type) \
-    do { \
-        for (const auto &secondary : config.nodes) { \
-            MAINTAIN_DROP_NODE_IMPL(config, secondary, drops_field, type); \
-        } \
+#define MAINTAIN_DROP_NODES(obj, field, type)                               \
+    do {                                                                    \
+        auto obj_copy = obj;                                                \
+        for (const auto &secondary : obj.secondaries) {                     \
+            maintain_drops(obj_copy.field, secondary, type);                \
+        }                                                                   \
+        if (obj.__isset.hp_secondaries) {                                   \
+            for (const auto &secondary : obj.hp_secondaries) {              \
+                maintain_drops(obj_copy.hp_##field, secondary, type);       \
+            }                                                               \
+        }                                                                   \
     } while (0)
-    
-inline void maintain_drops(/*inout*/ configuration_update_request &request, partition_configuration &pc, bool is_group_check)
+
+template <typename T>
+void maintain_drops(/*inout*/ std::vector<T> &drops, const T &node, config_type::type t)
 {
-    auto t = request.type;
-    auto make_proc = [](auto &drops, const auto &node) {
-        return [&drops, &node](bool is_adding) {
-            auto it = std::find(drops.begin(), drops.end(), node);
-            if (is_adding) {
-                if (it != drops.end()) {
-                    drops.erase(it);
-                }
-            } else {
-                CHECK(it == drops.end(),
-                      "the node({}) cannot be in drops set before this update",
-                      node);
-                drops.push_back(node);
-                if (drops.size() > 3) {
-                    drops.erase(drops.begin());
-                }
+    auto action = [&drops, &node](bool is_adding) {
+        auto it = std::find(drops.begin(), drops.end(), node);
+        if (is_adding) {
+            if (it != drops.end()) {
+                drops.erase(it);
+            }
+        } else {
+            CHECK(
+                it == drops.end(), "the node({}) cannot be in drops set before this update", node);
+            drops.push_back(node);
+            if (drops.size() > 3) {
+                drops.erase(drops.begin());
             }
-        };
-    };
-
-    if (is_group_check) {
-        for (const auto &secondary : pc.hp_secondaries) {
-            when_update_replicas(t, make_proc(request.config.hp_last_drops, secondary));
-        }
-
-        for (const auto &secondary : pc.secondaries) {
-            when_update_replicas(t, make_proc(request.config.last_drops, secondary));
-        }
-    } else {
-        if (pc.hp_primary) {
-            when_update_replicas(t, make_proc(request.config.hp_last_drops, pc.hp_primary));
-        }
-
-        if (pc.primary) {
-            when_update_replicas(t, make_proc(request.config.last_drops, pc.primary));
         }
-    }
+    };
+    when_update_replicas(t, action);
 }
 
 // Try to construct a replica-group by current replica-infos of a gpid

src/meta/server_state.cpp

@@ -2095,10 +2095,9 @@ void server_state::drop_partition(std::shared_ptr<app_state> &app, int pidx)
     request.type = config_type::CT_DROP_PARTITION;
     SET_OBJ_IP_AND_HOST_PORT(request, node, pc, primary);
 
-    MAINTAIN_DROP_NODES(request.config, hp_secondaries, hp_last_drops, request.type);
-    MAINTAIN_DROP_NODES(request.config, secondaries, last_drops, request.type);
-    MAINTAIN_DROP_NODE(request.config, hp_primary, hp_last_drops, request.type);
-    MAINTAIN_DROP_NODE(request.config, primary, last_drops, request.type);
+    request.config = pc;
+    MAINTAIN_DROP_NODES(request.config, last_drops, request.type);
+    MAINTAIN_DROP_NODE(request.config, last_drops, request.type);
 
     RESET_IP_AND_HOST_PORT(request.config, primary);
     CLEAR_IP_AND_HOST_PORT(request.config, secondaries);
@@ -2160,9 +2159,7 @@ void server_state::downgrade_primary_to_inactive(std::shared_ptr<app_state> &app
     SET_OBJ_IP_AND_HOST_PORT(request, node, pc, primary);
     request.config.ballot++;
     RESET_IP_AND_HOST_PORT(request.config, primary);
-    MAINTAIN_DROP_NODE(request.config, hp_primary, hp_last_drops, request.type);
-    MAINTAIN_DROP_NODE(request.config, primary, last_drops, request.type);
-    // maintain_drops(request, pc, false);
+    MAINTAIN_DROP_NODE(request.config, last_drops, request.type);
 
     cc.stage = config_status::pending_remote_sync;
     cc.pending_sync_request = req;
@@ -2299,8 +2296,7 @@ void server_state::on_update_configuration(
         msg->release_ref();
         return;
     } else {
-        MAINTAIN_DROP_NODES(cfg_request->config, hp_node, hp_last_drops, cfg_request->type);
-        MAINTAIN_DROP_NODES(cfg_request->config, node, last_drops, cfg_request->type);
+        MAINTAIN_DROP_NODES(cfg_request->config, last_drops, cfg_request->type);
     }
 
     if (response.err != ERR_IO_PENDING) {