Squash a warning => compiles from scratch

Author: michaelklishin

src/rabbit_mirror_queue_misc.erl

@@ -19,7 +19,7 @@
 
 -export([remove_from_queue/3, on_node_up/0, add_mirrors/3,
          report_deaths/4, store_updated_slaves/1,
-         initial_queue_node/2, suggested_queue_nodes/1,
+         initial_queue_node/2, suggested_queue_nodes/1, actual_queue_nodes/1,
          is_mirrored/1, update_mirrors/2, update_mirrors/1, validate_policy/1,
          maybe_auto_sync/1, maybe_drop_master_after_sync/1,
          sync_batch_size/1, log_info/3, log_warning/3]).

src/rabbit_queue_master_location_misc.erl

@@ -95,7 +95,7 @@ get_location_mod_by_config(#amqqueue{}) ->
 all_nodes(Queue = #amqqueue{}) ->
     handle_suggested_queue_nodes(rabbit_mirror_queue_misc:suggested_queue_nodes(Queue)).
 
-handle_suggested_queue_nodes({MNode, []}) ->
+handle_suggested_queue_nodes({_MNode, []}) ->
     rabbit_nodes:all_running();
 handle_suggested_queue_nodes({MNode, SNodes}) ->
     [MNode | SNodes].

test/queue_master_location_SUITE.erl

@@ -165,18 +165,27 @@ declare_policy_exactly(Config) ->
     unset_location_config(Config),
     % Note:
     % Node0 has 15 queues, Node1 has 8 and Node2 has 1
-    Node1 = rabbit_ct_broker_helpers:get_node_config(Config, 1, nodename),
     Policy = [{<<"queue-master-locator">>, <<"min-masters">>},
               {<<"ha-mode">>, <<"exactly">>},
               {<<"ha-params">>, 2}],
     ok = rabbit_ct_broker_helpers:set_policy(Config, 0, ?POLICY,
                                              <<".*">>, <<"queues">>, Policy),
-    QueueName = rabbit_misc:r(<<"/">>, queue, Q = <<"qm.test">>),
-    declare(Config, QueueName, false, false, _Args=[], none),
-    % Note: even though Node2 has the fewest masters, the "exactly" policy
-    % chooses Node0 and Node1 as eligible, and then "min-masters"
-    % chooses Node1
-    verify_min_master(Config, Q, Node1).
+    QueueRec = rabbit_misc:r(<<"/">>, queue, Q = <<"qm.test">>),
+    declare(Config, QueueRec, false, false, _Args=[], none),
+
+    Node0 = rabbit_ct_broker_helpers:get_node_config(Config, 0, nodename),
+    rabbit_ct_broker_helpers:control_action(sync_queue, Node0,
+                                            [binary_to_list(Q)], [{"-p", "/"}]),
+    wait_for_sync(Config, Node0, QueueRec, 1),
+
+    {ok, Queue} = rabbit_ct_broker_helpers:rpc(Config, Node0,
+                                               rabbit_amqqueue, lookup, [QueueRec]),
+    ct:pal("Queue after sync ~p~n", [Queue]),
+    {MNode, SNodes, SSNodes} = rabbit_ct_broker_helpers:rpc(Config, Node0,
+                                                            rabbit_mirror_queue_misc,
+                                                            actual_queue_nodes, [Queue]),
+    ct:pal("MNode ~p SNodes ~p SSNodes ~p~n", [MNode, SNodes, SSNodes]),
+    verify_min_master(Config, Q, Node0).
 
 declare_config(Config) ->
     setup_test_environment(Config),
@@ -286,44 +295,66 @@ min_master_node(Config) ->
 
 set_location_config(Config, Strategy) ->
     Nodes = rabbit_ct_broker_helpers:get_node_configs(Config, nodename),
-    [ok = rpc:call(Node, application, set_env,
-                   [rabbit, queue_master_locator, Strategy]) || Node <- Nodes],
+    [ok = rabbit_ct_broker_helpers:rpc(Config, Node,
+                                       application, set_env,
+                                       [rabbit, queue_master_locator, Strategy]) || Node <- Nodes],
     ok.
 
 unset_location_config(Config) ->
     Nodes = rabbit_ct_broker_helpers:get_node_configs(Config, nodename),
-    [ok = rpc:call(Node, application, unset_env,
-                   [rabbit, queue_master_locator]) || Node <- Nodes],
+    [ok = rabbit_ct_broker_helpers:rpc(Config, Node,
+                                       application, unset_env,
+                                       [rabbit, queue_master_locator]) || Node <- Nodes],
     ok.
 
-declare(Config, QueueName, Durable, AutoDelete, Args, Owner) ->
-    Node = rabbit_ct_broker_helpers:get_node_config(Config, 0, nodename),
-    {new, Queue} = rpc:call(Node, rabbit_amqqueue, declare,
-                            [QueueName, Durable, AutoDelete, Args, Owner]),
+declare(Config, QueueName, Durable, AutoDelete, Args0, Owner) ->
+    Args1 = [QueueName, Durable, AutoDelete, Args0, Owner],
+    {new, Queue} = rabbit_ct_broker_helpers:rpc(Config, 0, rabbit_amqqueue, declare, Args1),
     Queue.
 
 verify_min_master(Config, Q, MinMasterNode) ->
-    Node = rabbit_ct_broker_helpers:get_node_config(Config, 0, nodename),
-    Rpc = rpc:call(Node, rabbit_queue_master_location_misc,
-                   lookup_master, [Q, ?DEFAULT_VHOST_PATH]),
+    Rpc = rabbit_ct_broker_helpers:rpc(Config, 0,
+                                       rabbit_queue_master_location_misc,
+                                       lookup_master, [Q, ?DEFAULT_VHOST_PATH]),
     ?assertEqual({ok, MinMasterNode}, Rpc).
 
 verify_min_master(Config, Q) ->
     MinMaster = min_master_node(Config),
     verify_min_master(Config, Q, MinMaster).
 
 verify_random(Config, Q) ->
-    [Node | _] = Nodes = rabbit_ct_broker_helpers:get_node_configs(Config,
-      nodename),
-    {ok, Master} = rpc:call(Node, rabbit_queue_master_location_misc,
-                            lookup_master, [Q, ?DEFAULT_VHOST_PATH]),
+    [Node | _] = Nodes = rabbit_ct_broker_helpers:get_node_configs(Config, nodename),
+    {ok, Master} = rabbit_ct_broker_helpers:rpc(Config, Node,
+                                                rabbit_queue_master_location_misc,
+                                                lookup_master, [Q, ?DEFAULT_VHOST_PATH]),
     ?assert(lists:member(Master, Nodes)).
 
 verify_client_local(Config, Q) ->
     Node = rabbit_ct_broker_helpers:get_node_config(Config, 0, nodename),
-    ?assertEqual({ok, Node}, rpc:call(Node, rabbit_queue_master_location_misc,
-                                      lookup_master, [Q, ?DEFAULT_VHOST_PATH])).
+    Rpc = rabbit_ct_broker_helpers:rpc(Config, Node,
+                                       rabbit_queue_master_location_misc,
+                                       lookup_master, [Q, ?DEFAULT_VHOST_PATH]),
+    ?assertEqual({ok, Node}, Rpc).
 
 set_location_policy(Config, Name, Strategy) ->
     ok = rabbit_ct_broker_helpers:set_policy(Config, 0,
       Name, <<".*">>, <<"queues">>, [{<<"queue-master-locator">>, Strategy}]).
+
+wait_for_sync(Config, Nodename, Q, ExpectedSSPidLen) ->
+    wait_for_sync(Config, Nodename, Q, ExpectedSSPidLen, 600).
+
+wait_for_sync(_, _, _, _, 0) ->
+    throw(sync_timeout);
+wait_for_sync(Config, Nodename, Q, ExpectedSSPidLen, N) ->
+    case synced(Config, Nodename, Q, ExpectedSSPidLen) of
+        true  -> ok;
+        false -> timer:sleep(100),
+                 wait_for_sync(Config, Nodename, Q, ExpectedSSPidLen, N-1)
+    end.
+
+synced(Config, Nodename, Q, ExpectedSSPidLen) ->
+    Info = rabbit_ct_broker_helpers:rpc(Config, Nodename,
+      rabbit_amqqueue, info_all, [<<"/">>, [name, synchronised_slave_pids]]),
+    ct:pal("synced Info: ~p~n", [Info]),
+    [SSPids] = [Pids || [{name, Q1}, {synchronised_slave_pids, Pids}] <- Info, Q =:= Q1],
+    length(SSPids) =:= ExpectedSSPidLen.