Rename delegate:call and :cast to :invoke and :invoke_async.

4 files changed, 34 insertions, 34 deletions

diff --git a/src/delegate.erl b/src/delegate.erl
index 1bc788f8..c72a3afb 100644
--- a/src/delegate.erl
+++ b/src/delegate.erl
@@ -34,7 +34,7 @@
 
 -behaviour(gen_server2).
 
--export([start_link/1, cast/2, call/2,
+-export([start_link/1, invoke_async/2, invoke/2,
          gs2_call/3, gs2_pcall/4,
          gs2_cast/2, gs2_pcast/3,
          server/1, process_count/0]).
@@ -49,8 +49,8 @@
 -type(serverref() :: atom() | {atom(), atom()} | {'global', term()} | pid()).
 
 -spec(start_link/1 :: (non_neg_integer()) -> {'ok', pid()}).
--spec(cast/2 :: (pid() | [pid()], fun((pid()) -> any())) -> 'ok').
--spec(call/2 :: (pid() | [pid()], fun((pid()) -> A)) -> A).
+-spec(invoke_async/2 :: (pid() | [pid()], fun((pid()) -> any())) -> 'ok').
+-spec(invoke/2 :: (pid() | [pid()], fun((pid()) -> A)) -> A).
 
 -spec(gs2_call/3 ::
       (serverref(), any(), non_neg_integer() | 'infinity') -> any()).
@@ -72,34 +72,34 @@ start_link(Hash) ->
 
 gs2_call(Pid, Msg, Timeout) ->
     {_Status, Res} =
-        call(Pid, fun(P) -> gen_server2:call(P, Msg, Timeout) end),
+        invoke(Pid, fun(P) -> gen_server2:call(P, Msg, Timeout) end),
     Res.
 
 gs2_pcall(Pid, Pri, Msg, Timeout) ->
     {_Status, Res} =
-        call(Pid, fun(P) -> gen_server2:pcall(P, Pri, Msg, Timeout) end),
+        invoke(Pid, fun(P) -> gen_server2:pcall(P, Pri, Msg, Timeout) end),
     Res.
 
 gs2_cast(Pid, Msg) ->
-    cast(Pid, fun(P) -> gen_server2:cast(P, Msg) end).
+    invoke_async(Pid, fun(P) -> gen_server2:cast(P, Msg) end).
 
 gs2_pcast(Pid, Pri, Msg) ->
-    cast(Pid, fun(P) -> gen_server2:pcast(P, Pri, Msg) end).
+    invoke_async(Pid, fun(P) -> gen_server2:pcast(P, Pri, Msg) end).
 
 
-call(Pid, FPid) when is_pid(Pid) ->
-    [{Status, Res, _}] = call_per_node([{node(Pid), [Pid]}], FPid),
+invoke(Pid, FPid) when is_pid(Pid) ->
+    [{Status, Res, _}] = invoke_per_node([{node(Pid), [Pid]}], FPid),
     {Status, Res};
 
-call(Pids, FPid) when is_list(Pids) ->
-    call_per_node(split_delegate_per_node(Pids), FPid).
+invoke(Pids, FPid) when is_list(Pids) ->
+    invoke_per_node(split_delegate_per_node(Pids), FPid).
 
-cast(Pid, FPid) when is_pid(Pid) ->
-    cast_per_node([{node(Pid), [Pid]}], FPid),
+invoke_async(Pid, FPid) when is_pid(Pid) ->
+    invoke_async_per_node([{node(Pid), [Pid]}], FPid),
     ok;
 
-cast(Pids, FPid) when is_list(Pids) ->
-    cast_per_node(split_delegate_per_node(Pids),  FPid),
+invoke_async(Pids, FPid) when is_list(Pids) ->
+    invoke_async_per_node(split_delegate_per_node(Pids),  FPid),
     ok.
 
 %%----------------------------------------------------------------------------
@@ -120,14 +120,14 @@ split_delegate_per_node(Pids) ->
         end,
         orddict:new(), Pids)).
 
-call_per_node([{Node, Pids}], FPid) when Node == node() ->
+invoke_per_node([{Node, Pids}], FPid) when Node == node() ->
     local_delegate(Pids, FPid);
-call_per_node(NodePids, FPid) ->
+invoke_per_node(NodePids, FPid) ->
     delegate_per_node(NodePids, FPid, fun internal_call/2).
 
-cast_per_node([{Node, Pids}], FPid) when Node == node() ->
+invoke_async_per_node([{Node, Pids}], FPid) when Node == node() ->
     local_delegate(Pids, FPid);
-cast_per_node(NodePids, FPid) ->
+invoke_async_per_node(NodePids, FPid) ->
     delegate_per_node(NodePids, FPid, fun internal_cast/2).
 
 local_delegate(Pids, FPid) ->
diff --git a/src/rabbit_amqqueue.erl b/src/rabbit_amqqueue.erl
index 23a4932a..a5fc4181 100644
--- a/src/rabbit_amqqueue.erl
+++ b/src/rabbit_amqqueue.erl
@@ -283,7 +283,7 @@ commit_all(QPids, Txn, ChPid) ->
       QPids).
 
 rollback_all(QPids, Txn, ChPid) ->
-    delegate:cast(QPids,
+    delegate:invoke_async(QPids,
         fun (QPid) -> gen_server2:cast(QPid, {rollback, Txn, ChPid}) end).
 
 notify_down_all(QPids, ChPid) ->
@@ -295,7 +295,7 @@ notify_down_all(QPids, ChPid) ->
       QPids).
 
 limit_all(QPids, ChPid, LimiterPid) ->
-    delegate:cast(QPids,
+    delegate:invoke_async(QPids,
         fun (QPid) -> gen_server2:cast(QPid, {limit, ChPid, LimiterPid}) end).
 
 claim_queue(#amqqueue{pid = QPid}, ReaderPid) ->
@@ -321,7 +321,7 @@ unblock(QPid, ChPid) ->
     delegate:gs2_pcast(QPid, 7, {unblock, ChPid}).
 
 flush_all(QPids, ChPid) ->
-    delegate:cast(QPids,
+    delegate:invoke_async(QPids,
         fun (QPid) -> gen_server2:cast(QPid, {flush, ChPid}) end).
 
 internal_delete(QueueName) ->
@@ -369,7 +369,7 @@ pseudo_queue(QueueName, Pid) ->
               pid = Pid}.
 
 safe_delegate_call_ok(H, F, Pids) ->
-    case [R || R = {error, _, _} <- delegate:call(
+    case [R || R = {error, _, _} <- delegate:invoke(
                                       Pids,
                                       fun (Pid) ->
                                               rabbit_misc:with_exit_handler(
diff --git a/src/rabbit_router.erl b/src/rabbit_router.erl
index 8681b535..444be4b2 100644
--- a/src/rabbit_router.erl
+++ b/src/rabbit_router.erl
@@ -56,12 +56,12 @@ deliver(QPids, Delivery = #delivery{mandatory = false,
     %% therefore safe to use a fire-and-forget cast here and return
     %% the QPids - the semantics is preserved. This scales much better
     %% than the non-immediate case below.
-    delegate:cast(QPids,
+    delegate:invoke_async(QPids,
                   fun(Pid) -> rabbit_amqqueue:deliver(Pid, Delivery) end),
     {routed, QPids};
 
 deliver(QPids, Delivery) ->
-    Res = delegate:call(QPids,
+    Res = delegate:invoke(QPids,
                         fun(Pid) -> rabbit_amqqueue:deliver(Pid, Delivery) end),
     {Routed, Handled} = lists:foldl(fun fold_deliveries/2, {false, []}, Res),
     check_delivery(Delivery#delivery.mandatory, Delivery#delivery.immediate,
diff --git a/src/rabbit_tests.erl b/src/rabbit_tests.erl
index a070e42d..f66b8cec 100644
--- a/src/rabbit_tests.erl
+++ b/src/rabbit_tests.erl
@@ -846,13 +846,13 @@ test_delegates_async(SecondaryNode) ->
 
     Responder = make_responder(fun({invoked, Pid}) -> Pid ! response end),
 
-    ok = delegate:cast(spawn(Responder), Sender),
-    ok = delegate:cast(spawn(SecondaryNode, Responder), Sender),
+    ok = delegate:invoke_async(spawn(Responder), Sender),
+    ok = delegate:invoke_async(spawn(SecondaryNode, Responder), Sender),
     await_response(2),
 
     LocalPids = spawn_responders(node(), Responder, 10),
     RemotePids = spawn_responders(SecondaryNode, Responder, 10),
-    ok = delegate:cast(LocalPids ++ RemotePids, Sender),
+    ok = delegate:invoke_async(LocalPids ++ RemotePids, Sender),
     await_response(20),
 
     passed.
@@ -890,19 +890,19 @@ test_delegates_sync(SecondaryNode) ->
                                       throw(exception)
                                   end),
 
-    {ok, response} = delegate:call(spawn(Responder), Sender),
-    {ok, response} = delegate:call(spawn(SecondaryNode, Responder), Sender),
+    {ok, response} = delegate:invoke(spawn(Responder), Sender),
+    {ok, response} = delegate:invoke(spawn(SecondaryNode, Responder), Sender),
 
-    {error, _} = delegate:call(spawn(BadResponder), Sender),
-    {error, _} = delegate:call(spawn(SecondaryNode, BadResponder), Sender),
+    {error, _} = delegate:invoke(spawn(BadResponder), Sender),
+    {error, _} = delegate:invoke(spawn(SecondaryNode, BadResponder), Sender),
 
     LocalGoodPids = spawn_responders(node(), Responder, 2),
     RemoteGoodPids = spawn_responders(SecondaryNode, Responder, 2),
     LocalBadPids = spawn_responders(node(), BadResponder, 2),
     RemoteBadPids = spawn_responders(SecondaryNode, BadResponder, 2),
 
-    GoodRes = delegate:call(LocalGoodPids ++ RemoteGoodPids, Sender),
-    BadRes = delegate:call(LocalBadPids ++ RemoteBadPids, Sender),
+    GoodRes = delegate:invoke(LocalGoodPids ++ RemoteGoodPids, Sender),
+    BadRes = delegate:invoke(LocalBadPids ++ RemoteBadPids, Sender),
 
     true = lists:all(fun ({ok, response, _}) -> true end, GoodRes),
     true = lists:all(fun ({error, _, _}) -> true end, BadRes),