Rename global to registry and pg to groups for clarity.

include/syn.hrl

@@ -24,13 +24,13 @@
 %% THE SOFTWARE.
 %% ==========================================================================================================
 %% records
--record(syn_global_table, {
+-record(syn_registry_table, {
     key = undefined :: any(),
     pid = undefined :: undefined | pid() | atom(),
     node = undefined :: atom(),
     meta = undefined :: any()
 }).
--record(syn_pg_table, {
+-record(syn_groups_table, {
     name = undefined :: any(),
     pid = undefined :: undefined | pid() | atom(),
     node = undefined :: atom()

src/syn.app.src

@@ -4,8 +4,8 @@
         {vsn, "1.0.0"},
         {registered, [
             syn_consistency,
-            syn_global,
-            syn_pg
+            syn_registry,
+            syn_groups
         ]},
         {applications, [
             kernel,

src/syn.erl

@@ -1,5 +1,5 @@
 %% ==========================================================================================================
-%% Syn - A global process registry.
+%% Syn - A global Process Registry and Process Group manager.
 %%
 %% The MIT License (MIT)
 %%
@@ -29,14 +29,14 @@
 -export([start/0, stop/0]).
 -export([init/0]).
 
-%% global
+%% registry
 -export([register/2, register/3]).
 -export([unregister/1]).
 -export([find_by_key/1, find_by_key/2]).
 -export([find_by_pid/1, find_by_pid/2]).
 -export([registry_count/0, registry_count/1]).
 
-%% PG
+%% groups
 -export([join/2]).
 -export([leave/2]).
 -export([member/2]).
@@ -62,59 +62,59 @@ init() ->
 
 -spec register(Key :: any(), Pid :: pid()) -> ok | {error, taken | pid_already_registered}.
 register(Key, Pid) ->
-    syn_global:register(Key, Pid).
+    syn_registry:register(Key, Pid).
 
 -spec register(Key :: any(), Pid :: pid(), Meta :: any()) -> ok | {error, taken | pid_already_registered}.
 register(Key, Pid, Meta) ->
-    syn_global:register(Key, Pid, Meta).
+    syn_registry:register(Key, Pid, Meta).
 
 -spec unregister(Key :: any()) -> ok | {error, undefined}.
 unregister(Key) ->
-    syn_global:unregister(Key).
+    syn_registry:unregister(Key).
 
 -spec find_by_key(Key :: any()) -> pid() | undefined.
 find_by_key(Key) ->
-    syn_global:find_by_key(Key).
+    syn_registry:find_by_key(Key).
 
 -spec find_by_key(Key :: any(), with_meta) -> {pid(), Meta :: any()} | undefined.
 find_by_key(Key, with_meta) ->
-    syn_global:find_by_key(Key, with_meta).
+    syn_registry:find_by_key(Key, with_meta).
 
 -spec find_by_pid(Pid :: pid()) -> Key :: any() | undefined.
 find_by_pid(Pid) ->
-    syn_global:find_by_pid(Pid).
+    syn_registry:find_by_pid(Pid).
 
 -spec find_by_pid(Pid :: pid(), with_meta) -> {Key :: any(), Meta :: any()} | undefined.
 find_by_pid(Pid, with_meta) ->
-    syn_global:find_by_pid(Pid, with_meta).
+    syn_registry:find_by_pid(Pid, with_meta).
 
 -spec registry_count() -> non_neg_integer().
 registry_count() ->
-    syn_global:count().
+    syn_registry:count().
 
 -spec registry_count(Node :: atom()) -> non_neg_integer().
 registry_count(Node) ->
-    syn_global:count(Node).
+    syn_registry:count(Node).
 
 -spec join(Name :: any(), Pid :: pid()) -> ok | {error, pid_already_in_group}.
 join(Name, Pid) ->
-    syn_pg:join(Name, Pid).
+    syn_groups:join(Name, Pid).
 
 -spec leave(Name :: any(), Pid :: pid()) -> ok | {error, undefined | pid_not_in_group}.
 leave(Name, Pid) ->
-    syn_pg:leave(Name, Pid).
+    syn_groups:leave(Name, Pid).
 
 -spec member(Pid :: pid(), Name :: any()) -> boolean().
 member(Pid, Name) ->
-    syn_pg:member(Pid, Name).
+    syn_groups:member(Pid, Name).
 
 -spec get_members(Name :: any()) -> [pid()].
 get_members(Name) ->
-    syn_pg:get_members(Name).
+    syn_groups:get_members(Name).
 
 -spec publish(Name :: any(), Message :: any()) -> {ok, RecipientCount :: non_neg_integer()}.
 publish(Name, Message) ->
-    syn_pg:publish(Name, Message).
+    syn_groups:publish(Name, Message).
 
 %% ===================================================================
 %% Internal

src/syn_backbone.erl

@@ -42,18 +42,18 @@ initdb() ->
     ClusterNodes = [node() | nodes()],
     mnesia:change_config(extra_db_nodes, ClusterNodes),
     %% create tables
-    create_table(syn_global_table, [
+    create_table(syn_registry_table, [
         {type, set},
         {ram_copies, ClusterNodes},
-        {attributes, record_info(fields, syn_global_table)},
-        {index, [#syn_global_table.pid]},
+        {attributes, record_info(fields, syn_registry_table)},
+        {index, [#syn_registry_table.pid]},
         {storage_properties, [{ets, [{read_concurrency, true}]}]}
     ]),
-    create_table(syn_pg_table, [
+    create_table(syn_groups_table, [
         {type, bag},
         {ram_copies, ClusterNodes},
-        {attributes, record_info(fields, syn_pg_table)},
-        {index, [#syn_pg_table.pid]},
+        {attributes, record_info(fields, syn_groups_table)},
+        {index, [#syn_groups_table.pid]},
         {storage_properties, [{ets, [{read_concurrency, true}]}]}
     ]).
 

src/syn_consistency.erl

@@ -169,21 +169,21 @@ code_change(_OldVsn, State, _Extra) ->
 -spec delete_global_pids_of_disconnected_node(RemoteNode :: atom()) -> ok.
 delete_global_pids_of_disconnected_node(RemoteNode) ->
     %% build match specs
-    MatchHead = #syn_global_table{key = '$1', node = '$2', _ = '_'},
+    MatchHead = #syn_registry_table{key = '$1', node = '$2', _ = '_'},
     Guard = {'=:=', '$2', RemoteNode},
     IdFormat = '$1',
     %% delete
-    DelF = fun(Id) -> mnesia:dirty_delete({syn_global_table, Id}) end,
-    NodePids = mnesia:dirty_select(syn_global_table, [{MatchHead, [Guard], [IdFormat]}]),
+    DelF = fun(Id) -> mnesia:dirty_delete({syn_registry_table, Id}) end,
+    NodePids = mnesia:dirty_select(syn_registry_table, [{MatchHead, [Guard], [IdFormat]}]),
     lists:foreach(DelF, NodePids).
 
 -spec delete_pg_pids_of_disconnected_node(RemoteNode :: atom()) -> ok.
 delete_pg_pids_of_disconnected_node(RemoteNode) ->
     %% build match specs
-    Pattern = #syn_pg_table{node = RemoteNode, _ = '_'},
-    ObjectsToDelete = mnesia:dirty_match_object(syn_pg_table, Pattern),
+    Pattern = #syn_groups_table{node = RemoteNode, _ = '_'},
+    ObjectsToDelete = mnesia:dirty_match_object(syn_groups_table, Pattern),
     %% delete
-    DelF = fun(Record) -> mnesia:dirty_delete_object(syn_pg_table, Record) end,
+    DelF = fun(Record) -> mnesia:dirty_delete_object(syn_groups_table, Record) end,
     lists:foreach(DelF, ObjectsToDelete).
 
 -spec automerge(RemoteNode :: atom()) -> ok.
@@ -214,7 +214,7 @@ stitch(RemoteNode) ->
     mnesia_controller:connect_nodes(
         [RemoteNode],
         fun(MergeF) ->
-            catch case MergeF([syn_global_table, syn_pg_table]) of
+            catch case MergeF([syn_registry_table, syn_groups_table]) of
                 {merged, _, _} = Res ->
                     stitch_global_tab(RemoteNode),
                     stitch_pg_tab(RemoteNode),
@@ -257,7 +257,7 @@ purge_double_processes_from_local_mnesia(LocalProcessesInfo, RemoteProcessesInfo
             [] -> Acc;
             [{Key, LocalProcessPid, LocalProcessMeta}] ->
                 %% found a double process, remove it from local mnesia table
-                mnesia:dirty_delete(syn_global_table, Key),
+                mnesia:dirty_delete(syn_registry_table, Key),
                 %% remove it from ETS
                 ets:delete(Tab, Key),
                 %% add it to acc
@@ -287,16 +287,16 @@ write_local_processes_to_remote(RemoteNode, LocalProcessesInfo) ->
 -spec get_processes_info_of_node(Node :: atom()) -> list().
 get_processes_info_of_node(Node) ->
     %% build match specs
-    MatchHead = #syn_global_table{key = '$1', pid = '$2', node = '$3', meta = '$4'},
+    MatchHead = #syn_registry_table{key = '$1', pid = '$2', node = '$3', meta = '$4'},
     Guard = {'=:=', '$3', Node},
     ProcessInfoFormat = {{'$1', '$2', '$4'}},
     %% select
-    mnesia:dirty_select(syn_global_table, [{MatchHead, [Guard], [ProcessInfoFormat]}]).
+    mnesia:dirty_select(syn_registry_table, [{MatchHead, [Guard], [ProcessInfoFormat]}]).
 
 -spec write_processes_info_to_node(Node :: atom(), ProcessesInfo :: list()) -> ok.
 write_processes_info_to_node(Node, ProcessesInfo) ->
     FWrite = fun({Key, ProcessPid, ProcessMeta}) ->
-        mnesia:dirty_write(#syn_global_table{
+        mnesia:dirty_write(#syn_registry_table{
             key = Key,
             pid = ProcessPid,
             node = Node,
@@ -339,11 +339,11 @@ stitch_pg_tab(RemoteNode) ->
 -spec get_pgs_info_of_node(Node :: atom()) -> list().
 get_pgs_info_of_node(Node) ->
     %% build match specs
-    MatchHead = #syn_pg_table{name = '$1', pid = '$2', node = '$3'},
+    MatchHead = #syn_groups_table{name = '$1', pid = '$2', node = '$3'},
     Guard = {'=:=', '$3', Node},
     PgInfoFormat = {{'$1', '$2'}},
     %% select
-    mnesia:dirty_select(syn_pg_table, [{MatchHead, [Guard], [PgInfoFormat]}]).
+    mnesia:dirty_select(syn_groups_table, [{MatchHead, [Guard], [PgInfoFormat]}]).
 
 -spec write_remote_pgs_to_local(RemoteNode :: atom(), RemotePgsInfo :: list()) -> ok.
 write_remote_pgs_to_local(RemoteNode, RemotePgsInfo) ->
@@ -356,7 +356,7 @@ write_local_pgs_to_remote(RemoteNode, LocalPgsInfo) ->
 -spec write_pgs_info_to_node(Node :: atom(), PgsInfo :: list()) -> ok.
 write_pgs_info_to_node(Node, PgsInfo) ->
     FWrite = fun({Name, Pid}) ->
-        mnesia:dirty_write(#syn_pg_table{
+        mnesia:dirty_write(#syn_groups_table{
             name = Name,
             pid = Pid,
             node = Node

src/syn_pg.erl → src/syn_groups.erl

@@ -23,7 +23,7 @@
 %% OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 %% THE SOFTWARE.
 %% ==========================================================================================================
--module(syn_pg).
+-module(syn_groups).
 
 %% API
 -export([start_link/0]).
@@ -61,10 +61,10 @@ leave(Name, Pid) ->
     case i_find_by_pid(Pid) of
         undefined ->
             {error, undefined};
-        Process when Process#syn_pg_table.name =/= Name ->
+        Process when Process#syn_groups_table.name =/= Name ->
             {error, pid_not_in_group};
         Process ->
-            Node = Process#syn_pg_table.node,
+            Node = Process#syn_groups_table.node,
             gen_server:call({?MODULE, Node}, {leave, Name, Pid})
     end.
 
@@ -119,7 +119,7 @@ handle_call({join, Name, Pid}, _From, State) ->
     case i_member(Pid, Name) of
         false ->
             %% add to table
-            mnesia:dirty_write(#syn_pg_table{
+            mnesia:dirty_write(#syn_groups_table{
                 name = Name,
                 pid = Pid,
                 node = node()
@@ -137,7 +137,7 @@ handle_call({leave, Name, Pid}, _From, State) ->
     case i_find_by_pid(Pid) of
         undefined ->
             {reply, {error, undefined}, State};
-        Process when Process#syn_pg_table.name =/= Name ->
+        Process when Process#syn_groups_table.name =/= Name ->
             {error, pid_not_in_group};
         Process ->
             %% remove from table
@@ -186,7 +186,7 @@ handle_info({'EXIT', Pid, Reason}, State) ->
 
         Process ->
             %% get pg
-            Name = Process#syn_pg_table.name,
+            Name = Process#syn_groups_table.name,
             %% log
             case Reason of
                 normal -> ok;
@@ -226,29 +226,29 @@ code_change(_OldVsn, State, _Extra) ->
 -spec i_member(Pid :: pid(), Name :: any()) -> boolean().
 i_member(Pid, Name) ->
     %% build match specs
-    MatchHead = #syn_pg_table{name = '$1', pid = '$2', _ = '_'},
+    MatchHead = #syn_groups_table{name = '$1', pid = '$2', _ = '_'},
     Guards = [{'=:=', '$1', Name}, {'=:=', '$2', Pid}],
     Result = '$2',
     %% select
-    case mnesia:dirty_select(syn_pg_table, [{MatchHead, Guards, [Result]}]) of
+    case mnesia:dirty_select(syn_groups_table, [{MatchHead, Guards, [Result]}]) of
         [] -> false;
         _ -> true
     end.
 
--spec i_get_members(Name :: any()) -> [Process :: #syn_pg_table{}].
+-spec i_get_members(Name :: any()) -> [Process :: #syn_groups_table{}].
 i_get_members(Name) ->
-    Processes = mnesia:dirty_read(syn_pg_table, Name),
+    Processes = mnesia:dirty_read(syn_groups_table, Name),
     lists:map(fun(Process) ->
-        Process#syn_pg_table.pid
+        Process#syn_groups_table.pid
     end, Processes).
 
--spec i_find_by_pid(Pid :: pid()) -> Process :: #syn_pg_table{} | undefined.
+-spec i_find_by_pid(Pid :: pid()) -> Process :: #syn_groups_table{} | undefined.
 i_find_by_pid(Pid) ->
-    case mnesia:dirty_index_read(syn_pg_table, Pid, #syn_pg_table.pid) of
+    case mnesia:dirty_index_read(syn_groups_table, Pid, #syn_groups_table.pid) of
         [Process] -> Process;
         _ -> undefined
     end.
 
--spec remove_process(Process :: #syn_pg_table{}) -> ok.
+-spec remove_process(Process :: #syn_groups_table{}) -> ok.
 remove_process(Process) ->
-    mnesia:dirty_delete_object(syn_pg_table, Process).
+    mnesia:dirty_delete_object(syn_groups_table, Process).

src/syn_global.erl → src/syn_registry.erl

@@ -23,7 +23,7 @@
 %% OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 %% THE SOFTWARE.
 %% ==========================================================================================================
--module(syn_global).
+-module(syn_registry).
 
 %% API
 -export([start_link/0]).
@@ -58,28 +58,28 @@ start_link() ->
 find_by_key(Key) ->
     case i_find_by_key(on_connected_node, Key) of
         undefined -> undefined;
-        Process -> Process#syn_global_table.pid
+        Process -> Process#syn_registry_table.pid
     end.
 
 -spec find_by_key(Key :: any(), with_meta) -> {pid(), Meta :: any()} | undefined.
 find_by_key(Key, with_meta) ->
     case i_find_by_key(on_connected_node, Key) of
         undefined -> undefined;
-        Process -> {Process#syn_global_table.pid, Process#syn_global_table.meta}
+        Process -> {Process#syn_registry_table.pid, Process#syn_registry_table.meta}
     end.
 
 -spec find_by_pid(Pid :: pid()) -> Key :: any() | undefined.
 find_by_pid(Pid) ->
     case i_find_by_pid(on_connected_node, Pid) of
         undefined -> undefined;
-        Process -> Process#syn_global_table.key
+        Process -> Process#syn_registry_table.key
     end.
 
 -spec find_by_pid(Pid :: pid(), with_meta) -> {Key :: any(), Meta :: any()} | undefined.
 find_by_pid(Pid, with_meta) ->
     case i_find_by_pid(on_connected_node, Pid) of
         undefined -> undefined;
-        Process -> {Process#syn_global_table.key, Process#syn_global_table.meta}
+        Process -> {Process#syn_registry_table.key, Process#syn_registry_table.meta}
     end.
 
 -spec register(Key :: any(), Pid :: pid()) -> ok | {error, taken | pid_already_registered}.
@@ -97,22 +97,22 @@ unregister(Key) ->
         undefined ->
             {error, undefined};
         Process ->
-            Node = Process#syn_global_table.node,
+            Node = Process#syn_registry_table.node,
             gen_server:call({?MODULE, Node}, {unregister_on_node, Key})
     end.
 
 -spec count() -> non_neg_integer().
 count() ->
-    mnesia:table_info(syn_global_table, size).
+    mnesia:table_info(syn_registry_table, size).
 
 -spec count(Node :: atom()) -> non_neg_integer().
 count(Node) ->
     %% build match specs
-    MatchHead = #syn_global_table{node = '$2', _ = '_'},
+    MatchHead = #syn_registry_table{node = '$2', _ = '_'},
     Guard = {'=:=', '$2', Node},
     Result = '$2',
     %% select
-    Processes = mnesia:dirty_select(syn_global_table, [{MatchHead, [Guard], [Result]}]),
+    Processes = mnesia:dirty_select(syn_registry_table, [{MatchHead, [Guard], [Result]}]),
     length(Processes).
 
 %% ===================================================================
@@ -162,7 +162,7 @@ handle_call({register_on_node, Key, Pid, Meta}, _From, State) ->
             case i_find_by_pid(Pid) of
                 undefined ->
                     %% add to table
-                    mnesia:dirty_write(#syn_global_table{
+                    mnesia:dirty_write(#syn_registry_table{
                         key = Key,
                         pid = Pid,
                         node = node(),
@@ -188,7 +188,7 @@ handle_call({unregister_on_node, Key}, _From, State) ->
             %% remove from table
             remove_process_by_key(Key),
             %% unlink
-            Pid = Process#syn_global_table.pid,
+            Pid = Process#syn_registry_table.pid,
             erlang:unlink(Pid),
             %% reply
             {reply, ok, State}
@@ -244,8 +244,8 @@ handle_info({'EXIT', Pid, Reason}, #state{
 
             Process ->
                 %% get process info
-                Key0 = Process#syn_global_table.key,
-                Meta0 = Process#syn_global_table.meta,
+                Key0 = Process#syn_registry_table.key,
+                Meta0 = Process#syn_registry_table.meta,
 
                 %% log
                 case Reason of
@@ -294,41 +294,41 @@ code_change(_OldVsn, State, _Extra) ->
 %% ===================================================================
 %% Internal
 %% ===================================================================
--spec i_find_by_key(on_connected_node, Key :: any()) -> Process :: #syn_global_table{} | undefined.
+-spec i_find_by_key(on_connected_node, Key :: any()) -> Process :: #syn_registry_table{} | undefined.
 i_find_by_key(on_connected_node, Key) ->
     case i_find_by_key(Key) of
         undefined -> undefined;
         Process -> return_if_on_connected_node(Process)
     end.
 
--spec i_find_by_key(Key :: any()) -> Process :: #syn_global_table{} | undefined.
+-spec i_find_by_key(Key :: any()) -> Process :: #syn_registry_table{} | undefined.
 i_find_by_key(Key) ->
-    case mnesia:dirty_read(syn_global_table, Key) of
+    case mnesia:dirty_read(syn_registry_table, Key) of
         [Process] -> Process;
         _ -> undefined
     end.
 
--spec i_find_by_pid(on_connected_node, Pid :: pid()) -> Process :: #syn_global_table{} | undefined.
+-spec i_find_by_pid(on_connected_node, Pid :: pid()) -> Process :: #syn_registry_table{} | undefined.
 i_find_by_pid(on_connected_node, Pid) ->
     case i_find_by_pid(Pid) of
         undefined -> undefined;
         Process -> return_if_on_connected_node(Process)
     end.
 
--spec i_find_by_pid(Pid :: pid()) -> Process :: #syn_global_table{} | undefined.
+-spec i_find_by_pid(Pid :: pid()) -> Process :: #syn_registry_table{} | undefined.
 i_find_by_pid(Pid) ->
-    case mnesia:dirty_index_read(syn_global_table, Pid, #syn_global_table.pid) of
+    case mnesia:dirty_index_read(syn_registry_table, Pid, #syn_registry_table.pid) of
         [Process] -> Process;
         _ -> undefined
     end.
 
--spec return_if_on_connected_node(Process :: #syn_global_table{}) -> Process :: #syn_global_table{} | undefined.
+-spec return_if_on_connected_node(Process :: #syn_registry_table{}) -> Process :: #syn_registry_table{} | undefined.
 return_if_on_connected_node(Process) ->
-    case lists:member(Process#syn_global_table.node, [node() | nodes()]) of
+    case lists:member(Process#syn_registry_table.node, [node() | nodes()]) of
         true -> Process;
         _ -> undefined
     end.
 
 -spec remove_process_by_key(Key :: any()) -> ok.
 remove_process_by_key(Key) ->
-    mnesia:dirty_delete(syn_global_table, Key).
+    mnesia:dirty_delete(syn_registry_table, Key).

src/syn_sup.erl

@@ -50,8 +50,8 @@ start_link() ->
     {ok, {{supervisor:strategy(), non_neg_integer(), pos_integer()}, [supervisor:child_spec()]}}.
 init([]) ->
     Children = [
-        ?CHILD(syn_global, worker),
-        ?CHILD(syn_pg, worker),
+        ?CHILD(syn_registry, worker),
+        ?CHILD(syn_groups, worker),
         ?CHILD(syn_consistency, worker)
     ],
     {ok, {{one_for_one, 10, 10}, Children}}.

test/syn-test.config

@@ -10,7 +10,7 @@
         %% You can set a callback to be triggered when a process exits.
         %% This callback will be called only on the node where the process was running.
 
-        {process_exit_callback, [syn_register_processes_SUITE, process_exit_callback_dummy]},
+        {process_exit_callback, [syn_registry_SUITE, process_exit_callback_dummy]},
 
         %% After a net split, when nodes reconnect, Syn will merge the data from all the nodes in the cluster.
         %% If the same Key was used to register a process on different nodes during a net split, then there will be a conflict.

test/syn_create_mnesia_SUITE.erl

@@ -178,7 +178,7 @@ single_node_when_mnesia_is_ram(_Config) ->
     ok = syn:start(),
     ok = syn:init(),
     %% check table exists
-    true = lists:member(syn_global_table, mnesia:system_info(tables)).
+    true = lists:member(syn_registry_table, mnesia:system_info(tables)).
 
 single_node_when_mnesia_is_opt_disc_no_schema_exists(_Config) ->
     %% set schema location
@@ -187,7 +187,7 @@ single_node_when_mnesia_is_opt_disc_no_schema_exists(_Config) ->
     ok = syn:start(),
     ok = syn:init(),
     %% check table exists
-    true = lists:member(syn_global_table, mnesia:system_info(tables)).
+    true = lists:member(syn_registry_table, mnesia:system_info(tables)).
 
 single_node_when_mnesia_is_opt_disc_schema_exists(_Config) ->
     %% set schema location
@@ -198,7 +198,7 @@ single_node_when_mnesia_is_opt_disc_schema_exists(_Config) ->
     ok = syn:start(),
     ok = syn:init(),
     %% check table exists
-    true = lists:member(syn_global_table, mnesia:system_info(tables)).
+    true = lists:member(syn_registry_table, mnesia:system_info(tables)).
 
 single_node_when_mnesia_is_disc(_Config) ->
     %% set schema location
@@ -209,7 +209,7 @@ single_node_when_mnesia_is_disc(_Config) ->
     ok = syn:start(),
     ok = syn:init(),
     %% check table exists
-    true = lists:member(syn_global_table, mnesia:system_info(tables)).
+    true = lists:member(syn_registry_table, mnesia:system_info(tables)).
 
 two_nodes_when_mnesia_is_ram(Config) ->
     %% get slave
@@ -224,10 +224,10 @@ two_nodes_when_mnesia_is_ram(Config) ->
     ok = rpc:call(SlaveNode, syn, init, []),
     timer:sleep(100),
     %% check table exists on local
-    true = lists:member(syn_global_table, mnesia:system_info(tables)),
+    true = lists:member(syn_registry_table, mnesia:system_info(tables)),
     %% check table exists on remote
     SlaveNodeMnesiaSystemInfo = rpc:call(SlaveNode, mnesia, system_info, [tables]),
-    true = rpc:call(SlaveNode, lists, member, [syn_global_table, SlaveNodeMnesiaSystemInfo]).
+    true = rpc:call(SlaveNode, lists, member, [syn_registry_table, SlaveNodeMnesiaSystemInfo]).
 
 two_nodes_when_mnesia_is_opt_disc_no_schema_exists(Config) ->
     %% get slave
@@ -242,10 +242,10 @@ two_nodes_when_mnesia_is_opt_disc_no_schema_exists(Config) ->
     ok = rpc:call(SlaveNode, syn, init, []),
     timer:sleep(100),
     %% check table exists on local
-    true = lists:member(syn_global_table, mnesia:system_info(tables)),
+    true = lists:member(syn_registry_table, mnesia:system_info(tables)),
     %% check table exists on remote
     SlaveNodeMnesiaSystemInfo = rpc:call(SlaveNode, mnesia, system_info, [tables]),
-    true = rpc:call(SlaveNode, lists, member, [syn_global_table, SlaveNodeMnesiaSystemInfo]).
+    true = rpc:call(SlaveNode, lists, member, [syn_registry_table, SlaveNodeMnesiaSystemInfo]).
 
 two_nodes_when_mnesia_is_opt_disc_schema_exists(Config) ->
     %% get slave
@@ -262,10 +262,10 @@ two_nodes_when_mnesia_is_opt_disc_schema_exists(Config) ->
     ok = rpc:call(SlaveNode, syn, init, []),
     timer:sleep(100),
     %% check table exists on local
-    true = lists:member(syn_global_table, mnesia:system_info(tables)),
+    true = lists:member(syn_registry_table, mnesia:system_info(tables)),
     %% check table exists on remote
     SlaveNodeMnesiaSystemInfo = rpc:call(SlaveNode, mnesia, system_info, [tables]),
-    true = rpc:call(SlaveNode, lists, member, [syn_global_table, SlaveNodeMnesiaSystemInfo]).
+    true = rpc:call(SlaveNode, lists, member, [syn_registry_table, SlaveNodeMnesiaSystemInfo]).
 
 two_nodes_when_mnesia_is_disc(Config) ->
     %% get slave
@@ -282,7 +282,7 @@ two_nodes_when_mnesia_is_disc(Config) ->
     ok = rpc:call(SlaveNode, syn, init, []),
     timer:sleep(100),
     %% check table exists on local
-    true = lists:member(syn_global_table, mnesia:system_info(tables)),
+    true = lists:member(syn_registry_table, mnesia:system_info(tables)),
     %% check table exists on remote
     SlaveNodeMnesiaSystemInfo = rpc:call(SlaveNode, mnesia, system_info, [tables]),
-    true = rpc:call(SlaveNode, lists, member, [syn_global_table, SlaveNodeMnesiaSystemInfo]).
+    true = rpc:call(SlaveNode, lists, member, [syn_registry_table, SlaveNodeMnesiaSystemInfo]).

test/syn_process_groups_SUITE.erl → test/syn_groups_SUITE.erl

@@ -23,7 +23,7 @@
 %% OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 %% THE SOFTWARE.
 %% ==========================================================================================================
--module(syn_process_groups_SUITE).
+-module(syn_groups_SUITE).
 
 %% callbacks
 -export([all/0]).

test/syn_process_groups_consistency_SUITE.erl → test/syn_groups_consistency_SUITE.erl

@@ -22,7 +22,7 @@
 %% LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 %% OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 %% THE SOFTWARE.
--module(syn_process_groups_consistency_SUITE).
+-module(syn_groups_consistency_SUITE).
 
 %% callbacks
 -export([all/0]).
@@ -179,15 +179,15 @@ two_nodes_netsplit_when_there_are_no_conflicts(Config) ->
     timer:sleep(100),
 
     %% check tables
-    3 = mnesia:table_info(syn_pg_table, size),
-    3 = rpc:call(SlaveNode, mnesia, table_info, [syn_pg_table, size]),
+    3 = mnesia:table_info(syn_groups_table, size),
+    3 = rpc:call(SlaveNode, mnesia, table_info, [syn_groups_table, size]),
 
-    LocalActiveReplicas = mnesia:table_info(syn_pg_table, active_replicas),
+    LocalActiveReplicas = mnesia:table_info(syn_groups_table, active_replicas),
     2 = length(LocalActiveReplicas),
     true = lists:member(SlaveNode, LocalActiveReplicas),
     true = lists:member(CurrentNode, LocalActiveReplicas),
 
-    SlaveActiveReplicas = rpc:call(SlaveNode, mnesia, table_info, [syn_pg_table, active_replicas]),
+    SlaveActiveReplicas = rpc:call(SlaveNode, mnesia, table_info, [syn_groups_table, active_replicas]),
     2 = length(SlaveActiveReplicas),
     true = lists:member(SlaveNode, SlaveActiveReplicas),
     true = lists:member(CurrentNode, SlaveActiveReplicas),
@@ -197,23 +197,23 @@ two_nodes_netsplit_when_there_are_no_conflicts(Config) ->
     timer:sleep(1000),
 
     %% check tables
-    1 = mnesia:table_info(syn_pg_table, size),
-    [CurrentNode] = mnesia:table_info(syn_pg_table, active_replicas),
+    1 = mnesia:table_info(syn_groups_table, size),
+    [CurrentNode] = mnesia:table_info(syn_groups_table, active_replicas),
 
     %% reconnect
     syn_test_suite_helper:connect_node(SlaveNode),
     timer:sleep(1000),
 
     %% check tables
-    3 = mnesia:table_info(syn_pg_table, size),
-    3 = rpc:call(SlaveNode, mnesia, table_info, [syn_pg_table, size]),
+    3 = mnesia:table_info(syn_groups_table, size),
+    3 = rpc:call(SlaveNode, mnesia, table_info, [syn_groups_table, size]),
 
-    LocalActiveReplicasAfter = mnesia:table_info(syn_pg_table, active_replicas),
+    LocalActiveReplicasAfter = mnesia:table_info(syn_groups_table, active_replicas),
     2 = length(LocalActiveReplicasAfter),
     true = lists:member(SlaveNode, LocalActiveReplicasAfter),
     true = lists:member(CurrentNode, LocalActiveReplicasAfter),
 
-    SlaveActiveReplicasAfter = rpc:call(SlaveNode, mnesia, table_info, [syn_pg_table, active_replicas]),
+    SlaveActiveReplicasAfter = rpc:call(SlaveNode, mnesia, table_info, [syn_groups_table, active_replicas]),
     2 = length(SlaveActiveReplicasAfter),
     true = lists:member(SlaveNode, SlaveActiveReplicasAfter),
     true = lists:member(CurrentNode, SlaveActiveReplicasAfter),

test/syn_register_processes_SUITE.erl → test/syn_registry_SUITE.erl

@@ -23,7 +23,7 @@
 %% OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 %% THE SOFTWARE.
 %% ==========================================================================================================
--module(syn_register_processes_SUITE).
+-module(syn_registry_SUITE).
 
 %% callbacks
 -export([all/0]).

test/syn_registry_consistency_SUITE.erl

@@ -207,15 +207,15 @@ two_nodes_netsplit_when_there_are_no_conflicts(Config) ->
     timer:sleep(100),
 
     %% check tables
-    3 = mnesia:table_info(syn_global_table, size),
-    3 = rpc:call(SlaveNode, mnesia, table_info, [syn_global_table, size]),
+    3 = mnesia:table_info(syn_registry_table, size),
+    3 = rpc:call(SlaveNode, mnesia, table_info, [syn_registry_table, size]),
 
-    LocalActiveReplicas = mnesia:table_info(syn_global_table, active_replicas),
+    LocalActiveReplicas = mnesia:table_info(syn_registry_table, active_replicas),
     2 = length(LocalActiveReplicas),
     true = lists:member(SlaveNode, LocalActiveReplicas),
     true = lists:member(CurrentNode, LocalActiveReplicas),
 
-    SlaveActiveReplicas = rpc:call(SlaveNode, mnesia, table_info, [syn_global_table, active_replicas]),
+    SlaveActiveReplicas = rpc:call(SlaveNode, mnesia, table_info, [syn_registry_table, active_replicas]),
     2 = length(SlaveActiveReplicas),
     true = lists:member(SlaveNode, SlaveActiveReplicas),
     true = lists:member(CurrentNode, SlaveActiveReplicas),
@@ -225,23 +225,23 @@ two_nodes_netsplit_when_there_are_no_conflicts(Config) ->
     timer:sleep(1000),
 
     %% check tables
-    1 = mnesia:table_info(syn_global_table, size),
-    [CurrentNode] = mnesia:table_info(syn_global_table, active_replicas),
+    1 = mnesia:table_info(syn_registry_table, size),
+    [CurrentNode] = mnesia:table_info(syn_registry_table, active_replicas),
 
     %% reconnect
     syn_test_suite_helper:connect_node(SlaveNode),
     timer:sleep(1000),
 
     %% check tables
-    3 = mnesia:table_info(syn_global_table, size),
-    3 = rpc:call(SlaveNode, mnesia, table_info, [syn_global_table, size]),
+    3 = mnesia:table_info(syn_registry_table, size),
+    3 = rpc:call(SlaveNode, mnesia, table_info, [syn_registry_table, size]),
 
-    LocalActiveReplicas2 = mnesia:table_info(syn_global_table, active_replicas),
+    LocalActiveReplicas2 = mnesia:table_info(syn_registry_table, active_replicas),
     2 = length(LocalActiveReplicas2),
     true = lists:member(SlaveNode, LocalActiveReplicas2),
     true = lists:member(CurrentNode, LocalActiveReplicas2),
 
-    SlaveActiveReplicas2 = rpc:call(SlaveNode, mnesia, table_info, [syn_global_table, active_replicas]),
+    SlaveActiveReplicas2 = rpc:call(SlaveNode, mnesia, table_info, [syn_registry_table, active_replicas]),
     2 = length(SlaveActiveReplicas2),
     true = lists:member(SlaveNode, SlaveActiveReplicas2),
     true = lists:member(CurrentNode, SlaveActiveReplicas2),
@@ -281,8 +281,8 @@ two_nodes_netsplit_kill_resolution_when_there_are_conflicts(Config) ->
     timer:sleep(100),
 
     %% check tables
-    1 = mnesia:table_info(syn_global_table, size),
-    1 = rpc:call(SlaveNode, mnesia, table_info, [syn_global_table, size]),
+    1 = mnesia:table_info(syn_registry_table, size),
+    1 = rpc:call(SlaveNode, mnesia, table_info, [syn_registry_table, size]),
 
     %% check process
     SlavePid = syn:find_by_key(conflicting_key),
@@ -292,8 +292,8 @@ two_nodes_netsplit_kill_resolution_when_there_are_conflicts(Config) ->
     timer:sleep(1000),
 
     %% check tables
-    0 = mnesia:table_info(syn_global_table, size),
-    [CurrentNode] = mnesia:table_info(syn_global_table, active_replicas),
+    0 = mnesia:table_info(syn_registry_table, size),
+    [CurrentNode] = mnesia:table_info(syn_registry_table, active_replicas),
 
     %% now register the local pid with the same key
     ok = syn:register(conflicting_key, LocalPid),
@@ -306,8 +306,8 @@ two_nodes_netsplit_kill_resolution_when_there_are_conflicts(Config) ->
     timer:sleep(1000),
 
     %% check tables
-    1 = mnesia:table_info(syn_global_table, size),
-    1 = rpc:call(SlaveNode, mnesia, table_info, [syn_global_table, size]),
+    1 = mnesia:table_info(syn_registry_table, size),
+    1 = rpc:call(SlaveNode, mnesia, table_info, [syn_registry_table, size]),
 
     %% check process
     FoundPid = syn:find_by_key(conflicting_key),
@@ -350,8 +350,8 @@ two_nodes_netsplit_callback_resolution_when_there_are_conflicts(Config) ->
     timer:sleep(100),
 
     %% check tables
-    1 = mnesia:table_info(syn_global_table, size),
-    1 = rpc:call(SlaveNode, mnesia, table_info, [syn_global_table, size]),
+    1 = mnesia:table_info(syn_registry_table, size),
+    1 = rpc:call(SlaveNode, mnesia, table_info, [syn_registry_table, size]),
 
     %% check process
     SlavePid = syn:find_by_key(conflicting_key),
@@ -361,8 +361,8 @@ two_nodes_netsplit_callback_resolution_when_there_are_conflicts(Config) ->
     timer:sleep(1000),
 
     %% check tables
-    0 = mnesia:table_info(syn_global_table, size),
-    [CurrentNode] = mnesia:table_info(syn_global_table, active_replicas),
+    0 = mnesia:table_info(syn_registry_table, size),
+    [CurrentNode] = mnesia:table_info(syn_registry_table, active_replicas),
 
     %% now register the local pid with the same key
     ok = syn:register(conflicting_key, LocalPid, Meta),
@@ -375,8 +375,8 @@ two_nodes_netsplit_callback_resolution_when_there_are_conflicts(Config) ->
     timer:sleep(1000),
 
     %% check tables
-    1 = mnesia:table_info(syn_global_table, size),
-    1 = rpc:call(SlaveNode, mnesia, table_info, [syn_global_table, size]),
+    1 = mnesia:table_info(syn_registry_table, size),
+    1 = rpc:call(SlaveNode, mnesia, table_info, [syn_registry_table, size]),
 
     %% check process
     FoundPid = syn:find_by_key(conflicting_key),
@@ -423,9 +423,9 @@ three_nodes_netsplit_kill_resolution_when_there_are_conflicts(Config) ->
     timer:sleep(100),
 
     %% check tables
-    2 = mnesia:table_info(syn_global_table, size),
-    2 = rpc:call(SlaveNode, mnesia, table_info, [syn_global_table, size]),
-    2 = rpc:call(SlaveNode2, mnesia, table_info, [syn_global_table, size]),
+    2 = mnesia:table_info(syn_registry_table, size),
+    2 = rpc:call(SlaveNode, mnesia, table_info, [syn_registry_table, size]),
+    2 = rpc:call(SlaveNode2, mnesia, table_info, [syn_registry_table, size]),
 
     %% check process
     SlavePid = syn:find_by_key(conflicting_key),
@@ -435,10 +435,10 @@ three_nodes_netsplit_kill_resolution_when_there_are_conflicts(Config) ->
     timer:sleep(1000),
 
     %% check tables
-    1 = mnesia:table_info(syn_global_table, size),
-    1 = rpc:call(SlaveNode2, mnesia, table_info, [syn_global_table, size]),
+    1 = mnesia:table_info(syn_registry_table, size),
+    1 = rpc:call(SlaveNode2, mnesia, table_info, [syn_registry_table, size]),
 
-    ActiveReplicaseDuringNetsplit = mnesia:table_info(syn_global_table, active_replicas),
+    ActiveReplicaseDuringNetsplit = mnesia:table_info(syn_registry_table, active_replicas),
     true = lists:member(CurrentNode, ActiveReplicaseDuringNetsplit),
     true = lists:member(SlaveNode2, ActiveReplicaseDuringNetsplit),
 
@@ -453,9 +453,9 @@ three_nodes_netsplit_kill_resolution_when_there_are_conflicts(Config) ->
     timer:sleep(1000),
 
     %% check tables
-    2 = mnesia:table_info(syn_global_table, size),
-    2 = rpc:call(SlaveNode, mnesia, table_info, [syn_global_table, size]),
-    2 = rpc:call(SlaveNode2, mnesia, table_info, [syn_global_table, size]),
+    2 = mnesia:table_info(syn_registry_table, size),
+    2 = rpc:call(SlaveNode, mnesia, table_info, [syn_registry_table, size]),
+    2 = rpc:call(SlaveNode2, mnesia, table_info, [syn_registry_table, size]),
 
     %% check processes
     FoundPid = syn:find_by_key(conflicting_key),

test/syn_test_suite_helper.erl

@@ -76,7 +76,7 @@ disconnect_node(Node) ->
 
 clean_after_test() ->
     %% delete table
-    {atomic, ok} = mnesia:delete_table(syn_global_table),
+    {atomic, ok} = mnesia:delete_table(syn_registry_table),
     %% stop mnesia
     mnesia:stop(),
     %% delete schema
@@ -88,7 +88,7 @@ clean_after_test(undefined) ->
     clean_after_test();
 clean_after_test(Node) ->
     %% delete table
-    {atomic, ok} = mnesia:delete_table(syn_global_table),
+    {atomic, ok} = mnesia:delete_table(syn_registry_table),
     %% stop mnesia
     mnesia:stop(),
     rpc:call(Node, mnesia, stop, []),