Rename invoke_async as it's not really async.

4 files changed, 17 insertions, 17 deletions

diff --git a/src/delegate.erl b/src/delegate.erl
index 8597595f..bdeda532 100644
--- a/src/delegate.erl
+++ b/src/delegate.erl
@@ -34,7 +34,7 @@
 
 -behaviour(gen_server2).
 
--export([start_link/1, invoke_async/2, invoke/2, process_count/0]).
+-export([start_link/1, invoke_no_return/2, invoke/2, process_count/0]).
 
 -export([init/1, handle_call/3, handle_cast/2, handle_info/2,
          terminate/2, code_change/3]).
@@ -44,7 +44,7 @@
 -ifdef(use_specs).
 
 -spec(start_link/1 :: (non_neg_integer()) -> {'ok', pid()}).
--spec(invoke_async/2 :: (pid() | [pid()], fun((pid()) -> any())) -> 'ok').
+-spec(invoke_no_return/2 :: (pid() | [pid()], fun((pid()) -> any())) -> 'ok').
 -spec(invoke/2 :: (pid() | [pid()], fun((pid()) -> A)) -> A).
 
 -spec(process_count/0 :: () -> non_neg_integer()).
@@ -64,12 +64,12 @@ invoke(Pid, FPid) when is_pid(Pid) ->
 invoke(Pids, FPid) when is_list(Pids) ->
     invoke_per_node(split_delegate_per_node(Pids), FPid).
 
-invoke_async(Pid, FPid) when is_pid(Pid) ->
-    invoke_async_per_node([{node(Pid), [Pid]}], FPid),
+invoke_no_return(Pid, FPid) when is_pid(Pid) ->
+    invoke_no_return_per_node([{node(Pid), [Pid]}], FPid),
     ok;
 
-invoke_async(Pids, FPid) when is_list(Pids) ->
-    invoke_async_per_node(split_delegate_per_node(Pids),  FPid),
+invoke_no_return(Pids, FPid) when is_list(Pids) ->
+    invoke_no_return_per_node(split_delegate_per_node(Pids),  FPid),
     ok.
 
 %%----------------------------------------------------------------------------
@@ -95,14 +95,14 @@ invoke_per_node([{Node, Pids}], FPid) when Node == node() ->
 invoke_per_node(NodePids, FPid) ->
     lists:append(delegate_per_node(NodePids, FPid, fun internal_call/2)).
 
-invoke_async_per_node([{Node, Pids}], FPid) when Node == node() ->
+invoke_no_return_per_node([{Node, Pids}], FPid) when Node == node() ->
     % This is not actually async! However, in practice FPid will always be
     % something that does a gen_server:cast or similar, so I don't think
     % it's a problem unless someone misuses this function. Making this
     % *actually* async would be painful as we can't spawn at this point or we
     % break effect ordering.
     local_delegate(Pids, FPid);
-invoke_async_per_node(NodePids, FPid) ->
+invoke_no_return_per_node(NodePids, FPid) ->
     delegate_per_node(NodePids, FPid, fun internal_cast/2),
     ok.
 
diff --git a/src/rabbit_amqqueue.erl b/src/rabbit_amqqueue.erl
index ec2368fb..b7281ac2 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:invoke_async(QPids,
+    delegate:invoke_no_return(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:invoke_async(QPids,
+    delegate:invoke_no_return(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_pcast(QPid, 7, {unblock, ChPid}).
 
 flush_all(QPids, ChPid) ->
-    delegate:invoke_async(QPids,
+    delegate:invoke_no_return(QPids,
         fun (QPid) -> gen_server2:cast(QPid, {flush, ChPid}) end).
 
 internal_delete(QueueName) ->
@@ -392,8 +392,8 @@ delegate_pcall(Pid, Pri, Msg, Timeout) ->
     Res.
 
 delegate_cast(Pid, Msg) ->
-    delegate:invoke_async(Pid, fun(P) -> gen_server2:cast(P, Msg) end).
+    delegate:invoke_no_return(Pid, fun(P) -> gen_server2:cast(P, Msg) end).
 
 delegate_pcast(Pid, Pri, Msg) ->
-    delegate:invoke_async(Pid, fun(P) -> gen_server2:pcast(P, Pri, Msg) end).
+    delegate:invoke_no_return(Pid, fun(P) -> gen_server2:pcast(P, Pri, Msg) end).
 
diff --git a/src/rabbit_router.erl b/src/rabbit_router.erl
index ea16bb40..098782e7 100644
--- a/src/rabbit_router.erl
+++ b/src/rabbit_router.erl
@@ -56,7 +56,7 @@ 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:invoke_async(
+    delegate:invoke_no_return(
       QPids, fun(Pid) -> rabbit_amqqueue:deliver(Pid, Delivery) end),
     {routed, QPids};
 
diff --git a/src/rabbit_tests.erl b/src/rabbit_tests.erl
index f66b8cec..2ad78793 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:invoke_async(spawn(Responder), Sender),
-    ok = delegate:invoke_async(spawn(SecondaryNode, Responder), Sender),
+    ok = delegate:invoke_no_return(spawn(Responder), Sender),
+    ok = delegate:invoke_no_return(spawn(SecondaryNode, Responder), Sender),
     await_response(2),
 
     LocalPids = spawn_responders(node(), Responder, 10),
     RemotePids = spawn_responders(SecondaryNode, Responder, 10),
-    ok = delegate:invoke_async(LocalPids ++ RemotePids, Sender),
+    ok = delegate:invoke_no_return(LocalPids ++ RemotePids, Sender),
     await_response(20),
 
     passed.