Remove select_node logic to find node with least queue load, now just do random

Author: SimonUnge

deps/rabbit/src/rabbit_quorum_queue_periodic_membership_reconciliation.erl

@@ -163,10 +163,7 @@ maybe_add_member(Q, Running, MemberNodes, TargetSize) ->
         true ->
             %% In the future, sort the list of new nodes based on load,
             %% availability zones etc
-            QueueCount = rabbit_amqqueue:count(),
-            QueueCountStartRandom = application:get_env(rabbit, queue_count_start_random_selection,
-                                                        ?QUEUE_COUNT_START_RANDOM_SELECTION),
-            Node = select_node(New, QueueCount, QueueCountStartRandom),
+            Node = select_node(New),
             QName = amqqueue:get_name(Q),
             case rabbit_quorum_queue:add_member(Q, Node) of
                 ok ->
@@ -241,28 +238,7 @@ update_result(Result, noop) ->
 update_result(Result, Result) ->
     Result.
 
-select_node([Node],  _QueueCount, _QueueCountStartRandom) ->
+select_node([Node]) ->
     Node;
-select_node(Nodes,  QueueCount, QueueCountStartRandom)
-  when QueueCount >= QueueCountStartRandom ->
-    lists:nth(rand:uniform(length(Nodes)), Nodes);
-select_node(Nodes, _QueueCount, _QueueCountStartRandom) ->
-    Counters0 = maps:from_list([{N, 0} || N <- Nodes]),
-    Queues = rabbit_amqqueue:list_by_type(rabbit_quorum_queue),
-    Counters = lists:foldl(fun(Q, Acc) ->
-                                   #{nodes := MNodes} = amqqueue:get_type_state(Q),
-                                   lists:foldl(fun(N, A)
-                                                     when is_map_key(N, A) ->
-                                                       maps:update_with(N, fun(C) -> C+1 end, A);
-                                                  (_, A) ->
-                                                       A
-                                               end, Acc, MNodes)
-                           end, Counters0, Queues),
-    L0 = maps:to_list(Counters),
-    %% Maybe cache this result for a few seconds, to
-    %% not run this check for each queue?
-    L1 = lists:sort(fun({_N0, C0}, {_N1, C1}) ->
-                            C0 =< C1
-                    end, L0),
-    {Node, _} = hd(L1),
-    Node.
+select_node(Nodes) ->
+    lists:nth(rand:uniform(length(Nodes)), Nodes).