Remove automerge on node boot.

src/syn_groups.erl

@@ -213,8 +213,6 @@ init([]) ->
     ok = net_kernel:monitor_nodes(true),
     %% get handler
     CustomEventHandler = syn_backbone:get_event_handler_module(),
-    %% start first sync
-    self() ! sync_all,
     %% init
     {ok, #state{
         custom_event_handler = CustomEventHandler
@@ -314,15 +312,6 @@ handle_info({'DOWN', _MonitorRef, process, Pid, Reason}, State) ->
     %% return
     {noreply, State};
 
-handle_info(sync_all, State) ->
-    error_logger:info_msg("Syn(~p): Start first groups sync~n", [node()]),
-    %% loop all nodes
-    lists:foreach(fun(RemoteNode) ->
-        group_manager_automerge(RemoteNode)
-    end, nodes()),
-    %% return
-    {noreply, State};
-
 handle_info({nodeup, RemoteNode}, State) ->
     error_logger:info_msg("Syn(~p): Node ~p has joined the cluster~n", [node(), RemoteNode]),
     group_manager_automerge(RemoteNode),

src/syn_registry.erl

@@ -132,8 +132,6 @@ init([]) ->
     ok = net_kernel:monitor_nodes(true),
     %% get handler
     CustomEventHandler = syn_backbone:get_event_handler_module(),
-    %% start first sync
-    self() ! sync_all,
     %% init
     {ok, #state{
         custom_event_handler = CustomEventHandler
@@ -291,15 +289,6 @@ handle_info({'DOWN', _MonitorRef, process, Pid, Reason}, State) ->
     %% return
     {noreply, State};
 
-handle_info(sync_all, State) ->
-    error_logger:info_msg("Syn(~p): Start first registry sync~n", [node()]),
-    %% loop all nodes
-    lists:foreach(fun(RemoteNode) ->
-        registry_automerge(RemoteNode, State)
-    end, nodes()),
-    %% return
-    {noreply, State};
-
 handle_info({nodeup, RemoteNode}, State) ->
     error_logger:info_msg("Syn(~p): Node ~p has joined the cluster~n", [node(), RemoteNode]),
     registry_automerge(RemoteNode, State),
@@ -447,58 +436,55 @@ registry_automerge(RemoteNode, State) ->
         fun() ->
             error_logger:info_msg("Syn(~p): REGISTRY AUTOMERGE ----> Initiating for remote node ~p~n", [node(), RemoteNode]),
             %% get registry tuples from remote node
-            case rpc:call(RemoteNode, ?MODULE, sync_get_local_registry_tuples, [node()]) of
-                {badrpc, _} ->
-                    error_logger:info_msg("Syn(~p): REGISTRY AUTOMERGE <---- Syn not ready on remote node ~p, aborting~n", [node(), RemoteNode]);
-
-                RegistryTuples ->
-                    error_logger:info_msg(
-                        "Syn(~p): Received ~p registry tuple(s) from remote node ~p~n",
-                        [node(), length(RegistryTuples), RemoteNode]
-                    ),
-                    %% ensure that registry doesn't have any joining node's entries (here again for race conditions)
-                    raw_purge_registry_entries_for_remote_node(RemoteNode),
-                    %% loop
-                    F = fun({Name, RemotePid, RemoteMeta}) ->
-                        %% check if same name is registered
-                        case find_process_entry_by_name(Name) of
-                            undefined ->
-                                %% no conflict
-                                case rpc:call(node(RemotePid), erlang, is_process_alive, [RemotePid]) of
-                                    true ->
-                                        add_to_local_table(Name, RemotePid, RemoteMeta, undefined);
-                                    _ ->
-                                        ok = rpc:call(RemoteNode, syn_registry, remove_from_local_table, [Name])
-                                end;
-
-                            Entry ->
-                                LocalPid = Entry#syn_registry_table.pid,
-                                LocalMeta = Entry#syn_registry_table.meta,
-
-                                error_logger:warning_msg(
-                                    "Syn(~p): Conflicting name in auto merge for: ~p, processes are ~p, ~p~n",
-                                    [node(), Name, {LocalPid, LocalMeta}, {RemotePid, RemoteMeta}]
-                                ),
-
-                                case resolve_conflict(Name, {LocalPid, LocalMeta}, {RemotePid, RemoteMeta}, State) of
-                                    {PidToKeep, PidToKill} when PidToKeep =:= LocalPid ->
-                                        ok = rpc:call(RemoteNode, syn_registry, remove_from_local_table, [Name]),
-                                        syn_kill(PidToKill, Name, RemoteMeta);
-
-                                    {PidToKeep, PidToKill} when PidToKeep =:= RemotePid ->
-                                        add_to_local_table(Name, RemotePid, RemoteMeta, undefined),
-                                        syn_kill(PidToKill, Name, LocalMeta);
-
-                                    _ ->
-                                        ok
-                                end
+            RegistryTuples = rpc:call(RemoteNode, ?MODULE, sync_get_local_registry_tuples, [node()]),
+            error_logger:info_msg(
+                "Syn(~p): Received ~p registry tuple(s) from remote node ~p~n",
+                [node(), length(RegistryTuples), RemoteNode]
+            ),
+            %% ensure that registry doesn't have any joining node's entries (here again for race conditions)
+            raw_purge_registry_entries_for_remote_node(RemoteNode),
+            %% loop
+            F = fun({Name, RemotePid, RemoteMeta}) ->
+                %% check if same name is registered
+                case find_process_entry_by_name(Name) of
+                    undefined ->
+                        %% no conflict
+                        case rpc:call(node(RemotePid), erlang, is_process_alive, [RemotePid]) of
+                            true ->
+                                add_to_local_table(Name, RemotePid, RemoteMeta, undefined);
+                            _ ->
+                                ok = rpc:call(RemoteNode, syn_registry, remove_from_local_table, [Name])
+                        end;
+
+                    Entry ->
+                        LocalPid = Entry#syn_registry_table.pid,
+                        LocalMeta = Entry#syn_registry_table.meta,
+
+                        error_logger:warning_msg(
+                            "Syn(~p): Conflicting name in auto merge for: ~p, processes are ~p, ~p~n",
+                            [node(), Name, {LocalPid, LocalMeta}, {RemotePid, RemoteMeta}]
+                        ),
+
+                        case resolve_conflict(Name, {LocalPid, LocalMeta}, {RemotePid, RemoteMeta}, State) of
+                            {PidToKeep, PidToKill} when PidToKeep =:= LocalPid ->
+%%                                        ok = rpc:call(RemoteNode, syn_registry, remove_from_local_table, [Name]),
+                                ok = rpc:call(RemoteNode, syn_registry, add_to_local_table, [Name, LocalPid, LocalMeta, undefined]),
+
+                                syn_kill(PidToKill, Name, RemoteMeta);
+
+                            {PidToKeep, PidToKill} when PidToKeep =:= RemotePid ->
+                                add_to_local_table(Name, RemotePid, RemoteMeta, undefined),
+                                syn_kill(PidToKill, Name, LocalMeta);
+
+                            _ ->
+                                ok
                         end
-                    end,
-                    %% add to table
-                    lists:foreach(F, RegistryTuples),
-                    %% exit
-                    error_logger:info_msg("Syn(~p): REGISTRY AUTOMERGE <---- Done for remote node ~p~n", [node(), RemoteNode])
-            end
+                end
+            end,
+            %% add to table
+            lists:foreach(F, RegistryTuples),
+            %% exit
+            error_logger:info_msg("Syn(~p): REGISTRY AUTOMERGE <---- Done for remote node ~p~n", [node(), RemoteNode])
         end
     ).
 

test/syn_registry_SUITE.erl

@@ -46,8 +46,7 @@
     two_nodes_register_monitor_and_unregister/1,
     two_nodes_registry_count/1,
     two_nodes_registration_race_condition_conflict_resolution/1,
-    two_nodes_registration_race_condition_conflict_resolution_when_process_died/1,
-    two_nodes_registry_wait_for_syn_up/1
+    two_nodes_registration_race_condition_conflict_resolution_when_process_died/1
 ]).
 -export([
     three_nodes_partial_netsplit_consistency/1,
@@ -113,8 +112,7 @@ groups() ->
             two_nodes_register_monitor_and_unregister,
             two_nodes_registry_count,
             two_nodes_registration_race_condition_conflict_resolution,
-            two_nodes_registration_race_condition_conflict_resolution_when_process_died,
-            two_nodes_registry_wait_for_syn_up
+            two_nodes_registration_race_condition_conflict_resolution_when_process_died
         ]},
         {three_nodes_process_registration, [shuffle], [
             three_nodes_partial_netsplit_consistency,
@@ -532,23 +530,6 @@ two_nodes_registration_race_condition_conflict_resolution_when_process_died(Conf
     %% check that process is alive
     true = rpc:call(SlaveNode, erlang, is_process_alive, [Pid1]).
 
-two_nodes_registry_wait_for_syn_up(_Config) ->
-    %% stop slave
-    syn_test_suite_helper:stop_slave(syn_slave),
-    %% start syn on local node
-    ok = syn:start(),
-    %% start process
-    Pid = syn_test_suite_helper:start_process(),
-    %% register
-    ok = syn:register(<<"proc">>, Pid),
-    %% start remote node and syn
-    {ok, SlaveNode} = syn_test_suite_helper:start_slave(syn_slave),
-    ok = rpc:call(SlaveNode, syn, start, []),
-    timer:sleep(1000),
-    %% check
-    Pid = syn:whereis(<<"proc">>),
-    Pid = rpc:call(SlaveNode, syn, whereis, [<<"proc">>]).
-
 three_nodes_partial_netsplit_consistency(Config) ->
     %% get slaves
     SlaveNode1 = proplists:get_value(slave_node_1, Config),