rabbit_peer_discovery: Don't use temporary hidden to query local node

Author: dumbbell

deps/rabbit/src/rabbit_peer_discovery.erl

@@ -26,7 +26,7 @@
          normalize/1,
          append_node_prefix/1,
          node_prefix/0]).
--export([do_query_node_props/2]).
+-export([do_query_node_props/1]).
 
 -ifdef(TEST).
 -export([query_node_props/1,
@@ -444,7 +444,12 @@ query_node_props(Nodes) when Nodes =/= [] ->
                [Peer],
                #{domain => ?RMQLOG_DOMAIN_PEER_DISC}),
             try
-                peer:call(Pid, ?MODULE, do_query_node_props, [Nodes, ThisNode], 180000)
+                NodesAndProps1 = (
+                  do_query_node_props([ThisNode]) ++
+                  peer:call(
+                    Pid, ?MODULE, do_query_node_props, [Nodes], 180000)),
+                NodesAndProps2 = sort_nodes_and_props(NodesAndProps1),
+                NodesAndProps2
             after
                 peer:stop(Pid)
             end;
@@ -567,25 +572,23 @@ maybe_add_tls_arguments(VMArgs) ->
               end,
     VMArgs2.
 
-do_query_node_props(Nodes, ThisNode) when Nodes =/= [] ->
+do_query_node_props(Nodes) when Nodes =/= [] ->
     %% Make sure all log messages are forwarded from this temporary hidden
     %% node to the upstream node, regardless of their level.
     _ = logger:set_primary_config(level, debug),
 
     %% TODO: Replace with `rabbit_nodes:list_members/0' when the oldest
     %% supported version has it.
     MembersPerNode = erpc:multicall(Nodes, rabbit_nodes, all, []),
-    query_node_props1(Nodes, MembersPerNode, [], ThisNode).
+    query_node_props1(Nodes, MembersPerNode, []).
 
 query_node_props1(
-  [Node | Nodes], [{ok, Members} | MembersPerNode], NodesAndProps,
-  ThisNode) ->
+  [Node | Nodes], [{ok, Members} | MembersPerNode], NodesAndProps) ->
     NodeAndProps = {Node, Members},
     NodesAndProps1 = [NodeAndProps | NodesAndProps],
-    query_node_props1(Nodes, MembersPerNode, NodesAndProps1, ThisNode);
+    query_node_props1(Nodes, MembersPerNode, NodesAndProps1);
 query_node_props1(
-  [Node | Nodes], [{error, _} = Error | MembersPerNode], NodesAndProps,
-  ThisNode) ->
+  [Node | Nodes], [{error, _} = Error | MembersPerNode], NodesAndProps) ->
     %% We consider that an error means the remote node is unreachable or not
     %% ready. Therefore, we exclude it from the list of discovered nodes as we
     %% won't be able to join it anyway.
@@ -594,22 +597,22 @@ query_node_props1(
        "Peer discovery: node '~ts' excluded from the discovered nodes",
        [Node, Error, Node],
        #{domain => ?RMQLOG_DOMAIN_PEER_DISC}),
-    query_node_props1(Nodes, MembersPerNode, NodesAndProps, ThisNode);
-query_node_props1([], [], NodesAndProps, ThisNode) ->
+    query_node_props1(Nodes, MembersPerNode, NodesAndProps);
+query_node_props1([], [], NodesAndProps) ->
     NodesAndProps1 = lists:reverse(NodesAndProps),
-    query_node_props2(NodesAndProps1, [], ThisNode).
+    query_node_props2(NodesAndProps1, []).
 
-query_node_props2([{Node, Members} | Rest], NodesAndProps, ThisNode) ->
+query_node_props2([{Node, Members} | Rest], NodesAndProps) ->
     try
         erpc:call(
           Node, logger, debug,
           ["Peer discovery: temporary hidden node '~ts' queries properties "
            "from node '~ts'", [node(), Node]]),
         StartTime = get_node_start_time(Node, microsecond),
-        IsReady = is_node_db_ready(Node, ThisNode),
+        IsReady = is_node_db_ready(Node),
         NodeAndProps = {Node, Members, StartTime, IsReady},
         NodesAndProps1 = [NodeAndProps | NodesAndProps],
-        query_node_props2(Rest, NodesAndProps1, ThisNode)
+        query_node_props2(Rest, NodesAndProps1)
     catch
         _:Error:_ ->
             %% If one of the erpc calls we use to get the start time fails,
@@ -622,14 +625,13 @@ query_node_props2([{Node, Members} | Rest], NodesAndProps, ThisNode) ->
                "Peer discovery: node '~ts' excluded from the discovered nodes",
                [Node, Error, Node],
                #{domain => ?RMQLOG_DOMAIN_PEER_DISC}),
-            query_node_props2(Rest, NodesAndProps, ThisNode)
+            query_node_props2(Rest, NodesAndProps)
     end;
-query_node_props2([], NodesAndProps, _ThisNode) ->
+query_node_props2([], NodesAndProps) ->
     NodesAndProps1 = lists:reverse(NodesAndProps),
-    NodesAndProps2 = sort_nodes_and_props(NodesAndProps1),
     ?assertEqual([], nodes()),
-    ?assert(length(NodesAndProps2) =< length(nodes(hidden))),
-    NodesAndProps2.
+    ?assert(length(NodesAndProps1) =< length(nodes(hidden))),
+    NodesAndProps1.
 
 -spec get_node_start_time(Node, Unit) -> StartTime when
       Node :: node(),
@@ -662,21 +664,20 @@ get_node_start_time(Node, Unit) ->
                   [SystemStartTime, native, Unit]),
     StartTime.
 
--spec is_node_db_ready(Node, ThisNode) -> IsReady when
+-spec is_node_db_ready(Node) -> IsReady when
       Node :: node(),
-      ThisNode :: node(),
       IsReady :: boolean() | undefined.
 %% @doc Returns if the node's DB layer is ready or not.
 %%
 %% @private
 
-is_node_db_ready(ThisNode, ThisNode) ->
+is_node_db_ready(Node) when Node =:= node() ->
     %% The current node is running peer discovery, thus way before we mark the
     %% DB layer as ready. Consider it ready in this case, otherwise if the
     %% current node is selected, it will loop forever waiting for itself to be
     %% ready.
     true;
-is_node_db_ready(Node, _ThisNode) ->
+is_node_db_ready(Node) ->
     try
         erpc:call(Node, rabbit_db, is_init_finished, [])
     catch