summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/rabbit_amqqueue.erl2
-rw-r--r--src/rabbit_mirror_queue_master.erl6
-rw-r--r--src/rabbit_mirror_queue_slave.erl2
-rw-r--r--test/clustering_management_SUITE.erl36
-rw-r--r--test/crashing_queues_SUITE.erl10
-rw-r--r--test/dynamic_ha_SUITE.erl108
-rw-r--r--test/priority_queue_SUITE.erl14
-rw-r--r--test/sync_detection_SUITE.erl48
8 files changed, 113 insertions, 113 deletions
diff --git a/src/rabbit_amqqueue.erl b/src/rabbit_amqqueue.erl
index 1e6184fd8c..25e5a56d42 100644
--- a/src/rabbit_amqqueue.erl
+++ b/src/rabbit_amqqueue.erl
@@ -1522,7 +1522,7 @@ wait_for_promoted_or_stopped(Q0) ->
case lists:any(fun(Pid) ->
rabbit_mnesia:is_process_alive(Pid)
end, SPids) of
- %% There is a live slave. May be promoted
+ %% There is a live mirror. May be promoted
true ->
timer:sleep(100),
wait_for_promoted_or_stopped(Q);
diff --git a/src/rabbit_mirror_queue_master.erl b/src/rabbit_mirror_queue_master.erl
index e1baca462b..2e519b1e92 100644
--- a/src/rabbit_mirror_queue_master.erl
+++ b/src/rabbit_mirror_queue_master.erl
@@ -451,7 +451,7 @@ is_duplicate(Message = #basic_message { id = MsgId },
backing_queue_state = BQS,
confirmed = Confirmed }) ->
%% Here, we need to deal with the possibility that we're about to
- %% receive a message that we've already seen when we were a slave
+ %% receive a message that we've already seen when we were a mirror
%% (we received it via gm). Thus if we do receive such message now
%% via the channel, there may be a confirm waiting to issue for
%% it.
@@ -478,12 +478,12 @@ is_duplicate(Message = #basic_message { id = MsgId },
%% confirmed some time after that (maybe even after
%% promotion), but before we received the publish from the
%% channel, so couldn't previously know what the
- %% msg_seq_no was (and thus confirm as a slave). So we
+ %% msg_seq_no was (and thus confirm as a mirror). So we
%% need to confirm now. As above, amqqueue_process will
%% have the entry for the msg_id_to_channel mapping added
%% immediately after calling is_duplicate/2.
orelse Disposition =:= discarded ->
- %% Message was discarded while we were a slave. Confirm now.
+ %% Message was discarded while we were a mirror. Confirm now.
%% As above, amqqueue_process will have the entry for the
%% msg_id_to_channel mapping.
{{true, drop}, State #state { seen_status = maps:remove(MsgId, SS),
diff --git a/src/rabbit_mirror_queue_slave.erl b/src/rabbit_mirror_queue_slave.erl
index 8a8151730f..7c592dab9c 100644
--- a/src/rabbit_mirror_queue_slave.erl
+++ b/src/rabbit_mirror_queue_slave.erl
@@ -797,7 +797,7 @@ confirm_sender_death(Pid) ->
Fun =
fun (?MODULE, State = #state { known_senders = KS,
gm = GM }) ->
- %% We're running still as a slave
+ %% We're running still as a mirror
%%
%% See comment in local_sender_death/2; we might have
%% received a sender_death in the meanwhile so check
diff --git a/test/clustering_management_SUITE.erl b/test/clustering_management_SUITE.erl
index 1825f89c85..34ad0b8cfd 100644
--- a/test/clustering_management_SUITE.erl
+++ b/test/clustering_management_SUITE.erl
@@ -66,7 +66,7 @@ groups() ->
]},
{clustered_4_nodes, [], [
{cluster_size_4, [], [
- forget_promotes_offline_slave
+ forget_promotes_offline_follower
]}
]}
].
@@ -388,13 +388,13 @@ forget_offline_removes_things(Config) ->
passive = true})),
ok.
-forget_promotes_offline_slave(Config) ->
+forget_promotes_offline_follower(Config) ->
[A, B, C, D] = rabbit_ct_broker_helpers:get_node_configs(Config, nodename),
ACh = rabbit_ct_client_helpers:open_channel(Config, A),
QName = <<"mirrored-queue">>,
declare(ACh, QName),
set_ha_policy(Config, QName, A, [B, C]),
- set_ha_policy(Config, QName, A, [C, D]), %% Test add and remove from recoverable_slaves
+ set_ha_policy(Config, QName, A, [C, D]), %% Test add and remove from recoverable_mirrors
%% Publish and confirm
amqp_channel:call(ACh, #'confirm.select'{}),
@@ -436,41 +436,41 @@ set_ha_policy(Config, QName, Master, Slaves) ->
Nodes = [list_to_binary(atom_to_list(N)) || N <- [Master | Slaves]],
HaPolicy = {<<"nodes">>, Nodes},
rabbit_ct_broker_helpers:set_ha_policy(Config, Master, QName, HaPolicy),
- await_slaves(QName, Master, Slaves).
+ await_followers(QName, Master, Slaves).
-await_slaves(QName, Master, Slaves) ->
- await_slaves_0(QName, Master, Slaves, 10).
+await_followers(QName, Master, Slaves) ->
+ await_followers_0(QName, Master, Slaves, 10).
-await_slaves_0(QName, Master, Slaves0, Tries) ->
- {ok, Queue} = await_slaves_lookup_queue(QName, Master),
+await_followers_0(QName, Master, Slaves0, Tries) ->
+ {ok, Queue} = await_followers_lookup_queue(QName, Master),
SPids = amqqueue:get_slave_pids(Queue),
ActMaster = amqqueue:qnode(Queue),
ActSlaves = lists:usort([node(P) || P <- SPids]),
Slaves1 = lists:usort(Slaves0),
- await_slaves_1(QName, ActMaster, ActSlaves, Master, Slaves1, Tries).
+ await_followers_1(QName, ActMaster, ActSlaves, Master, Slaves1, Tries).
-await_slaves_1(QName, _ActMaster, _ActSlaves, _Master, _Slaves, 0) ->
- error({timeout_waiting_for_slaves, QName});
-await_slaves_1(QName, ActMaster, ActSlaves, Master, Slaves, Tries) ->
+await_followers_1(QName, _ActMaster, _ActSlaves, _Master, _Slaves, 0) ->
+ error({timeout_waiting_for_followers, QName});
+await_followers_1(QName, ActMaster, ActSlaves, Master, Slaves, Tries) ->
case {Master, Slaves} of
{ActMaster, ActSlaves} ->
ok;
_ ->
timer:sleep(250),
- await_slaves_0(QName, Master, Slaves, Tries - 1)
+ await_followers_0(QName, Master, Slaves, Tries - 1)
end.
-await_slaves_lookup_queue(QName, Master) ->
- await_slaves_lookup_queue(QName, Master, 10).
+await_followers_lookup_queue(QName, Master) ->
+ await_followers_lookup_queue(QName, Master, 10).
-await_slaves_lookup_queue(QName, _Master, 0) ->
+await_followers_lookup_queue(QName, _Master, 0) ->
error({timeout_looking_up_queue, QName});
-await_slaves_lookup_queue(QName, Master, Tries) ->
+await_followers_lookup_queue(QName, Master, Tries) ->
RpcArgs = [rabbit_misc:r(<<"/">>, queue, QName)],
case rpc:call(Master, rabbit_amqqueue, lookup, RpcArgs) of
{error, not_found} ->
timer:sleep(250),
- await_slaves_lookup_queue(QName, Master, Tries - 1);
+ await_followers_lookup_queue(QName, Master, Tries - 1);
{ok, Q} ->
{ok, Q}
end.
diff --git a/test/crashing_queues_SUITE.erl b/test/crashing_queues_SUITE.erl
index ea453135e6..577ebb8517 100644
--- a/test/crashing_queues_SUITE.erl
+++ b/test/crashing_queues_SUITE.erl
@@ -99,7 +99,7 @@ crashing_mirrored(Config) ->
#'queue.declare'{queue = QName, durable = true}),
ok.
-test_queue_failure(Node, Ch, RaceConn, MsgCount, SlaveCount, Decl) ->
+test_queue_failure(Node, Ch, RaceConn, MsgCount, FollowerCount, Decl) ->
#'queue.declare_ok'{queue = QName} = amqp_channel:call(Ch, Decl),
try
publish(Ch, QName, transient),
@@ -107,7 +107,7 @@ test_queue_failure(Node, Ch, RaceConn, MsgCount, SlaveCount, Decl) ->
Racer = spawn_declare_racer(RaceConn, Decl),
kill_queue(Node, QName),
assert_message_count(MsgCount, Ch, QName),
- assert_slave_count(SlaveCount, Node, QName),
+ assert_follower_count(FollowerCount, Node, QName),
stop_declare_racer(Racer)
after
amqp_channel:call(Ch, #'queue.delete'{queue = QName})
@@ -258,7 +258,7 @@ assert_message_count(Count, Ch, QName) ->
amqp_channel:call(Ch, #'queue.declare'{queue = QName,
passive = true}).
-assert_slave_count(Count, Node, QName) ->
+assert_follower_count(Count, Node, QName) ->
Q = lookup(Node, QName),
[{_, Pids}] = rpc:call(Node, rabbit_amqqueue, info, [Q, [slave_pids]]),
RealCount = case Pids of
@@ -270,7 +270,7 @@ assert_slave_count(Count, Node, QName) ->
ok;
_ when RealCount < Count ->
timer:sleep(10),
- assert_slave_count(Count, Node, QName);
+ assert_follower_count(Count, Node, QName);
_ ->
- exit({too_many_slaves, Count, RealCount})
+ exit({too_many_replicas, Count, RealCount})
end.
diff --git a/test/dynamic_ha_SUITE.erl b/test/dynamic_ha_SUITE.erl
index f594683782..3b7eca40e4 100644
--- a/test/dynamic_ha_SUITE.erl
+++ b/test/dynamic_ha_SUITE.erl
@@ -60,10 +60,10 @@ groups() ->
force_delete_if_no_master,
promote_on_shutdown,
promote_on_failure,
- slave_recovers_after_vhost_failure,
- slave_recovers_after_vhost_down_and_up,
+ follower_recovers_after_vhost_failure,
+ follower_recovers_after_vhost_down_and_up,
master_migrates_on_vhost_down,
- slave_recovers_after_vhost_down_and_master_migrated,
+ follower_recovers_after_vhost_down_and_master_migrated,
queue_survive_adding_dead_vhost_mirror,
dynamic_mirroring
]},
@@ -71,7 +71,7 @@ groups() ->
change_policy,
rapid_change,
nodes_policy_should_pick_master_from_its_params,
- promote_slave_after_standalone_restart,
+ promote_follower_after_standalone_restart,
queue_survive_adding_dead_vhost_mirror,
rebalance_all,
rebalance_exactly,
@@ -194,33 +194,33 @@ change_policy(Config) ->
%% When we first declare a queue with no policy, it's not HA.
amqp_channel:call(ACh, #'queue.declare'{queue = ?QNAME}),
timer:sleep(200),
- assert_slaves(A, ?QNAME, {A, ''}),
+ assert_followers(A, ?QNAME, {A, ''}),
%% Give it policy "all", it becomes HA and gets all mirrors
rabbit_ct_broker_helpers:set_ha_policy(Config, A, ?POLICY, <<"all">>),
- assert_slaves(A, ?QNAME, {A, [B, C]}, [{A, []}, {A, [B]}, {A, [C]}]),
+ assert_followers(A, ?QNAME, {A, [B, C]}, [{A, []}, {A, [B]}, {A, [C]}]),
%% Give it policy "nodes", it gets specific mirrors
rabbit_ct_broker_helpers:set_ha_policy(Config, A, ?POLICY,
{<<"nodes">>, [rabbit_misc:atom_to_binary(A),
rabbit_misc:atom_to_binary(B)]}),
- assert_slaves(A, ?QNAME, {A, [B]}, [{A, [B, C]}]),
+ assert_followers(A, ?QNAME, {A, [B]}, [{A, [B, C]}]),
%% Now explicitly change the mirrors
rabbit_ct_broker_helpers:set_ha_policy(Config, A, ?POLICY,
{<<"nodes">>, [rabbit_misc:atom_to_binary(A),
rabbit_misc:atom_to_binary(C)]}),
- assert_slaves(A, ?QNAME, {A, [C]}, [{A, [B, C]}]),
+ assert_followers(A, ?QNAME, {A, [C]}, [{A, [B, C]}]),
%% Clear the policy, and we go back to non-mirrored
ok = rabbit_ct_broker_helpers:clear_policy(Config, A, ?POLICY),
- assert_slaves(A, ?QNAME, {A, ''}),
+ assert_followers(A, ?QNAME, {A, ''}),
%% Test switching "away" from an unmirrored node
rabbit_ct_broker_helpers:set_ha_policy(Config, A, ?POLICY,
{<<"nodes">>, [rabbit_misc:atom_to_binary(B),
rabbit_misc:atom_to_binary(C)]}),
- assert_slaves(A, ?QNAME, {B, [C]}, [{A, []}, {A, [B]}, {A, [C]}, {A, [B, C]}]),
+ assert_followers(A, ?QNAME, {B, [C]}, [{A, []}, {A, [B]}, {A, [C]}, {A, [B, C]}]),
ok.
@@ -230,19 +230,19 @@ change_cluster(Config) ->
ACh = rabbit_ct_client_helpers:open_channel(Config, A),
amqp_channel:call(ACh, #'queue.declare'{queue = ?QNAME}),
- assert_slaves(A, ?QNAME, {A, ''}),
+ assert_followers(A, ?QNAME, {A, ''}),
%% Give it policy exactly 4, it should mirror to all 3 nodes
rabbit_ct_broker_helpers:set_ha_policy(Config, A, ?POLICY, {<<"exactly">>, 4}),
- assert_slaves(A, ?QNAME, {A, [B, C]}, [{A, []}, {A, [B]}, {A, [C]}]),
+ assert_followers(A, ?QNAME, {A, [B, C]}, [{A, []}, {A, [B]}, {A, [C]}]),
%% Add D and E, D or E joins in
rabbit_ct_broker_helpers:cluster_nodes(Config, [A, D, E]),
- assert_slaves(A, ?QNAME, [{A, [B, C, D]}, {A, [B, C, E]}], [{A, [B, C]}]),
+ assert_followers(A, ?QNAME, [{A, [B, C, D]}, {A, [B, C, E]}], [{A, [B, C]}]),
%% Remove one, the other joins in
rabbit_ct_broker_helpers:stop_node(Config, D),
- assert_slaves(A, ?QNAME, [{A, [B, C, D]}, {A, [B, C, E]}], [{A, [B, C]}]),
+ assert_followers(A, ?QNAME, [{A, [B, C, D]}, {A, [B, C, E]}], [{A, [B, C]}]),
ok.
@@ -437,9 +437,9 @@ nodes_policy_should_pick_master_from_its_params(Config) ->
%% --> Master: A
%% Slaves: [B, C] or [C, B]
Info = find_queue(?QNAME, A),
- SSPids = proplists:get_value(synchronised_slave_pids, Info),
+ SSPids = proplists:get_value(synchronised_follower_pids, Info),
- %% Choose mirror that isn't the first sync slave. Cover a bug that always
+ %% Choose mirror that isn't the first sync mirror. Cover a bug that always
%% chose the first, even if it was not part of the policy
LastSlave = node(lists:last(SSPids)),
?assertEqual(true, apply_policy_to_declared_queue(Config, Ch, [A],
@@ -469,29 +469,29 @@ nodes_policy_should_pick_master_from_its_params(Config) ->
amqp_channel:call(Ch, #'queue.delete'{queue = ?QNAME}),
_ = rabbit_ct_broker_helpers:clear_policy(Config, A, ?POLICY).
-slave_recovers_after_vhost_failure(Config) ->
+follower_recovers_after_vhost_failure(Config) ->
[A, B] = rabbit_ct_broker_helpers:get_node_configs(Config, nodename),
rabbit_ct_broker_helpers:set_ha_policy_all(Config),
ACh = rabbit_ct_client_helpers:open_channel(Config, A),
- QName = <<"slave_recovers_after_vhost_failure-q">>,
+ QName = <<"follower_recovers_after_vhost_failure-q">>,
amqp_channel:call(ACh, #'queue.declare'{queue = QName}),
timer:sleep(500),
- assert_slaves(A, QName, {A, [B]}, [{A, []}]),
+ assert_followers(A, QName, {A, [B]}, [{A, []}]),
%% Crash vhost on a node hosting a mirror
{ok, Sup} = rabbit_ct_broker_helpers:rpc(Config, B, rabbit_vhost_sup_sup, get_vhost_sup, [<<"/">>]),
exit(Sup, foo),
- assert_slaves(A, QName, {A, [B]}, [{A, []}]).
+ assert_followers(A, QName, {A, [B]}, [{A, []}]).
-slave_recovers_after_vhost_down_and_up(Config) ->
+follower_recovers_after_vhost_down_and_up(Config) ->
[A, B] = rabbit_ct_broker_helpers:get_node_configs(Config, nodename),
rabbit_ct_broker_helpers:set_ha_policy_all(Config),
ACh = rabbit_ct_client_helpers:open_channel(Config, A),
- QName = <<"slave_recovers_after_vhost_down_and_up-q">>,
+ QName = <<"follower_recovers_after_vhost_down_and_up-q">>,
amqp_channel:call(ACh, #'queue.declare'{queue = QName}),
timer:sleep(200),
- assert_slaves(A, QName, {A, [B]}, [{A, []}]),
+ assert_followers(A, QName, {A, [B]}, [{A, []}]),
%% Crash vhost on a node hosting a mirror
rabbit_ct_broker_helpers:force_vhost_failure(Config, B, <<"/">>),
@@ -504,7 +504,7 @@ slave_recovers_after_vhost_down_and_up(Config) ->
{error,{already_started, _Sup}} -> ok
end,
- assert_slaves(A, QName, {A, [B]}, [{A, []}]).
+ assert_followers(A, QName, {A, [B]}, [{A, []}]).
master_migrates_on_vhost_down(Config) ->
[A, B] = rabbit_ct_broker_helpers:get_node_configs(Config, nodename),
@@ -513,25 +513,25 @@ master_migrates_on_vhost_down(Config) ->
QName = <<"master_migrates_on_vhost_down-q">>,
amqp_channel:call(ACh, #'queue.declare'{queue = QName}),
timer:sleep(500),
- assert_slaves(A, QName, {A, [B]}, [{A, []}]),
+ assert_followers(A, QName, {A, [B]}, [{A, []}]),
%% Crash vhost on the node hosting queue master
rabbit_ct_broker_helpers:force_vhost_failure(Config, A, <<"/">>),
timer:sleep(500),
- assert_slaves(A, QName, {B, []}).
+ assert_followers(A, QName, {B, []}).
-slave_recovers_after_vhost_down_and_master_migrated(Config) ->
+follower_recovers_after_vhost_down_and_master_migrated(Config) ->
[A, B] = rabbit_ct_broker_helpers:get_node_configs(Config, nodename),
rabbit_ct_broker_helpers:set_ha_policy_all(Config),
ACh = rabbit_ct_client_helpers:open_channel(Config, A),
- QName = <<"slave_recovers_after_vhost_down_and_master_migrated-q">>,
+ QName = <<"follower_recovers_after_vhost_down_and_master_migrated-q">>,
amqp_channel:call(ACh, #'queue.declare'{queue = QName}),
timer:sleep(500),
- assert_slaves(A, QName, {A, [B]}, [{A, []}]),
+ assert_followers(A, QName, {A, [B]}, [{A, []}]),
%% Crash vhost on the node hosting queue master
rabbit_ct_broker_helpers:force_vhost_failure(Config, A, <<"/">>),
timer:sleep(500),
- assert_slaves(B, QName, {B, []}),
+ assert_followers(B, QName, {B, []}),
%% Restart the vhost on the node (previously) hosting queue master
case rabbit_ct_broker_helpers:rpc(Config, A, rabbit_vhost_sup_sup, start_vhost, [<<"/">>]) of
@@ -539,7 +539,7 @@ slave_recovers_after_vhost_down_and_master_migrated(Config) ->
{error,{already_started, _Sup}} -> ok
end,
timer:sleep(500),
- assert_slaves(B, QName, {B, [A]}, [{B, []}]).
+ assert_followers(B, QName, {B, [A]}, [{B, []}]).
random_policy(Config) ->
run_proper(fun prop_random_policy/1, [Config]).
@@ -558,7 +558,7 @@ failing_random_policies(Config) ->
[all, undefined, {exactly, 2}, all, {exactly, 3}, {exactly, 3},
undefined, {exactly, 3}, all])).
-promote_slave_after_standalone_restart(Config) ->
+promote_follower_after_standalone_restart(Config) ->
%% Tests that mirrors can be brought up standalone after forgetting the rest
%% of the cluster. Slave ordering should be irrelevant.
%% https://github.com/rabbitmq/rabbitmq-server/issues/1213
@@ -620,11 +620,11 @@ rebalance_all(Config) ->
rabbit_ct_client_helpers:publish(ACh, Q1, 5),
rabbit_ct_client_helpers:publish(ACh, Q2, 3),
- assert_slaves(A, Q1, {A, [B, C]}, [{A, []}, {A, [B]}, {A, [C]}]),
- assert_slaves(A, Q2, {A, [B, C]}, [{A, []}, {A, [B]}, {A, [C]}]),
- assert_slaves(A, Q3, {A, [B, C]}, [{A, []}, {A, [B]}, {A, [C]}]),
- assert_slaves(A, Q4, {A, [B, C]}, [{A, []}, {A, [B]}, {A, [C]}]),
- assert_slaves(A, Q5, {A, [B, C]}, [{A, []}, {A, [B]}, {A, [C]}]),
+ assert_followers(A, Q1, {A, [B, C]}, [{A, []}, {A, [B]}, {A, [C]}]),
+ assert_followers(A, Q2, {A, [B, C]}, [{A, []}, {A, [B]}, {A, [C]}]),
+ assert_followers(A, Q3, {A, [B, C]}, [{A, []}, {A, [B]}, {A, [C]}]),
+ assert_followers(A, Q4, {A, [B, C]}, [{A, []}, {A, [B]}, {A, [C]}]),
+ assert_followers(A, Q5, {A, [B, C]}, [{A, []}, {A, [B]}, {A, [C]}]),
{ok, Summary} = rpc:call(A, rabbit_amqqueue, rebalance, [classic, ".*", ".*"]),
@@ -639,8 +639,8 @@ rebalance_all(Config) ->
rabbit_ct_helpers:await_condition(Condition1, 60000),
%% Check that Q1 and Q2 haven't moved
- assert_slaves(A, Q1, {A, [B, C]}, [{A, []}, {A, [B]}, {A, [C]}]),
- assert_slaves(A, Q2, {A, [B, C]}, [{A, []}, {A, [B]}, {A, [C]}]),
+ assert_followers(A, Q1, {A, [B, C]}, [{A, []}, {A, [B]}, {A, [C]}]),
+ assert_followers(A, Q2, {A, [B, C]}, [{A, []}, {A, [B]}, {A, [C]}]),
ok.
@@ -795,31 +795,31 @@ rebalance_multiple_blocked1(_) ->
%%----------------------------------------------------------------------------
-assert_slaves(RPCNode, QName, Exp) ->
- assert_slaves(RPCNode, QName, Exp, []).
+assert_followers(RPCNode, QName, Exp) ->
+ assert_followers(RPCNode, QName, Exp, []).
-assert_slaves(RPCNode, QName, Exp, PermittedIntermediate) ->
- assert_slaves0(RPCNode, QName, Exp,
+assert_followers(RPCNode, QName, Exp, PermittedIntermediate) ->
+ assert_followers0(RPCNode, QName, Exp,
[{get(previous_exp_m_node), get(previous_exp_s_nodes)} |
PermittedIntermediate], 1000).
-assert_slaves0(_RPCNode, _QName, [], _PermittedIntermediate, _Attempts) ->
+assert_followers0(_RPCNode, _QName, [], _PermittedIntermediate, _Attempts) ->
error(invalid_expectation);
-assert_slaves0(RPCNode, QName, [{ExpMNode, ExpSNodes}|T], PermittedIntermediate, Attempts) ->
- case assert_slaves1(RPCNode, QName, {ExpMNode, ExpSNodes}, PermittedIntermediate, Attempts, nofail) of
+assert_followers0(RPCNode, QName, [{ExpMNode, ExpSNodes}|T], PermittedIntermediate, Attempts) ->
+ case assert_followers1(RPCNode, QName, {ExpMNode, ExpSNodes}, PermittedIntermediate, Attempts, nofail) of
ok ->
ok;
failed ->
- assert_slaves0(RPCNode, QName, T, PermittedIntermediate, Attempts - 1)
+ assert_followers0(RPCNode, QName, T, PermittedIntermediate, Attempts - 1)
end;
-assert_slaves0(RPCNode, QName, {ExpMNode, ExpSNodes}, PermittedIntermediate, Attempts) ->
- assert_slaves1(RPCNode, QName, {ExpMNode, ExpSNodes}, PermittedIntermediate, Attempts, fail).
+assert_followers0(RPCNode, QName, {ExpMNode, ExpSNodes}, PermittedIntermediate, Attempts) ->
+ assert_followers1(RPCNode, QName, {ExpMNode, ExpSNodes}, PermittedIntermediate, Attempts, fail).
-assert_slaves1(_RPCNode, _QName, _Exp, _PermittedIntermediate, 0, fail) ->
- error(give_up_waiting_for_slaves);
-assert_slaves1(_RPCNode, _QName, _Exp, _PermittedIntermediate, 0, nofail) ->
+assert_followers1(_RPCNode, _QName, _Exp, _PermittedIntermediate, 0, fail) ->
+ error(give_up_waiting_for_followers);
+assert_followers1(_RPCNode, _QName, _Exp, _PermittedIntermediate, 0, nofail) ->
failed;
-assert_slaves1(RPCNode, QName, {ExpMNode, ExpSNodes}, PermittedIntermediate, Attempts, FastFail) ->
+assert_followers1(RPCNode, QName, {ExpMNode, ExpSNodes}, PermittedIntermediate, Attempts, FastFail) ->
Q = find_queue(QName, RPCNode),
Pid = proplists:get_value(pid, Q),
SPids = proplists:get_value(slave_pids, Q),
@@ -850,7 +850,7 @@ assert_slaves1(RPCNode, QName, {ExpMNode, ExpSNodes}, PermittedIntermediate, Att
ct:pal("Waiting to leave state ~p~n Waiting for ~p~n",
[State, {ExpMNode, ExpSNodes}]),
timer:sleep(200),
- assert_slaves1(RPCNode, QName, {ExpMNode, ExpSNodes},
+ assert_followers1(RPCNode, QName, {ExpMNode, ExpSNodes},
PermittedIntermediate,
Attempts - 1, FastFail)
end;
diff --git a/test/priority_queue_SUITE.erl b/test/priority_queue_SUITE.erl
index 97381fd61c..2e29aa8725 100644
--- a/test/priority_queue_SUITE.erl
+++ b/test/priority_queue_SUITE.erl
@@ -56,7 +56,7 @@ groups() ->
mirror_queue_auto_ack,
mirror_fast_reset_policy,
mirror_reset_policy,
- mirror_stop_pending_slaves
+ mirror_stop_pending_followers
]}
].
@@ -449,7 +449,7 @@ mirror_queue_sync(Config) ->
publish(Ch, Q, [1, 2, 3, 1, 2, 3]),
%% master now has 9, mirror 6.
get_partial(Ch, Q, manual_ack, [3, 3, 3, 2, 2, 2]),
- %% So some but not all are unacked at the slave
+ %% So some but not all are unacked at the mirror
Nodename0 = rabbit_ct_broker_helpers:get_node_config(Config, 0, nodename),
rabbit_ct_broker_helpers:control_action(sync_queue, Nodename0,
[binary_to_list(Q)], [{"-p", "/"}]),
@@ -541,7 +541,7 @@ mirror_queue_sync_order(Config) ->
{3, <<"msg5">>}]),
rabbit_ct_client_helpers:close_channel(Ch),
- %% Add and sync slave
+ %% Add and sync mirror
ok = rabbit_ct_broker_helpers:set_ha_policy(
Config, A, <<"^mirror_queue_sync_order-queue$">>, <<"all">>),
rabbit_ct_broker_helpers:control_action(sync_queue, A,
@@ -602,7 +602,7 @@ mirror_reset_policy(Config, Wait) ->
rabbit_ct_client_helpers:close_connection(Conn),
passed.
-mirror_stop_pending_slaves(Config) ->
+mirror_stop_pending_followers(Config) ->
A = rabbit_ct_broker_helpers:get_node_config(Config, 0, nodename),
B = rabbit_ct_broker_helpers:get_node_config(Config, 1, nodename),
C = rabbit_ct_broker_helpers:get_node_config(Config, 2, nodename),
@@ -611,17 +611,17 @@ mirror_stop_pending_slaves(Config) ->
Config, Nodename, application, set_env, [rabbit, slave_wait_timeout, 0]) || Nodename <- [A, B, C]],
{Conn, Ch} = rabbit_ct_client_helpers:open_connection_and_channel(Config, A),
- Q = <<"mirror_stop_pending_slaves-queue">>,
+ Q = <<"mirror_stop_pending_followers-queue">>,
declare(Ch, Q, 5),
publish_many(Ch, Q, 20000),
[begin
rabbit_ct_broker_helpers:set_ha_policy(
- Config, A, <<"^mirror_stop_pending_slaves-queue$">>, <<"all">>,
+ Config, A, <<"^mirror_stop_pending_followers-queue$">>, <<"all">>,
[{<<"ha-sync-mode">>, <<"automatic">>}]),
wait_for_sync(Config, A, rabbit_misc:r(<<"/">>, queue, Q), 2),
rabbit_ct_broker_helpers:clear_policy(
- Config, A, <<"^mirror_stop_pending_slaves-queue$">>)
+ Config, A, <<"^mirror_stop_pending_followers-queue$">>)
end || _ <- lists:seq(1, 15)],
delete(Ch, Q),
diff --git a/test/sync_detection_SUITE.erl b/test/sync_detection_SUITE.erl
index 6041218268..42e224d112 100644
--- a/test/sync_detection_SUITE.erl
+++ b/test/sync_detection_SUITE.erl
@@ -32,10 +32,10 @@ all() ->
groups() ->
[
{cluster_size_2, [], [
- slave_synchronization
+ follower_synchronization
]},
{cluster_size_3, [], [
- slave_synchronization_ttl
+ follower_synchronization_ttl
]}
].
@@ -85,7 +85,7 @@ end_per_testcase(Testcase, Config) ->
%% Testcases.
%% -------------------------------------------------------------------
-slave_synchronization(Config) ->
+follower_synchronization(Config) ->
[Master, Slave] = rabbit_ct_broker_helpers:get_node_configs(Config,
nodename),
Channel = rabbit_ct_client_helpers:open_channel(Config, Master),
@@ -107,13 +107,13 @@ slave_synchronization(Config) ->
rabbit_ct_broker_helpers:start_broker(Config, Slave),
- slave_unsynced(Master, Queue),
+ follower_unsynced(Master, Queue),
send_dummy_message(Channel, Queue), % 1 - 1
- slave_unsynced(Master, Queue),
+ follower_unsynced(Master, Queue),
amqp_channel:cast(Channel, #'basic.ack'{delivery_tag = Tag1}), % 1 - 0
- slave_synced(Master, Queue),
+ follower_synced(Master, Queue),
%% We restart the mirror and we send a message, so that the mirror will only
%% have one of the messages.
@@ -122,26 +122,26 @@ slave_synchronization(Config) ->
send_dummy_message(Channel, Queue), % 2 - 0
- slave_unsynced(Master, Queue),
+ follower_unsynced(Master, Queue),
%% We reject the message that the mirror doesn't have, and verify that it's
%% still unsynced
{#'basic.get_ok'{delivery_tag = Tag2}, _} =
amqp_channel:call(Channel, #'basic.get'{queue = Queue}), % 1 - 1
- slave_unsynced(Master, Queue),
+ follower_unsynced(Master, Queue),
amqp_channel:cast(Channel, #'basic.reject'{ delivery_tag = Tag2,
requeue = true }), % 2 - 0
- slave_unsynced(Master, Queue),
+ follower_unsynced(Master, Queue),
{#'basic.get_ok'{delivery_tag = Tag3}, _} =
amqp_channel:call(Channel, #'basic.get'{queue = Queue}), % 1 - 1
amqp_channel:cast(Channel, #'basic.ack'{delivery_tag = Tag3}), % 1 - 0
- slave_synced(Master, Queue),
+ follower_synced(Master, Queue),
{#'basic.get_ok'{delivery_tag = Tag4}, _} =
amqp_channel:call(Channel, #'basic.get'{queue = Queue}), % 0 - 1
amqp_channel:cast(Channel, #'basic.ack'{delivery_tag = Tag4}), % 0 - 0
- slave_synced(Master, Queue).
+ follower_synced(Master, Queue).
-slave_synchronization_ttl(Config) ->
+follower_synchronization_ttl(Config) ->
[Master, Slave, DLX] = rabbit_ct_broker_helpers:get_node_configs(Config,
nodename),
Channel = rabbit_ct_client_helpers:open_channel(Config, Master),
@@ -165,33 +165,33 @@ slave_synchronization_ttl(Config) ->
auto_delete = false,
arguments = Args}),
- slave_synced(Master, Queue),
+ follower_synced(Master, Queue),
%% All unknown
rabbit_ct_broker_helpers:stop_broker(Config, Slave),
send_dummy_message(Channel, Queue),
send_dummy_message(Channel, Queue),
rabbit_ct_broker_helpers:start_broker(Config, Slave),
- slave_unsynced(Master, Queue),
+ follower_unsynced(Master, Queue),
wait_for_messages(DLXQueue, DLXChannel, 2),
- slave_synced(Master, Queue),
+ follower_synced(Master, Queue),
%% 1 unknown, 1 known
rabbit_ct_broker_helpers:stop_broker(Config, Slave),
send_dummy_message(Channel, Queue),
rabbit_ct_broker_helpers:start_broker(Config, Slave),
- slave_unsynced(Master, Queue),
+ follower_unsynced(Master, Queue),
send_dummy_message(Channel, Queue),
- slave_unsynced(Master, Queue),
+ follower_unsynced(Master, Queue),
wait_for_messages(DLXQueue, DLXChannel, 2),
- slave_synced(Master, Queue),
+ follower_synced(Master, Queue),
%% %% both known
send_dummy_message(Channel, Queue),
send_dummy_message(Channel, Queue),
- slave_synced(Master, Queue),
+ follower_synced(Master, Queue),
wait_for_messages(DLXQueue, DLXChannel, 2),
- slave_synced(Master, Queue),
+ follower_synced(Master, Queue),
ok.
@@ -200,7 +200,7 @@ send_dummy_message(Channel, Queue) ->
Publish = #'basic.publish'{exchange = <<>>, routing_key = Queue},
amqp_channel:cast(Channel, Publish, #amqp_msg{payload = Payload}).
-slave_pids(Node, Queue) ->
+follower_pids(Node, Queue) ->
{ok, Q} = rpc:call(Node, rabbit_amqqueue, lookup,
[rabbit_misc:r(<<"/">>, queue, Queue)]),
SSP = synchronised_slave_pids,
@@ -223,17 +223,17 @@ wait_for_sync_status(N, Max, Status, Node, Queue) when N >= Max ->
{expected_status, Status},
{max_tried, Max}]});
wait_for_sync_status(N, Max, Status, Node, Queue) ->
- Synced = length(slave_pids(Node, Queue)) =:= 1,
+ Synced = length(follower_pids(Node, Queue)) =:= 1,
case Synced =:= Status of
true -> ok;
false -> timer:sleep(?LOOP_RECURSION_DELAY),
wait_for_sync_status(N + 1, Max, Status, Node, Queue)
end.
-slave_synced(Node, Queue) ->
+follower_synced(Node, Queue) ->
wait_for_sync_status(true, Node, Queue).
-slave_unsynced(Node, Queue) ->
+follower_unsynced(Node, Queue) ->
wait_for_sync_status(false, Node, Queue).
wait_for_messages(Queue, Channel, N) ->
View Lorry Controller Status