Rename delegate_{sync,async} to delegate_{call,cast}.

3 files changed, 24 insertions, 24 deletions

diff --git a/src/delegate.erl b/src/delegate.erl
index d469e464..c72a7e5a 100644
--- a/src/delegate.erl
+++ b/src/delegate.erl
@@ -34,7 +34,7 @@
 
 -behaviour(gen_server2).
 
--export([start_link/1, delegate_async/2, delegate_sync/2, server/1]).
+-export([start_link/1, delegate_cast/2, delegate_call/2, server/1]).
 
 -export([init/1, handle_call/3, handle_cast/2, handle_info/2,
          terminate/2, code_change/3]).
@@ -46,30 +46,30 @@ start_link(Hash) ->
     gen_server2:start_link({local, server(Hash)},
                            ?MODULE, [], []).
 
-delegate_sync(Node, Thunk) when is_atom(Node) ->
+delegate_call(Node, Thunk) when is_atom(Node) ->
     gen_server2:call({server(), Node}, {thunk, Thunk}, infinity);
 
-delegate_sync(Pid, FPid) when is_pid(Pid) ->
+delegate_call(Pid, FPid) when is_pid(Pid) ->
     [[{Status, Res, _}]] = delegate_per_node([{node(Pid), [Pid]}],
-                                             f_pid_node(fun delegate_sync/2, FPid)),
+                                             f_pid_node(fun delegate_call/2, FPid)),
     {Status, Res};
 
-delegate_sync(Pids, FPid) when is_list(Pids) ->
+delegate_call(Pids, FPid) when is_list(Pids) ->
     lists:flatten(
         delegate_per_node(split_per_node(Pids),
-                          f_pid_node(fun delegate_sync/2, FPid))).
+                          f_pid_node(fun delegate_call/2, FPid))).
 
-delegate_async(Node, Thunk) when is_atom(Node) ->
+delegate_cast(Node, Thunk) when is_atom(Node) ->
     gen_server2:cast({server(), Node}, {thunk, Thunk});
 
-delegate_async(Pid, FPid) when is_pid(Pid) ->
+delegate_cast(Pid, FPid) when is_pid(Pid) ->
     delegate_per_node([{node(Pid), [Pid]}],
-                      f_pid_node(fun delegate_async/2, FPid)),
+                      f_pid_node(fun delegate_cast/2, FPid)),
     ok;
 
-delegate_async(Pids, FPid) when is_list(Pids) ->
+delegate_cast(Pids, FPid) when is_list(Pids) ->
     delegate_per_node(split_per_node(Pids),
-                      f_pid_node(fun delegate_async/2, FPid)),
+                      f_pid_node(fun delegate_cast/2, FPid)),
     ok.
 
 %%----------------------------------------------------------------------------
diff --git a/src/rabbit_router.erl b/src/rabbit_router.erl
index a8cffbdf..8c4da5f3 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:delegate_async(QPids,
+    delegate:delegate_cast(QPids,
         fun(Pid) -> rabbit_amqqueue:deliver(Pid, Delivery) end),
     {routed, QPids};
 
 deliver(QPids, Delivery) ->
-    Res = delegate:delegate_sync(QPids,
+    Res = delegate:delegate_call(QPids,
         fun(Pid) -> rabbit_amqqueue:deliver(Pid, Delivery) end),
     {Routed, Handled} =
         lists:foldl(fun fold_deliveries/2, {false, []}, Res),
diff --git a/src/rabbit_tests.erl b/src/rabbit_tests.erl
index c4024831..297803f9 100644
--- a/src/rabbit_tests.erl
+++ b/src/rabbit_tests.erl
@@ -830,13 +830,13 @@ test_delegates_async() ->
         end
     end,
 
-    ok = delegate:delegate_async(spawn(Receiver), Sender),
-    ok = delegate:delegate_async(spawn(SecondaryNode, Receiver), Sender),
+    ok = delegate:delegate_cast(spawn(Receiver), Sender),
+    ok = delegate:delegate_cast(spawn(SecondaryNode, Receiver), Sender),
     await_response(2),
 
     LocalPids = [spawn(Receiver) || _ <- lists:seq(1,10)],
     RemotePids = [spawn(SecondaryNode, Receiver) || _ <- lists:seq(1,10)],
-    ok = delegate:delegate_async(LocalPids ++ RemotePids, Sender),
+    ok = delegate:delegate_cast(LocalPids ++ RemotePids, Sender),
     await_response(20),
 
     passed.
@@ -855,8 +855,8 @@ await_response(Count) ->
 
 test_delegates_sync() ->
     SecondaryNode = rabbit_misc:makenode("hare"),
-    {ok, "foo"} = delegate:delegate_sync(node(), fun() -> "foo" end),
-    {ok, "bar"} = delegate:delegate_sync(SecondaryNode, fun() -> "bar" end),
+    {ok, "foo"} = delegate:delegate_call(node(), fun() -> "foo" end),
+    {ok, "bar"} = delegate:delegate_call(SecondaryNode, fun() -> "bar" end),
 
     Sender = fun(Pid) ->
         gen_server2:call(Pid, invoked)
@@ -882,22 +882,22 @@ test_delegates_sync() ->
         end
     end,
 
-    {ok, response} = delegate:delegate_sync(spawn(Responder), Sender),
-    {ok, response} = delegate:delegate_sync(spawn(SecondaryNode, Responder), Sender),
+    {ok, response} = delegate:delegate_call(spawn(Responder), Sender),
+    {ok, response} = delegate:delegate_call(spawn(SecondaryNode, Responder), Sender),
 
-    {error, _} = delegate:delegate_sync(spawn(BadResponder), Sender),
-    {error, _} = delegate:delegate_sync(spawn(SecondaryNode, BadResponder), Sender),
+    {error, _} = delegate:delegate_call(spawn(BadResponder), Sender),
+    {error, _} = delegate:delegate_call(spawn(SecondaryNode, BadResponder), Sender),
 
     LocalGoodPids = [spawn(Responder) || _ <- lists:seq(1,2)],
     RemoteGoodPids = [spawn(Responder) || _ <- lists:seq(1,2)],
     LocalBadPids = [spawn(SecondaryNode, BadResponder) || _ <- lists:seq(1,2)],
     RemoteBadPids = [spawn(SecondaryNode, BadResponder) || _ <- lists:seq(1,2)],
 
-    GoodRes = delegate:delegate_sync(LocalGoodPids ++ RemoteGoodPids, Sender),
+    GoodRes = delegate:delegate_call(LocalGoodPids ++ RemoteGoodPids, Sender),
     [{ok, response, _}, {ok, response, _},
      {ok, response, _}, {ok, response, _}] = GoodRes,
 
-    BadRes = delegate:delegate_sync(LocalBadPids ++ RemoteBadPids, Sender),
+    BadRes = delegate:delegate_call(LocalBadPids ++ RemoteBadPids, Sender),
     [{error, _, _}, {error, _, _},
      {error, _, _}, {error, _, _}] = BadRes,