Rename processes table to global table.

include/syn.hrl

@@ -24,7 +24,7 @@
 %% THE SOFTWARE.
 %% ==========================================================================================================
 %% records
--record(syn_processes_table, {
+-record(syn_global_table, {
     key = undefined :: any(),
     pid = undefined :: undefined | pid() | atom(),
     node = undefined :: atom(),

src/syn_backbone.erl

@@ -44,44 +44,44 @@ initdb() ->
     %% ensure all nodes are added
     mnesia:change_config(extra_db_nodes, ClusterNodes),
     %% ensure table exists
-    case mnesia:create_table(syn_processes_table, [
+    case mnesia:create_table(syn_global_table, [
         {type, set},
         {ram_copies, ClusterNodes},
-        {attributes, record_info(fields, syn_processes_table)},
-        {index, [#syn_processes_table.pid]},
+        {attributes, record_info(fields, syn_global_table)},
+        {index, [#syn_global_table.pid]},
         {storage_properties, [{ets, [{read_concurrency, true}]}]}
     ]) of
         {atomic, ok} ->
-            error_logger:info_msg("syn_processes_table was successfully created"),
+            error_logger:info_msg("syn_global_table was successfully created"),
             ok;
-        {aborted, {already_exists, syn_processes_table}} ->
+        {aborted, {already_exists, syn_global_table}} ->
             %% table already exists, try to add current node as copy
             add_table_copy_to_current_node();
-        {aborted, {already_exists, syn_processes_table, CurrentNode}} ->
+        {aborted, {already_exists, syn_global_table, CurrentNode}} ->
             %% table already exists, try to add current node as copy
             add_table_copy_to_current_node();
         Other ->
-            error_logger:error_msg("Error while creating syn_processes_table: ~p", [Other]),
+            error_logger:error_msg("Error while creating syn_global_table: ~p", [Other]),
             {error, Other}
     end.
 
 -spec add_table_copy_to_current_node() -> ok | {error, any()}.
 add_table_copy_to_current_node() ->
     %% wait for table
-    mnesia:wait_for_tables([syn_processes_table], 10000),
+    mnesia:wait_for_tables([syn_global_table], 10000),
     %% add copy
     CurrentNode = node(),
-    case mnesia:add_table_copy(syn_processes_table, CurrentNode, ram_copies) of
+    case mnesia:add_table_copy(syn_global_table, CurrentNode, ram_copies) of
         {atomic, ok} ->
-            error_logger:info_msg("Copy of syn_processes_table was successfully added to current node"),
+            error_logger:info_msg("Copy of syn_global_table was successfully added to current node"),
             ok;
-        {aborted, {already_exists, syn_processes_table}} ->
-            error_logger:info_msg("Copy of syn_processes_table is already added to current node"),
+        {aborted, {already_exists, syn_global_table}} ->
+            error_logger:info_msg("Copy of syn_global_table is already added to current node"),
             ok;
-        {aborted, {already_exists, syn_processes_table, CurrentNode}} ->
-            error_logger:info_msg("Copy of syn_processes_table is already added to current node"),
+        {aborted, {already_exists, syn_global_table, CurrentNode}} ->
+            error_logger:info_msg("Copy of syn_global_table is already added to current node"),
             ok;
         {aborted, Reason} ->
-            error_logger:error_msg("Error while creating copy of syn_processes_table: ~p", [Reason]),
+            error_logger:error_msg("Error while creating copy of syn_global_table: ~p", [Reason]),
             {error, Reason}
     end.

src/syn_consistency.erl

@@ -165,12 +165,12 @@ code_change(_OldVsn, State, _Extra) ->
 -spec delete_pids_of_disconnected_node(RemoteNode :: atom()) -> ok.
 delete_pids_of_disconnected_node(RemoteNode) ->
     %% build match specs
-    MatchHead = #syn_processes_table{key = '$1', node = '$2', _ = '_'},
+    MatchHead = #syn_global_table{key = '$1', node = '$2', _ = '_'},
     Guard = {'=:=', '$2', RemoteNode},
     IdFormat = '$1',
     %% delete
-    DelF = fun(Id) -> mnesia:dirty_delete({syn_processes_table, Id}) end,
-    NodePids = mnesia:dirty_select(syn_processes_table, [{MatchHead, [Guard], [IdFormat]}]),
+    DelF = fun(Id) -> mnesia:dirty_delete({syn_global_table, Id}) end,
+    NodePids = mnesia:dirty_select(syn_global_table, [{MatchHead, [Guard], [IdFormat]}]),
     lists:foreach(DelF, NodePids).
 
 -spec automerge(RemoteNode :: atom()) -> ok.
@@ -201,7 +201,7 @@ stitch(RemoteNode) ->
     mnesia_controller:connect_nodes(
         [RemoteNode],
         fun(MergeF) ->
-            catch case MergeF([syn_processes_table]) of
+            catch case MergeF([syn_global_table]) of
                 {merged, _, _} = Res ->
                     stitch_tab(RemoteNode),
                     Res;
@@ -243,7 +243,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_processes_table, Key),
+                mnesia:dirty_delete(syn_global_table, Key),
                 %% remove it from ETS
                 ets:delete(Tab, Key),
                 %% add it to acc
@@ -273,16 +273,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_processes_table{key = '$1', pid = '$2', node = '$3', meta = '$4'},
+    MatchHead = #syn_global_table{key = '$1', pid = '$2', node = '$3', meta = '$4'},
     Guard = {'=:=', '$3', Node},
     ProcessInfoFormat = {{'$1', '$2', '$4'}},
     %% select
-    mnesia:dirty_select(syn_processes_table, [{MatchHead, [Guard], [ProcessInfoFormat]}]).
+    mnesia:dirty_select(syn_global_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_processes_table{
+        mnesia:dirty_write(#syn_global_table{
             key = Key,
             pid = ProcessPid,
             node = Node,

src/syn_global.erl

@@ -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_processes_table.pid
+        Process -> Process#syn_global_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_processes_table.pid, Process#syn_processes_table.meta}
+        Process -> {Process#syn_global_table.pid, Process#syn_global_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_processes_table.key
+        Process -> Process#syn_global_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_processes_table.key, Process#syn_processes_table.meta}
+        Process -> {Process#syn_global_table.key, Process#syn_global_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_processes_table.node,
+            Node = Process#syn_global_table.node,
             gen_server:call({?MODULE, Node}, {unregister_on_node, Key})
     end.
 
 -spec count() -> non_neg_integer().
 count() ->
-    mnesia:table_info(syn_processes_table, size).
+    mnesia:table_info(syn_global_table, size).
 
 -spec count(Node :: atom()) -> non_neg_integer().
 count(Node) ->
     %% build match specs
-    MatchHead = #syn_processes_table{node = '$2', _ = '_'},
+    MatchHead = #syn_global_table{node = '$2', _ = '_'},
     Guard = {'=:=', '$2', Node},
     Result = '$2',
     %% select
-    Processes = mnesia:dirty_select(syn_processes_table, [{MatchHead, [Guard], [Result]}]),
+    Processes = mnesia:dirty_select(syn_global_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_processes_table{
+                    mnesia:dirty_write(#syn_global_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_processes_table.pid,
+            Pid = Process#syn_global_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_processes_table.key,
-                Meta0 = Process#syn_processes_table.meta,
+                Key0 = Process#syn_global_table.key,
+                Meta0 = Process#syn_global_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_processes_table{} | undefined.
+-spec i_find_by_key(on_connected_node, Key :: any()) -> Process :: #syn_global_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_processes_table{} | undefined.
+-spec i_find_by_key(Key :: any()) -> Process :: #syn_global_table{} | undefined.
 i_find_by_key(Key) ->
-    case mnesia:dirty_read(syn_processes_table, Key) of
+    case mnesia:dirty_read(syn_global_table, Key) of
         [Process] -> Process;
         _ -> undefined
     end.
 
--spec i_find_by_pid(on_connected_node, Pid :: pid()) -> Process :: #syn_processes_table{} | undefined.
+-spec i_find_by_pid(on_connected_node, Pid :: pid()) -> Process :: #syn_global_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_processes_table{} | undefined.
+-spec i_find_by_pid(Pid :: pid()) -> Process :: #syn_global_table{} | undefined.
 i_find_by_pid(Pid) ->
-    case mnesia:dirty_index_read(syn_processes_table, Pid, #syn_processes_table.pid) of
+    case mnesia:dirty_index_read(syn_global_table, Pid, #syn_global_table.pid) of
         [Process] -> Process;
         _ -> undefined
     end.
 
--spec return_if_on_connected_node(Process :: #syn_processes_table{}) -> Process :: #syn_processes_table{} | undefined.
+-spec return_if_on_connected_node(Process :: #syn_global_table{}) -> Process :: #syn_global_table{} | undefined.
 return_if_on_connected_node(Process) ->
-    case lists:member(Process#syn_processes_table.node, [node() | nodes()]) of
+    case lists:member(Process#syn_global_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_processes_table, Key).
+    mnesia:dirty_delete(syn_global_table, Key).

test/syn_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_processes_table, size),
-    3 = rpc:call(SlaveNode, mnesia, table_info, [syn_processes_table, size]),
+    3 = mnesia:table_info(syn_global_table, size),
+    3 = rpc:call(SlaveNode, mnesia, table_info, [syn_global_table, size]),
 
-    LocalActiveReplicas = mnesia:table_info(syn_processes_table, active_replicas),
+    LocalActiveReplicas = mnesia:table_info(syn_global_table, active_replicas),
     2 = length(LocalActiveReplicas),
     true = lists:member(SlaveNode, LocalActiveReplicas),
     true = lists:member(CurrentNode, LocalActiveReplicas),
 
-    SlaveActiveReplicas = rpc:call(SlaveNode, mnesia, table_info, [syn_processes_table, active_replicas]),
+    SlaveActiveReplicas = rpc:call(SlaveNode, mnesia, table_info, [syn_global_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_processes_table, size),
-    [CurrentNode] = mnesia:table_info(syn_processes_table, active_replicas),
+    1 = mnesia:table_info(syn_global_table, size),
+    [CurrentNode] = mnesia:table_info(syn_global_table, active_replicas),
 
     %% reconnect
     syn_test_suite_helper:connect_node(SlaveNode),
     timer:sleep(1000),
 
     %% check tables
-    3 = mnesia:table_info(syn_processes_table, size),
-    3 = rpc:call(SlaveNode, mnesia, table_info, [syn_processes_table, size]),
+    3 = mnesia:table_info(syn_global_table, size),
+    3 = rpc:call(SlaveNode, mnesia, table_info, [syn_global_table, size]),
 
-    LocalActiveReplicas2 = mnesia:table_info(syn_processes_table, active_replicas),
+    LocalActiveReplicas2 = mnesia:table_info(syn_global_table, active_replicas),
     2 = length(LocalActiveReplicas2),
     true = lists:member(SlaveNode, LocalActiveReplicas2),
     true = lists:member(CurrentNode, LocalActiveReplicas2),
 
-    SlaveActiveReplicas2 = rpc:call(SlaveNode, mnesia, table_info, [syn_processes_table, active_replicas]),
+    SlaveActiveReplicas2 = rpc:call(SlaveNode, mnesia, table_info, [syn_global_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_processes_table, size),
-    1 = rpc:call(SlaveNode, mnesia, table_info, [syn_processes_table, size]),
+    1 = mnesia:table_info(syn_global_table, size),
+    1 = rpc:call(SlaveNode, mnesia, table_info, [syn_global_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_processes_table, size),
-    [CurrentNode] = mnesia:table_info(syn_processes_table, active_replicas),
+    0 = mnesia:table_info(syn_global_table, size),
+    [CurrentNode] = mnesia:table_info(syn_global_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_processes_table, size),
-    1 = rpc:call(SlaveNode, mnesia, table_info, [syn_processes_table, size]),
+    1 = mnesia:table_info(syn_global_table, size),
+    1 = rpc:call(SlaveNode, mnesia, table_info, [syn_global_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_processes_table, size),
-    1 = rpc:call(SlaveNode, mnesia, table_info, [syn_processes_table, size]),
+    1 = mnesia:table_info(syn_global_table, size),
+    1 = rpc:call(SlaveNode, mnesia, table_info, [syn_global_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_processes_table, size),
-    [CurrentNode] = mnesia:table_info(syn_processes_table, active_replicas),
+    0 = mnesia:table_info(syn_global_table, size),
+    [CurrentNode] = mnesia:table_info(syn_global_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_processes_table, size),
-    1 = rpc:call(SlaveNode, mnesia, table_info, [syn_processes_table, size]),
+    1 = mnesia:table_info(syn_global_table, size),
+    1 = rpc:call(SlaveNode, mnesia, table_info, [syn_global_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_processes_table, size),
-    2 = rpc:call(SlaveNode, mnesia, table_info, [syn_processes_table, size]),
-    2 = rpc:call(SlaveNode2, mnesia, table_info, [syn_processes_table, size]),
+    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]),
 
     %% 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_processes_table, size),
-    1 = rpc:call(SlaveNode2, mnesia, table_info, [syn_processes_table, size]),
+    1 = mnesia:table_info(syn_global_table, size),
+    1 = rpc:call(SlaveNode2, mnesia, table_info, [syn_global_table, size]),
 
-    ActiveReplicaseDuringNetsplit = mnesia:table_info(syn_processes_table, active_replicas),
+    ActiveReplicaseDuringNetsplit = mnesia:table_info(syn_global_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_processes_table, size),
-    2 = rpc:call(SlaveNode, mnesia, table_info, [syn_processes_table, size]),
-    2 = rpc:call(SlaveNode2, mnesia, table_info, [syn_processes_table, size]),
+    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]),
 
     %% check processes
     FoundPid = syn:find_by_key(conflicting_key),

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_processes_table, mnesia:system_info(tables)).
+    true = lists:member(syn_global_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_processes_table, mnesia:system_info(tables)).
+    true = lists:member(syn_global_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_processes_table, mnesia:system_info(tables)).
+    true = lists:member(syn_global_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_processes_table, mnesia:system_info(tables)).
+    true = lists:member(syn_global_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_processes_table, mnesia:system_info(tables)),
+    true = lists:member(syn_global_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_processes_table, SlaveNodeMnesiaSystemInfo]).
+    true = rpc:call(SlaveNode, lists, member, [syn_global_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_processes_table, mnesia:system_info(tables)),
+    true = lists:member(syn_global_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_processes_table, SlaveNodeMnesiaSystemInfo]).
+    true = rpc:call(SlaveNode, lists, member, [syn_global_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_processes_table, mnesia:system_info(tables)),
+    true = lists:member(syn_global_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_processes_table, SlaveNodeMnesiaSystemInfo]).
+    true = rpc:call(SlaveNode, lists, member, [syn_global_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_processes_table, mnesia:system_info(tables)),
+    true = lists:member(syn_global_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_processes_table, SlaveNodeMnesiaSystemInfo]).
+    true = rpc:call(SlaveNode, lists, member, [syn_global_table, SlaveNodeMnesiaSystemInfo]).

test/syn_test_suite_helper.erl

@@ -76,7 +76,7 @@ disconnect_node(Node) ->
 
 clean_after_test() ->
     %% delete table
-    {atomic, ok} = mnesia:delete_table(syn_processes_table),
+    {atomic, ok} = mnesia:delete_table(syn_global_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_processes_table),
+    {atomic, ok} = mnesia:delete_table(syn_global_table),
     %% stop mnesia
     mnesia:stop(),
     rpc:call(Node, mnesia, stop, []),