Support gen_server via tuples with scopes.

src/syn.erl

@@ -199,7 +199,9 @@ register(NameOrScope, PidOrName, MetaOrPid) ->
 %% When a process gets registered, Syn will automatically monitor it. You may also register the same process with different names.
 %%
 %% Processes can also be registered as `gen_server' names, by usage of via-tuples. This way, you can use the `gen_server'
-%% API with these tuples without referring to the Pid directly.
+%% API with these tuples without referring to the Pid directly. If you do so, you MUST use a `gen_server' name
+%% in format `{Scope, Name}', i.e. your via tuple will look like `{via, syn, {my_scope, <<"process name">>}}'.
+%% See here below for examples.
 %%
 %% <h2>Examples</h2>
 %% <h3>Elixir</h3>
@@ -212,8 +214,8 @@ register(NameOrScope, PidOrName, MetaOrPid) ->
 %% {#PID<0.105.0>, [meta: :one]}
 %% '''
 %% ```
-%% iex> tuple = {:via, :syn, <<"your process name">>}.
-%% :ok
+%% iex> tuple = {:via, :syn, {:default, <<"your process name">>}}.
+%% {:via, :syn, {:default, <<"your process name">>}}
 %% iex> GenServer.start_link(__MODULE__, [], name: tuple)
 %% {ok, #PID<0.105.0>}
 %% iex> GenServer.call(tuple, :your_message).
@@ -229,8 +231,8 @@ register(NameOrScope, PidOrName, MetaOrPid) ->
 %% {<0.79.0>, [{meta, one}]}
 %% '''
 %% ```
-%% 1> Tuple = {via, syn, <<"your process name">>}.
-%% ok
+%% 1> Tuple = {via, syn, {default, <<"your process name">>}}.
+%% {via, syn, {default, <<"your process name">>}}
 %% 2> gen_server:start_link(Tuple, your_module, []).
 %% {ok, <0.79.0>}
 %% 3> gen_server:call(Tuple, your_message).
@@ -306,31 +308,31 @@ local_registry_count(Scope) ->
 
 %% ----- \/ gen_server via module interface --------------------------
 -spec register_name(Name :: any(), Pid :: pid()) -> yes | no.
-register_name(Name, Pid) ->
-    case syn_registry:register(Name, Pid) of
+register_name({Scope, Name}, Pid) ->
+    case syn_registry:register(Scope, Name, Pid) of
         ok -> yes;
         _ -> no
     end.
 
 -spec unregister_name(Name :: any()) -> any().
-unregister_name(Name) ->
-    case syn_registry:unregister(Name) of
+unregister_name({Scope, Name}) ->
+    case syn_registry:unregister(Scope, Name) of
         ok -> Name;
         _ -> nil
     end.
 
 -spec whereis_name(Name :: any()) -> pid() | undefined.
-whereis_name(Name) ->
-    case syn_registry:lookup(Name) of
+whereis_name({Scope, Name}) ->
+    case syn_registry:lookup(Scope, Name) of
         {Pid, _Meta} -> Pid;
         undefined -> undefined
     end.
 
 -spec send(Name :: any(), Message :: any()) -> pid().
-send(Name, Message) ->
-    case whereis_name(Name) of
+send({Scope, Name}, Message) ->
+    case whereis_name({Scope, Name}) of
         undefined ->
-            {badarg, {Name, Message}};
+            {badarg, {{Scope, Name}, Message}};
         Pid ->
             Pid ! Message,
             Pid

test/syn_registry_SUITE.erl

@@ -187,26 +187,56 @@ end_per_testcase(_, _Config) ->
 one_node_via_register_unregister(_Config) ->
     %% start syn
     ok = syn:start(),
+
+    %% ---> default scope
+    %% start gen server via syn
+    GenServerName = {default, <<"my proc">>},
+    Tuple = {via, syn, GenServerName},
+    {ok, Pid} = syn_test_gen_server:start_link(Tuple),
+    %% retrieve
+    {Pid, undefined} = syn:lookup(<<"my proc">>),
+    %% call
+    pong = syn_test_gen_server:ping(Tuple),
+    %% send via syn
+    syn:send(GenServerName, {self(), send_ping}),
+    syn_test_suite_helper:assert_received_messages([
+        reply_pong
+    ]),
+    %% stop server
+    syn_test_gen_server:stop(Tuple),
+    %% retrieve
+    syn_test_suite_helper:assert_wait(
+        undefined,
+        fun() -> syn:lookup(<<"my proc">>) end
+    ),
+    %% send via syn
+    {badarg, {GenServerName, anything}} = catch syn:send(GenServerName, anything),
+
+    %% ---> custom scope
+    syn:add_node_to_scope(custom_scope),
+
     %% start gen server via syn
-    {ok, Pid} = syn_test_gen_server:start_link(),
+    GenServerNameCustom = {custom_scope, <<"my proc">>},
+    TupleCustom = {via, syn, GenServerNameCustom},
+    {ok, PidCustom} = syn_test_gen_server:start_link(TupleCustom),
     %% retrieve
-    {Pid, undefined} = syn:lookup(syn_test_gen_server),
+    {PidCustom, undefined} = syn:lookup(custom_scope, <<"my proc">>),
     %% call
-    pong = syn_test_gen_server:ping(),
+    pong = syn_test_gen_server:ping(TupleCustom),
     %% send via syn
-    syn:send(syn_test_gen_server, {self(), send_ping}),
+    syn:send(GenServerNameCustom, {self(), send_ping}),
     syn_test_suite_helper:assert_received_messages([
         reply_pong
     ]),
     %% stop server
-    syn_test_gen_server:stop(),
+    syn_test_gen_server:stop(TupleCustom),
     %% retrieve
     syn_test_suite_helper:assert_wait(
         undefined,
-        fun() -> syn:lookup(syn_test_gen_server) end
+        fun() -> syn:lookup(custom_scope, <<"my proc">>) end
     ),
     %% send via syn
-    {badarg, {syn_test_gen_server, anything}} = catch syn:send(syn_test_gen_server, anything).
+    {badarg, {GenServerNameCustom, anything}} = catch syn:send(GenServerNameCustom, anything).
 
 three_nodes_discover_default_scope(Config) ->
     %% get slaves

test/syn_test_gen_server.erl

@@ -27,21 +27,21 @@
 -behaviour(gen_server).
 
 %% API
--export([start_link/0]).
--export([ping/0]).
--export([stop/0]).
+-export([start_link/1]).
+-export([ping/1]).
+-export([stop/1]).
 
 %% gen_server callbacks
 -export([init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2, code_change/3]).
 
-start_link() ->
-    gen_server:start_link({via, syn, ?MODULE}, ?MODULE, [], []).
+start_link(Tuple) ->
+    gen_server:start_link(Tuple, ?MODULE, [], []).
 
-ping() ->
-    gen_server:call({via, syn, ?MODULE}, ping).
+ping(Tuple) ->
+    gen_server:call(Tuple, ping).
 
-stop() ->
-    gen_server:cast({via, syn, ?MODULE}, stop).
+stop(Tuple) ->
+    gen_server:cast(Tuple, stop).
 
 init(State) ->
     {ok, State}.