Use consistent naming of Registry and Groups.

src/syn_consistency.erl

@@ -38,8 +38,8 @@
 %% internal
 -export([get_processes_info_of_node/1]).
 -export([write_processes_info_to_node/2]).
--export([get_pgs_info_of_node/1]).
--export([write_pgs_info_to_node/2]).
+-export([get_groups_info_of_node/1]).
+-export([write_groups_info_to_node/2]).
 
 %% records
 -record(state, {
@@ -127,8 +127,8 @@ handle_info({mnesia_system_event, {inconsistent_database, Context, RemoteNode}},
 
 handle_info({mnesia_system_event, {mnesia_down, RemoteNode}}, State) when RemoteNode =/= node() ->
     error_logger:error_msg("Received a MNESIA down event, removing on node ~p all pids of node ~p", [node(), RemoteNode]),
-    delete_global_pids_of_disconnected_node(RemoteNode),
-    delete_pg_pids_of_disconnected_node(RemoteNode),
+    delete_registry_pids_of_disconnected_node(RemoteNode),
+    delete_groups_pids_of_disconnected_node(RemoteNode),
     {noreply, State};
 
 handle_info({mnesia_system_event, _MnesiaEvent}, State) ->
@@ -166,8 +166,8 @@ code_change(_OldVsn, State, _Extra) ->
 %% ===================================================================
 %% Internal
 %% ===================================================================
--spec delete_global_pids_of_disconnected_node(RemoteNode :: atom()) -> ok.
-delete_global_pids_of_disconnected_node(RemoteNode) ->
+-spec delete_registry_pids_of_disconnected_node(RemoteNode :: atom()) -> ok.
+delete_registry_pids_of_disconnected_node(RemoteNode) ->
     %% build match specs
     MatchHead = #syn_registry_table{key = '$1', node = '$2', _ = '_'},
     Guard = {'=:=', '$2', RemoteNode},
@@ -177,8 +177,8 @@ delete_global_pids_of_disconnected_node(RemoteNode) ->
     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) ->
+-spec delete_groups_pids_of_disconnected_node(RemoteNode :: atom()) -> ok.
+delete_groups_pids_of_disconnected_node(RemoteNode) ->
     %% build match specs
     Pattern = #syn_groups_table{node = RemoteNode, _ = '_'},
     ObjectsToDelete = mnesia:dirty_match_object(syn_groups_table, Pattern),
@@ -216,16 +216,16 @@ stitch(RemoteNode) ->
         fun(MergeF) ->
             catch case MergeF([syn_registry_table, syn_groups_table]) of
                 {merged, _, _} = Res ->
-                    stitch_global_tab(RemoteNode),
-                    stitch_pg_tab(RemoteNode),
+                    stitch_registry_tab(RemoteNode),
+                    stitch_group_tab(RemoteNode),
                     Res;
                 Other ->
                     Other
             end
         end).
 
--spec stitch_global_tab(RemoteNode :: atom()) -> ok.
-stitch_global_tab(RemoteNode) ->
+-spec stitch_registry_tab(RemoteNode :: atom()) -> ok.
+stitch_registry_tab(RemoteNode) ->
     %% get remote processes info
     RemoteProcessesInfo = rpc:call(RemoteNode, ?MODULE, get_processes_info_of_node, [RemoteNode]),
     %% get local processes info
@@ -326,35 +326,35 @@ purge_double_processes(ConflictingProcessCallbackModule, ConflictingProcessCallb
     end,
     lists:foreach(F, DoubleProcessesInfo).
 
--spec stitch_pg_tab(RemoteNode :: atom()) -> ok.
-stitch_pg_tab(RemoteNode) ->
+-spec stitch_group_tab(RemoteNode :: atom()) -> ok.
+stitch_group_tab(RemoteNode) ->
     %% get remote processes info
-    RemotePgsInfo = rpc:call(RemoteNode, ?MODULE, get_pgs_info_of_node, [RemoteNode]),
+    RemoteGroupsInfo = rpc:call(RemoteNode, ?MODULE, get_groups_info_of_node, [RemoteNode]),
     %% get local processes info
-    LocalPgsInfo = get_pgs_info_of_node(node()),
+    LocalGroupsInfo = get_groups_info_of_node(node()),
     %% write
-    write_remote_pgs_to_local(RemoteNode, RemotePgsInfo),
-    write_local_pgs_to_remote(RemoteNode, LocalPgsInfo).
+    write_remote_groups_to_local(RemoteNode, RemoteGroupsInfo),
+    write_local_groups_to_remote(RemoteNode, LocalGroupsInfo).
 
--spec get_pgs_info_of_node(Node :: atom()) -> list().
-get_pgs_info_of_node(Node) ->
+-spec get_groups_info_of_node(Node :: atom()) -> list().
+get_groups_info_of_node(Node) ->
     %% build match specs
     MatchHead = #syn_groups_table{name = '$1', pid = '$2', node = '$3'},
     Guard = {'=:=', '$3', Node},
-    PgInfoFormat = {{'$1', '$2'}},
+    GroupInfoFormat = {{'$1', '$2'}},
     %% select
-    mnesia:dirty_select(syn_groups_table, [{MatchHead, [Guard], [PgInfoFormat]}]).
+    mnesia:dirty_select(syn_groups_table, [{MatchHead, [Guard], [GroupInfoFormat]}]).
 
--spec write_remote_pgs_to_local(RemoteNode :: atom(), RemotePgsInfo :: list()) -> ok.
-write_remote_pgs_to_local(RemoteNode, RemotePgsInfo) ->
-    write_pgs_info_to_node(RemoteNode, RemotePgsInfo).
+-spec write_remote_groups_to_local(RemoteNode :: atom(), RemoteGroupsInfo :: list()) -> ok.
+write_remote_groups_to_local(RemoteNode, RemoteGroupsInfo) ->
+    write_groups_info_to_node(RemoteNode, RemoteGroupsInfo).
 
--spec write_local_pgs_to_remote(RemoteNode :: atom(), LocalPgsInfo :: list()) -> ok.
-write_local_pgs_to_remote(RemoteNode, LocalPgsInfo) ->
-    ok = rpc:call(RemoteNode, ?MODULE, write_pgs_info_to_node, [node(), LocalPgsInfo]).
+-spec write_local_groups_to_remote(RemoteNode :: atom(), LocalGroupsInfo :: list()) -> ok.
+write_local_groups_to_remote(RemoteNode, LocalGroupsInfo) ->
+    ok = rpc:call(RemoteNode, ?MODULE, write_groups_info_to_node, [node(), LocalGroupsInfo]).
 
--spec write_pgs_info_to_node(Node :: atom(), PgsInfo :: list()) -> ok.
-write_pgs_info_to_node(Node, PgsInfo) ->
+-spec write_groups_info_to_node(Node :: atom(), GroupsInfo :: list()) -> ok.
+write_groups_info_to_node(Node, GroupsInfo) ->
     FWrite = fun({Name, Pid}) ->
         mnesia:dirty_write(#syn_groups_table{
             name = Name,
@@ -362,4 +362,4 @@ write_pgs_info_to_node(Node, PgsInfo) ->
             node = Node
         })
     end,
-    lists:foreach(FWrite, PgsInfo).
+    lists:foreach(FWrite, GroupsInfo).

test/syn_groups_SUITE.erl

@@ -177,18 +177,18 @@ single_node_leave(_Config) ->
     %% start process
     Pid = syn_test_suite_helper:start_process(),
     %% retrieve
-    [] = syn:get_members(<<"my pg">>),
-    false = syn:member(Pid, <<"my pg">>),
+    [] = syn:get_members(<<"my group">>),
+    false = syn:member(Pid, <<"my group">>),
     %% join
-    ok = syn:join(<<"my pg">>, Pid),
+    ok = syn:join(<<"my group">>, Pid),
     %% retrieve
-    [Pid] = syn:get_members(<<"my pg">>),
-    true = syn:member(Pid, <<"my pg">>),
+    [Pid] = syn:get_members(<<"my group">>),
+    true = syn:member(Pid, <<"my group">>),
     %% leave
-    ok = syn:leave(<<"my pg">>, Pid),
+    ok = syn:leave(<<"my group">>, Pid),
     %% retrieve
-    [] = syn:get_members(<<"my pg">>),
-    false = syn:member(Pid, <<"my pg">>),
+    [] = syn:get_members(<<"my group">>),
+    false = syn:member(Pid, <<"my group">>),
     %% kill process
     syn_test_suite_helper:kill_process(Pid).
 
@@ -201,19 +201,19 @@ single_node_kill(_Config) ->
     %% start process
     Pid = syn_test_suite_helper:start_process(),
     %% retrieve
-    [] = syn:get_members(<<"my pg">>),
-    false = syn:member(Pid, <<"my pg">>),
+    [] = syn:get_members(<<"my group">>),
+    false = syn:member(Pid, <<"my group">>),
     %% join
-    ok = syn:join(<<"my pg">>, Pid),
+    ok = syn:join(<<"my group">>, Pid),
     %% retrieve
-    [Pid] = syn:get_members(<<"my pg">>),
-    true = syn:member(Pid, <<"my pg">>),
+    [Pid] = syn:get_members(<<"my group">>),
+    true = syn:member(Pid, <<"my group">>),
     %% kill process
     syn_test_suite_helper:kill_process(Pid),
     timer:sleep(100),
     %% retrieve
-    [] = syn:get_members(<<"my pg">>),
-    false = syn:member(Pid, <<"my pg">>).
+    [] = syn:get_members(<<"my group">>),
+    false = syn:member(Pid, <<"my group">>).
 
 single_node_publish(_Config) ->
     %% set schema location
@@ -227,10 +227,10 @@ single_node_publish(_Config) ->
     Pid1 = syn_test_suite_helper:start_process(F),
     Pid2 = syn_test_suite_helper:start_process(F),
     %% join
-    ok = syn:join(<<"my pg">>, Pid1),
-    ok = syn:join(<<"my pg">>, Pid2),
+    ok = syn:join(<<"my group">>, Pid1),
+    ok = syn:join(<<"my group">>, Pid2),
     %% publish
-    syn:publish(<<"my pg">>, {test, message}),
+    syn:publish(<<"my group">>, {test, message}),
     %% check publish was received
     receive
         {received, Pid1, {test, message}} -> ok
@@ -262,33 +262,33 @@ two_nodes_kill(Config) ->
     PidLocal = syn_test_suite_helper:start_process(),
     PidSlave = syn_test_suite_helper:start_process(SlaveNode),
     %% retrieve
-    [] = syn:get_members(<<"my pg">>),
-    false = syn:member(PidLocal, <<"my pg">>),
-    false = syn:member(PidSlave, <<"my pg">>),
-    [] = rpc:call(SlaveNode, syn, get_members, [<<"my pg">>]),
-    false = rpc:call(SlaveNode, syn, member, [PidLocal, <<"my pg">>]),
-    false = rpc:call(SlaveNode, syn, member, [PidSlave, <<"my pg">>]),
+    [] = syn:get_members(<<"my group">>),
+    false = syn:member(PidLocal, <<"my group">>),
+    false = syn:member(PidSlave, <<"my group">>),
+    [] = rpc:call(SlaveNode, syn, get_members, [<<"my group">>]),
+    false = rpc:call(SlaveNode, syn, member, [PidLocal, <<"my group">>]),
+    false = rpc:call(SlaveNode, syn, member, [PidSlave, <<"my group">>]),
     %% register
-    ok = syn:join(<<"my pg">>, PidSlave),
-    ok = rpc:call(SlaveNode, syn, join, [<<"my pg">>, PidLocal]),
+    ok = syn:join(<<"my group">>, PidSlave),
+    ok = rpc:call(SlaveNode, syn, join, [<<"my group">>, PidLocal]),
     %% retrieve
-    2 = length(syn:get_members(<<"my pg">>)),
-    true = syn:member(PidLocal, <<"my pg">>),
-    true = syn:member(PidSlave, <<"my pg">>),
-    2 = length(rpc:call(SlaveNode, syn, get_members, [<<"my pg">>])),
-    true = rpc:call(SlaveNode, syn, member, [PidLocal, <<"my pg">>]),
-    true = rpc:call(SlaveNode, syn, member, [PidSlave, <<"my pg">>]),
+    2 = length(syn:get_members(<<"my group">>)),
+    true = syn:member(PidLocal, <<"my group">>),
+    true = syn:member(PidSlave, <<"my group">>),
+    2 = length(rpc:call(SlaveNode, syn, get_members, [<<"my group">>])),
+    true = rpc:call(SlaveNode, syn, member, [PidLocal, <<"my group">>]),
+    true = rpc:call(SlaveNode, syn, member, [PidSlave, <<"my group">>]),
     %% kill processes
     syn_test_suite_helper:kill_process(PidLocal),
     syn_test_suite_helper:kill_process(PidSlave),
     timer:sleep(100),
     %% retrieve
-    [] = syn:get_members(<<"my pg">>),
-    false = syn:member(PidLocal, <<"my pg">>),
-    false = syn:member(PidSlave, <<"my pg">>),
-    [] = rpc:call(SlaveNode, syn, get_members, [<<"my pg">>]),
-    false = rpc:call(SlaveNode, syn, member, [PidLocal, <<"my pg">>]),
-    false = rpc:call(SlaveNode, syn, member, [PidSlave, <<"my pg">>]).
+    [] = syn:get_members(<<"my group">>),
+    false = syn:member(PidLocal, <<"my group">>),
+    false = syn:member(PidSlave, <<"my group">>),
+    [] = rpc:call(SlaveNode, syn, get_members, [<<"my group">>]),
+    false = rpc:call(SlaveNode, syn, member, [PidLocal, <<"my group">>]),
+    false = rpc:call(SlaveNode, syn, member, [PidSlave, <<"my group">>]).
 
 two_nodes_publish(Config) ->
     %% get slave
@@ -308,10 +308,10 @@ two_nodes_publish(Config) ->
     PidLocal = syn_test_suite_helper:start_process(F),
     PidSlave = syn_test_suite_helper:start_process(SlaveNode, F),
     %% register
-    ok = syn:join(<<"my pg">>, PidSlave),
-    ok = rpc:call(SlaveNode, syn, join, [<<"my pg">>, PidLocal]),
+    ok = syn:join(<<"my group">>, PidSlave),
+    ok = rpc:call(SlaveNode, syn, join, [<<"my group">>, PidLocal]),
     %% publish
-    syn:publish(<<"my pg">>, {test, message}),
+    syn:publish(<<"my group">>, {test, message}),
     %% check publish was received
     receive
         {received, PidLocal, {test, message}} -> ok

test/syn_groups_consistency_SUITE.erl

@@ -173,9 +173,9 @@ two_nodes_netsplit_when_there_are_no_conflicts(Config) ->
     SlavePidSlave = syn_test_suite_helper:start_process(SlaveNode),
 
     %% join
-    ok = syn:join(test_pg, LocalPid),
-    ok = syn:join(test_pg, SlavePidLocal),    %% joined on local node
-    ok = rpc:call(SlaveNode, syn, join, [test_pg, SlavePidSlave]),    %% joined on slave node
+    ok = syn:join({group, tuple_name}, LocalPid),
+    ok = syn:join({group, tuple_name}, SlavePidLocal),    %% joined on local node
+    ok = rpc:call(SlaveNode, syn, join, [{group, tuple_name}, SlavePidSlave]),    %% joined on slave node
     timer:sleep(100),
 
     %% check tables
@@ -219,11 +219,11 @@ two_nodes_netsplit_when_there_are_no_conflicts(Config) ->
     true = lists:member(CurrentNode, SlaveActiveReplicasAfter),
 
     %% check grouos
-    3 = length(syn:get_members(test_pg)),
-    true = syn:member(LocalPid, test_pg),
-    true = syn:member(SlavePidLocal, test_pg),
-    true = syn:member(SlavePidSlave, test_pg),
-    3 = length(rpc:call(SlaveNode, syn, get_members, [test_pg])),
-    true = rpc:call(SlaveNode, syn, member, [LocalPid, test_pg]),
-    true = rpc:call(SlaveNode, syn, member, [SlavePidLocal, test_pg]),
-    true = rpc:call(SlaveNode, syn, member, [SlavePidSlave, test_pg]).
+    3 = length(syn:get_members({group, tuple_name})),
+    true = syn:member(LocalPid, {group, tuple_name}),
+    true = syn:member(SlavePidLocal, {group, tuple_name}),
+    true = syn:member(SlavePidSlave, {group, tuple_name}),
+    3 = length(rpc:call(SlaveNode, syn, get_members, [{group, tuple_name}])),
+    true = rpc:call(SlaveNode, syn, member, [LocalPid, {group, tuple_name}]),
+    true = rpc:call(SlaveNode, syn, member, [SlavePidLocal, {group, tuple_name}]),
+    true = rpc:call(SlaveNode, syn, member, [SlavePidSlave, {group, tuple_name}]).