diff options
Diffstat (limited to 'lib/kernel/test/global_SUITE.erl')
| -rw-r--r-- | lib/kernel/test/global_SUITE.erl | 4395 |
1 files changed, 4395 insertions, 0 deletions
diff --git a/lib/kernel/test/global_SUITE.erl b/lib/kernel/test/global_SUITE.erl new file mode 100644 index 0000000000..a8c68985e2 --- /dev/null +++ b/lib/kernel/test/global_SUITE.erl @@ -0,0 +1,4395 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1997-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% +-module(global_SUITE). + +-compile(r11). % some code is run from r11-nodes + +%-define(line_trace, 1). + +-export([all/1, + names/1, names_hidden/1, locks/1, locks_hidden/1, + bad_input/1, names_and_locks/1, lock_die/1, name_die/1, + basic_partition/1, basic_name_partition/1, + advanced_partition/1, stress_partition/1, + ring/1, simple_ring/1, line/1, simple_line/1, + global_lost_nodes/1, otp_1849/1, + otp_3162/1, otp_5640/1, otp_5737/1, + otp_6931/1, + simple_disconnect/1, + simple_resolve/1, simple_resolve2/1, simple_resolve3/1, + leftover_name/1, re_register_name/1, name_exit/1, external_nodes/1, + many_nodes/1, sync_0/1, + global_groups_change/1, + register_1/1, + both_known_1/1, + lost_unregister/1, + mass_death/1, + garbage_messages/1]). + +-export([global_load/3, lock_global/2, lock_global2/2]). + +-export([ttt/1]). +-export([mass_spawn/1]). + +-export([start_tracer/0, stop_tracer/0, get_trace/0]). + +-compile(export_all). + +-include("test_server.hrl"). + +-define(NODES, [node()|nodes()]). + +-define(UNTIL(Seq), loop_until_true(fun() -> Seq end, Config)). + +%% The resource used by the global module. +-define(GLOBAL_LOCK, global). + +ttt(suite) -> + [ +%% 5&6: succeeds +%% 4&5&6: succeeds +%% 3&4&5&6: succeeds +%% 1&2&3&6: fails +%% 1&2&6: succeeds +%% 3&6: succeeds + names, names_hidden, locks, locks_hidden, + bad_input, + names_and_locks, lock_die, name_die, basic_partition, +% advanced_partition, basic_name_partition, +% stress_partition, simple_ring, simple_line, + ring]. + +all(suite) -> + case init:get_argument(ring_line) of + {ok, _} -> + [ring_line]; + _ -> + [names, names_hidden, locks, locks_hidden, + bad_input, + names_and_locks, lock_die, name_die, basic_partition, + advanced_partition, basic_name_partition, + stress_partition, simple_ring, simple_line, + ring, line, global_lost_nodes, otp_1849, + otp_3162, otp_5640, otp_5737, otp_6931, + simple_disconnect, simple_resolve, simple_resolve2, + simple_resolve3, + leftover_name, re_register_name, name_exit, + external_nodes, many_nodes, sync_0, global_groups_change, + register_1, both_known_1, lost_unregister, + mass_death, garbage_messages] + end. + +-define(TESTCASE, testcase_name). +-define(testcase, ?config(?TESTCASE, Config)). +-define(nodes_tag, '$global_nodes'). +-define(registered, ?config(registered, Config)). + +init_per_testcase(Case, Config) when is_atom(Case), is_list(Config) -> + ok = gen_server:call(global_name_server, high_level_trace_start,infinity), + [{?TESTCASE, Case}, {registered, registered()} | Config]. + +fin_per_testcase(_Case, Config) -> + ?line write_high_level_trace(Config), + ?line _ = + gen_server:call(global_name_server, high_level_trace_stop, infinity), + ?line[global:unregister_name(N) || N <- global:registered_names(), + N =/= test_server], + ?line InitRegistered = ?registered, + ?line Registered = registered(), + ?line [io:format("~s local names: ~p~n", [What, N]) || + {What, N} <- [{"Added", Registered -- InitRegistered}, + {"Removed", InitRegistered -- Registered}], + N =/= []], + ok. + +%%% General comments: +%%% One source of problems with failing tests can be that the nodes from the +%%% previous test haven't died yet. +%%% So, when stressing a particular test by running it in a loop, it may +%%% fail already when starting the help nodes, even if the nodes have been +%%% monitored and the nodedowns picked up at the previous round. Waiting +%%% a few seconds between rounds seems to solve the problem. Possibly the +%%% timeout of 7 seconds for connections can also be a problem. This problem +%%% is the same with old (vsn 3) and new global (vsn 4). + + +%%% Test that register_name/2 registers the name on all nodes, even if +%%% a new node appears in the middle of the operation (OTP-3552). +%%% +%%% Test scenario: process p2 is spawned, locks global, starts a slave node, +%%% and tells the parent to do register_name. Then p2 sleeps for five seconds +%%% and releases the lock. Now the name should exist on both our own node +%%% and on the slave node (we wait until that is true; it seems that we +%%% can do rpc calls to another node before the connection is really up). +register_1(suite) -> []; +register_1(Config) when is_list(Config) -> + Timeout = 15, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + P = spawn_link(?MODULE, lock_global, [self(), Config]), + receive + {P, ok} -> + io:format("p1: received ok~n"), + ok + end, + P ! step2, + io:format("p1: sent step2~n"), + ?line yes = global:register_name(foo, self()), + io:format("p1: registered~n"), + P ! step3, + receive + {P, I, I2} -> + ok + end, + if + I =:= I2 -> + ok; + true -> + test_server:fail({notsync, I, I2}) + end, + ?line _ = global:unregister_name(foo), + write_high_level_trace(Config), + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + +lock_global(Parent, Config) -> + Id = {global, self()}, + io:format("p2: setting lock~n"), + global:set_lock(Id, [node()]), + Parent ! {self(), ok}, + io:format("p2: sent ok~n"), + receive + step2 -> + io:format("p2: received step2"), + ok + end, + io:format("p2: starting slave~n"), + {ok, Host} = inet:gethostname(), + {ok, N1} = slave:start(Host, node1), + io:format("p2: deleting lock~n"), + global:del_lock(Id, [node()]), + io:format("p2: deleted lock~n"), + receive + step3 -> + ok + end, + io:format("p2: received step3~n"), + I = global:whereis_name(foo), + io:format("p2: name ~p~n", [I]), + ?line ?UNTIL(I =:= rpc:call(N1, global, whereis_name, [foo])), + I2 = I, + slave:stop(N1), + io:format("p2: name2 ~p~n", [I2]), + Parent ! {self(), I, I2}, + ok. + +%%% Test for the OTP-3576 problem: if nodes 1 and 2 are separated and +%%% brought together again, while keeping connection with 3, it could +%%% happen that if someone temporarily held the 'global' lock, +%%% 'try_again_locker' would be called, and this time cause both 1 and 2 +%%% to obtain a lock for 'global' on node 3, which would keep the +%%% name registry from ever becoming consistent again. +both_known_1(suite) -> []; +both_known_1(Config) when is_list(Config) -> + Timeout = 30, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + + ?line OrigNames = global:registered_names(), + + ?line [Cp1, Cp2, Cp3] = start_nodes([cp1, cp2, cp3], slave, Config), + + ?line wait_for_ready_net(Config), + + ?line rpc_disconnect_node(Cp1, Cp2, Config), + + ?line {_Pid1, yes} = rpc:call(Cp1, ?MODULE, start_proc, [p1]), + ?line {_Pid2, yes} = rpc:call(Cp2, ?MODULE, start_proc, [p2]), + + ?line Names10 = rpc:call(Cp1, global, registered_names, []), + ?line Names20 = rpc:call(Cp2, global, registered_names, []), + ?line Names30 = rpc:call(Cp3, global, registered_names, []), + + Names1 = Names10 -- OrigNames, + Names2 = Names20 -- OrigNames, + Names3 = Names30 -- OrigNames, + + ?line [p1] = lists:sort(Names1), + ?line [p2] = lists:sort(Names2), + ?line [p1, p2] = lists:sort(Names3), + + ?line Locker = spawn(Cp3, ?MODULE, lock_global2, [{global, l3}, + self()]), + + ?line receive + {locked, S} -> + true = S + end, + + ?line pong = rpc:call(Cp1, net_adm, ping, [Cp2]), + + %% Bring cp1 and cp2 together, while someone has locked global. + %% They will now loop in 'loop_locker'. + + ?line Names10_2 = rpc:call(Cp1, global, registered_names, []), + ?line Names20_2 = rpc:call(Cp2, global, registered_names, []), + ?line Names30_2 = rpc:call(Cp3, global, registered_names, []), + + Names1_2 = Names10_2 -- OrigNames, + Names2_2 = Names20_2 -- OrigNames, + Names3_2 = Names30_2 -- OrigNames, + + ?line [p1] = lists:sort(Names1_2), + ?line [p2] = lists:sort(Names2_2), + ?line [p1, p2] = lists:sort(Names3_2), + + %% Let go of the lock, and expect the lockers to resolve the name + %% registry. + Locker ! {ok, self()}, + + ?line + ?UNTIL(begin + ?line Names10_3 = rpc:call(Cp1, global, registered_names, []), + ?line Names20_3 = rpc:call(Cp2, global, registered_names, []), + ?line Names30_3 = rpc:call(Cp3, global, registered_names, []), + + Names1_3 = Names10_3 -- OrigNames, + Names2_3 = Names20_3 -- OrigNames, + Names3_3 = Names30_3 -- OrigNames, + + N1 = lists:sort(Names1_3), + N2 = lists:sort(Names2_3), + N3 = lists:sort(Names3_3), + (N1 =:= [p1, p2]) and (N2 =:= [p1, p2]) and (N3 =:= [p1, p2]) + end), + + write_high_level_trace(Config), + stop_node(Cp1), + stop_node(Cp2), + stop_node(Cp3), + + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + +lost_unregister(suite) -> []; +lost_unregister(doc) -> + ["OTP-6428. An unregistered name reappears."]; +lost_unregister(Config) when is_list(Config) -> + Timeout = 30, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + + ?line {ok, B} = start_node(b, Config), + ?line {ok, C} = start_node(c, Config), + Nodes = [node(), B, C], + + ?line wait_for_ready_net(Config), + + % start a proc and register it + ?line {Pid, yes} = start_proc(test), + + ?line ?UNTIL(Pid =:= global:whereis_name(test)), + ?line check_everywhere(Nodes, test, Config), + + ?line rpc_disconnect_node(B, C, Config), + ?line check_everywhere(Nodes, test, Config), + ?line _ = rpc:call(B, global, unregister_name, [test]), + ?line ?UNTIL(undefined =:= global:whereis_name(test)), + ?line Pid = rpc:call(C, global, whereis_name, [test]), + ?line check_everywhere(Nodes--[C], test, Config), + ?line pong = rpc:call(B, net_adm, ping, [C]), + + %% Now the name has reappeared on node B. + ?line ?UNTIL(Pid =:= global:whereis_name(test)), + ?line check_everywhere(Nodes, test, Config), + + exit_p(Pid), + + ?line ?UNTIL(undefined =:= global:whereis_name(test)), + ?line check_everywhere(Nodes, test, Config), + + write_high_level_trace(Config), + stop_node(B), + stop_node(C), + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + +-define(UNTIL_LOOP, 300). + +-define(end_tag, 'end at'). + +init_high_level_trace(Time) -> + Mul = try + test_server:timetrap_scale_factor() + catch _:_ -> 1 + end, + put(?end_tag, msec() + Time * Mul * 1000), + %% Assures that started nodes start the high level trace automatically. + ok = gen_server:call(global_name_server, high_level_trace_start,infinity), + os:putenv("GLOBAL_HIGH_LEVEL_TRACE", "TRUE"), + put(?nodes_tag, []). + +loop_until_true(Fun, Config) -> + case Fun() of + true -> + true; + _ -> + case get(?end_tag) of + undefined -> + timer:sleep(?UNTIL_LOOP), + loop_until_true(Fun, Config); + EndAt -> + Left = EndAt - msec(), + case Left < 6000 of + true -> + write_high_level_trace(Config), + Ref = make_ref(), + receive Ref -> ok end; + false -> + timer:sleep(?UNTIL_LOOP), + loop_until_true(Fun, Config) + end + end + end. + +write_high_level_trace(Config) -> + case erase(?nodes_tag) of + undefined -> + ok; + Nodes0 -> + Nodes = lists:usort([node() | Nodes0]), + write_high_level_trace(Nodes, Config) + end. + +write_high_level_trace(Nodes, Config) -> + When = now(), + %% 'info' returns more than the trace, which is nice. + Data = [{Node, {info, rpc:call(Node, global, info, [])}} || + Node <- Nodes], + Dir = ?config(priv_dir, Config), + DataFile = filename:join([Dir, lists:concat(["global_", ?testcase])]), + file:write_file(DataFile, term_to_binary({high_level_trace, When, Data})). + +lock_global2(Id, Parent) -> + S = global:set_lock(Id), + Parent ! {locked, S}, + receive + {ok, Parent} -> + ok + end. + +%%----------------------------------------------------------------- +%% Test suite for global names and locks. +%% Should be started in a CC view with: +%% erl -sname XXX -rsh ctrsh where XX not in [cp1, cp2, cp3] +%%----------------------------------------------------------------- + +%cp1 - cp3 are started, and the name 'test' registered for a process on +%test_server. Then it is checked that the name is registered on all +%nodes, using whereis_name and safe_whereis_name. Check that the same +%name can't be registered with another value. Exit the registered +%process and check that the name disappears. Register a new process +%(Pid2) under the name 'test'. Let another new process (Pid3) +%reregister itself under the same name. Test global:send/2. Test +%unregister. Kill Pid3. Start a process (Pid6) on cp3, +%register it as 'test', stop cp1 - cp3 and check that 'test' disappeared. +%Kill Pid2 and check that 'test' isn't registered. + +names(suite) -> []; +names(Config) when is_list(Config) -> + Timeout = 30, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + ?line OrigNames = global:registered_names(), + + ?line {ok, Cp1} = start_node(cp1, Config), + ?line {ok, Cp2} = start_node(cp2, Config), + ?line {ok, Cp3} = start_node(cp3, Config), + + ?line wait_for_ready_net(Config), + + % start a proc and register it + ?line {Pid, yes} = start_proc(test), + + % test that it is registered at all nodes + ?line + ?UNTIL(begin + (Pid =:= global:safe_whereis_name(test)) and + (Pid =:= rpc:call(Cp1, global, safe_whereis_name, [test])) and + (Pid =:= rpc:call(Cp2, global, safe_whereis_name, [test])) and + (Pid =:= rpc:call(Cp3, global, safe_whereis_name, [test])) and + (Pid =:= global:whereis_name(test)) and + (Pid =:= rpc:call(Cp1, global, whereis_name, [test])) and + (Pid =:= rpc:call(Cp2, global, whereis_name, [test])) and + (Pid =:= rpc:call(Cp3, global, whereis_name, [test])) and + ([test] =:= global:registered_names() -- OrigNames) + end), + + % try to register the same name + ?line no = global:register_name(test, self()), + ?line no = rpc:call(Cp1, global, register_name, [test, self()]), + + % let process exit, check that it is unregistered automatically + exit_p(Pid), + + ?line + ?UNTIL((undefined =:= global:whereis_name(test)) and + (undefined =:= rpc:call(Cp1, global, whereis_name, [test])) and + (undefined =:= rpc:call(Cp2, global, whereis_name, [test])) and + (undefined =:= rpc:call(Cp3, global, whereis_name, [test]))), + + % test re_register + ?line {Pid2, yes} = start_proc(test), + ?line ?UNTIL(Pid2 =:= rpc:call(Cp3, global, whereis_name, [test])), + Pid3 = rpc:call(Cp3, ?MODULE, start_proc2, [test]), + ?line ?UNTIL(Pid3 =:= rpc:call(Cp3, global, whereis_name, [test])), + Pid3 = global:whereis_name(test), + + % test sending + global:send(test, {ping, self()}), + receive + {pong, Cp3} -> ok + after + 2000 -> test_server:fail(timeout1) + end, + + rpc:call(Cp1, global, send, [test, {ping, self()}]), + receive + {pong, Cp3} -> ok + after + 2000 -> test_server:fail(timeout2) + end, + + ?line _ = global:unregister_name(test), + ?line + ?UNTIL((undefined =:= global:whereis_name(test)) and + (undefined =:= rpc:call(Cp1, global, whereis_name, [test])) and + (undefined =:= rpc:call(Cp2, global, whereis_name, [test])) and + (undefined =:= rpc:call(Cp3, global, whereis_name, [test]))), + + exit_p(Pid3), + + ?line ?UNTIL(undefined =:= global:whereis_name(test)), + + % register a proc + ?line {_Pid6, yes} = rpc:call(Cp3, ?MODULE, start_proc, [test]), + + write_high_level_trace(Config), + % stop the nodes, and make sure names are released. + stop_node(Cp1), + stop_node(Cp2), + stop_node(Cp3), + + ?line ?UNTIL(undefined =:= global:whereis_name(test)), + exit_p(Pid2), + + ?line ?UNTIL(undefined =:= global:whereis_name(test)), + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + +names_hidden(suite) -> []; +names_hidden(doc) -> + ["Tests that names on a hidden node doesn't interfere with names on " + "visible nodes."]; +names_hidden(Config) when is_list(Config) -> + Timeout = 30, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + ?line OrigNames = global:registered_names(), + ?line OrigNodes = nodes(), + + ?line {ok, Cp1} = start_node(cp1, Config), + ?line {ok, Cp2} = start_node(cp2, Config), + ?line {ok, Cp3} = start_hidden_node(cp3, Config), + ?line pong = rpc:call(Cp1, net_adm, ping, [Cp3]), + ?line pong = rpc:call(Cp3, net_adm, ping, [Cp2]), + ?line pong = rpc:call(Cp3, net_adm, ping, [node()]), + + ?line [] = [Cp1, Cp2 | OrigNodes] -- nodes(), + + % start a proc on hidden node and register it + ?line {HPid, yes} = rpc:call(Cp3, ?MODULE, start_proc, [test]), + ?line Cp3 = node(HPid), + + % Check that it didn't get registered on visible nodes + ?line + ?UNTIL((undefined =:= global:safe_whereis_name(test)) and + (undefined =:= rpc:call(Cp1, global, safe_whereis_name, [test])) and + (undefined =:= rpc:call(Cp2, global, safe_whereis_name, [test])) and + (undefined =:= global:whereis_name(test)) and + (undefined =:= rpc:call(Cp1, global, whereis_name, [test])) and + (undefined =:= rpc:call(Cp2, global, whereis_name, [test]))), + + % start a proc on visible node and register it + ?line {Pid, yes} = start_proc(test), + ?line true = (Pid =/= HPid), + + % test that it is registered at all nodes + ?line + ?UNTIL((Pid =:= global:safe_whereis_name(test)) and + (Pid =:= rpc:call(Cp1, global, safe_whereis_name, [test])) and + (Pid =:= rpc:call(Cp2, global, safe_whereis_name, [test])) and + (HPid =:= rpc:call(Cp3, global, safe_whereis_name, [test])) and + (Pid =:= global:whereis_name(test)) and + (Pid =:= rpc:call(Cp1, global, whereis_name, [test])) and + (Pid =:= rpc:call(Cp2, global, whereis_name, [test])) and + (HPid =:= rpc:call(Cp3, global, whereis_name, [test])) and + ([test] =:= global:registered_names() -- OrigNames)), + + % try to register the same name + ?line no = global:register_name(test, self()), + ?line no = rpc:call(Cp1, global, register_name, [test, self()]), + + % let process exit, check that it is unregistered automatically + exit_p(Pid), + + ?line + ?UNTIL((undefined =:= global:whereis_name(test)) and + (undefined =:= rpc:call(Cp1, global, whereis_name, [test])) and + (undefined =:= rpc:call(Cp2, global, whereis_name, [test])) and + (HPid =:= rpc:call(Cp3, global, whereis_name, [test]))), + + % test re_register + ?line {Pid2, yes} = start_proc(test), + ?line ?UNTIL(Pid2 =:= rpc:call(Cp2, global, whereis_name, [test])), + Pid3 = rpc:call(Cp2, ?MODULE, start_proc2, [test]), + ?line ?UNTIL(Pid3 =:= rpc:call(Cp2, global, whereis_name, [test])), + ?line Pid3 = global:whereis_name(test), + + % test sending + ?line Pid3 = global:send(test, {ping, self()}), + receive + {pong, Cp2} -> ok + after + 2000 -> test_server:fail(timeout1) + end, + + rpc:call(Cp1, global, send, [test, {ping, self()}]), + receive + {pong, Cp2} -> ok + after + 2000 -> test_server:fail(timeout2) + end, + + ?line _ = rpc:call(Cp3, global, unregister_name, [test]), + ?line + ?UNTIL((Pid3 =:= global:whereis_name(test)) and + (Pid3 =:= rpc:call(Cp1, global, whereis_name, [test])) and + (Pid3 =:= rpc:call(Cp2, global, whereis_name, [test])) and + (undefined =:= rpc:call(Cp3, global, whereis_name, [test]))), + + ?line _ = global:unregister_name(test), + ?line + ?UNTIL((undefined =:= global:whereis_name(test)) and + (undefined =:= rpc:call(Cp1, global, whereis_name, [test])) and + (undefined =:= rpc:call(Cp2, global, whereis_name, [test])) and + (undefined =:= rpc:call(Cp3, global, whereis_name, [test]))), + + exit_p(Pid3), + exit_p(HPid), + + ?line ?UNTIL(undefined =:= global:whereis_name(test)), + + write_high_level_trace(Config), + % stop the nodes, and make sure names are released. + stop_node(Cp1), + stop_node(Cp2), + stop_node(Cp3), + + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + +locks(suite) -> []; +locks(Config) when is_list(Config) -> + Timeout = 30, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + ?line {ok, Cp1} = start_node(cp1, Config), + ?line {ok, Cp2} = start_node(cp2, Config), + ?line {ok, Cp3} = start_node(cp3, Config), + + ?line wait_for_ready_net(Config), + + % start two procs + ?line Pid = start_proc(), + ?line Pid2 = rpc:call(Cp1, ?MODULE, start_proc, []), + % set a lock, and make sure noone else can set the same lock + ?line true = global:set_lock({test_lock, self()}, ?NODES, 1), + ?line false = req(Pid, {set_lock, test_lock, self()}), + ?line false = req(Pid2, {set_lock, test_lock, self()}), + % delete, and let another proc set the lock + global:del_lock({test_lock, self()}), + ?line true = req(Pid, {set_lock, test_lock, self()}), + ?line false = req(Pid2, {set_lock, test_lock, self()}), + ?line false = global:set_lock({test_lock, self()}, ?NODES,1), + % kill lock-holding proc, make sure the lock is released + exit_p(Pid), + ?UNTIL(true =:= global:set_lock({test_lock, self()}, ?NODES,1)), + Pid2 ! {set_lock_loop, test_lock, self()}, + % make sure we don't have the msg + receive + {got_lock, Pid2} -> test_server:fail(got_lock) + after + 1000 -> ok + end, + global:del_lock({test_lock, self()}), + % make sure pid2 got the lock + receive + {got_lock, Pid2} -> ok + after + % 12000 >> 5000, which is the max time before a new retry for + % set_lock + 12000 -> test_server:fail(got_lock2) + end, + + % let proc set the same lock + ?line true = req(Pid2, {set_lock, test_lock, self()}), + % let proc set new lock + ?line true = req(Pid2, {set_lock, test_lock2, self()}), + ?line false = global:set_lock({test_lock, self()},?NODES,1), + ?line false = global:set_lock({test_lock2, self()}, ?NODES,1), + exit_p(Pid2), +% erlang:display({locks1, ets:tab2list(global_locks)}), + ?UNTIL(true =:= global:set_lock({test_lock, self()}, ?NODES, 1)), + ?UNTIL(true =:= global:set_lock({test_lock2, self()}, ?NODES, 1)), + ?line global:del_lock({test_lock, self()}), + ?line global:del_lock({test_lock2, self()}), + + % let proc set two locks + ?line Pid3 = rpc:call(Cp1, ?MODULE, start_proc, []), + ?line true = req(Pid3, {set_lock, test_lock, self()}), + ?line true = req(Pid3, {set_lock, test_lock2, self()}), + % del one lock + ?line Pid3 ! {del_lock, test_lock2}, + ?line test_server:sleep(100), + % check that one lock is still set, but not the other + ?line false = global:set_lock({test_lock, self()}, ?NODES, 1), + ?line true = global:set_lock({test_lock2, self()}, ?NODES, 1), + ?line global:del_lock({test_lock2, self()}), + % kill lock-holder + exit_p(Pid3), +% erlang:display({locks2, ets:tab2list(global_locks)}), + ?UNTIL(true =:= global:set_lock({test_lock, self()}, ?NODES, 1)), + ?line global:del_lock({test_lock, self()}), + ?UNTIL(true =:= global:set_lock({test_lock2, self()}, ?NODES, 1)), + ?line global:del_lock({test_lock2, self()}), + + % start one proc on each node + ?line Pid4 = start_proc(), + ?line Pid5 = rpc:call(Cp1, ?MODULE, start_proc, []), + ?line Pid6 = rpc:call(Cp2, ?MODULE, start_proc, []), + ?line Pid7 = rpc:call(Cp3, ?MODULE, start_proc, []), + % set lock on two nodes + ?line true = req(Pid4, {set_lock, test_lock, self(), [node(), Cp1]}), + ?line false = req(Pid5, {set_lock, test_lock, self(), [node(), Cp1]}), + % set same lock on other two nodes + ?line true = req(Pid6, {set_lock, test_lock, self(), [Cp2, Cp3]}), + ?line false = req(Pid7, {set_lock, test_lock, self(), [Cp2, Cp3]}), + % release lock + Pid6 ! {del_lock, test_lock, [Cp2, Cp3]}, + % try to set lock on a node that already has the lock + ?line false = req(Pid6, {set_lock, test_lock, self(), [Cp1, Cp2, Cp3]}), + + % set lock on a node + exit_p(Pid4), + ?UNTIL(true =:= req(Pid5, {set_lock, test_lock, self(), [node(), Cp1]})), + ?line Pid8 = start_proc(), + ?line false = req(Pid8, {set_lock, test_lock, self()}), + write_high_level_trace(Config), + % stop the nodes, and make sure locks are released. + stop_node(Cp1), + stop_node(Cp2), + stop_node(Cp3), + ?line test_server:sleep(100), + ?line true = req(Pid8, {set_lock, test_lock, self()}), + exit_p(Pid8), + ?line test_server:sleep(10), + + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + + +locks_hidden(suite) -> []; +locks_hidden(doc) -> + ["Tests that locks on a hidden node doesn't interere with locks on " + "visible nodes."]; +locks_hidden(Config) when is_list(Config) -> + Timeout = 30, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + ?line OrigNodes = nodes(), + ?line {ok, Cp1} = start_node(cp1, Config), + ?line {ok, Cp2} = start_node(cp2, Config), + ?line {ok, Cp3} = start_hidden_node(cp3, Config), + ?line pong = rpc:call(Cp1, net_adm, ping, [Cp3]), + ?line pong = rpc:call(Cp3, net_adm, ping, [Cp2]), + ?line pong = rpc:call(Cp3, net_adm, ping, [node()]), + + ?line [] = [Cp1, Cp2 | OrigNodes] -- nodes(), + + % start two procs + ?line Pid = start_proc(), + ?line Pid2 = rpc:call(Cp1, ?MODULE, start_proc, []), + ?line HPid = rpc:call(Cp3, ?MODULE, start_proc, []), + % Make sure hidden node doesn't interfere with visible nodes lock + ?line true = req(HPid, {set_lock, test_lock, self()}), + ?line true = global:set_lock({test_lock, self()}, ?NODES, 1), + ?line false = req(Pid, {set_lock, test_lock, self()}), + ?line true = req(HPid, {del_lock_sync, test_lock, self()}), + ?line false = req(Pid2, {set_lock, test_lock, self()}), + % delete, and let another proc set the lock + global:del_lock({test_lock, self()}), + ?line true = req(Pid, {set_lock, test_lock, self()}), + ?line false = req(Pid2, {set_lock, test_lock, self()}), + ?line false = global:set_lock({test_lock, self()}, ?NODES,1), + % kill lock-holding proc, make sure the lock is released + exit_p(Pid), + ?UNTIL(true =:= global:set_lock({test_lock, self()}, ?NODES, 1)), + ?UNTIL(true =:= req(HPid, {set_lock, test_lock, self()})), + Pid2 ! {set_lock_loop, test_lock, self()}, + % make sure we don't have the msg + receive + {got_lock, Pid2} -> test_server:fail(got_lock) + after + 1000 -> ok + end, + global:del_lock({test_lock, self()}), + % make sure pid2 got the lock + receive + {got_lock, Pid2} -> ok + after + % 12000 >> 5000, which is the max time before a new retry for + % set_lock + 12000 -> test_server:fail(got_lock2) + end, + ?line true = req(HPid, {del_lock_sync, test_lock, self()}), + + % let proc set the same lock + ?line true = req(Pid2, {set_lock, test_lock, self()}), + % let proc set new lock + ?line true = req(Pid2, {set_lock, test_lock2, self()}), + ?line true = req(HPid, {set_lock, test_lock, self()}), + ?line true = req(HPid, {set_lock, test_lock2, self()}), + exit_p(HPid), + ?line false = global:set_lock({test_lock, self()},?NODES,1), + ?line false = global:set_lock({test_lock2, self()}, ?NODES,1), + exit_p(Pid2), +% erlang:display({locks1, ets:tab2list(global_locks)}), + ?UNTIL(true =:= global:set_lock({test_lock, self()}, ?NODES, 1)), + ?UNTIL(true =:= global:set_lock({test_lock2, self()}, ?NODES, 1)), + ?line global:del_lock({test_lock, self()}), + ?line global:del_lock({test_lock2, self()}), + + write_high_level_trace(Config), + % stop the nodes, and make sure locks are released. + stop_node(Cp1), + stop_node(Cp2), + stop_node(Cp3), + + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + + +bad_input(suite) -> []; +bad_input(Config) when is_list(Config) -> + Timeout = 15, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + Pid = whereis(global_name_server), + ?line {'EXIT', _} = (catch global:set_lock(bad_id)), + ?line {'EXIT', _} = (catch global:set_lock({id, self()}, bad_nodes)), + ?line {'EXIT', _} = (catch global:del_lock(bad_id)), + ?line {'EXIT', _} = (catch global:del_lock({id, self()}, bad_nodes)), + ?line {'EXIT', _} = (catch global:register_name(name, bad_pid)), + ?line {'EXIT', _} = (catch global:reregister_name(name, bad_pid)), + ?line {'EXIT', _} = (catch global:trans(bad_id, {m,f})), + ?line {'EXIT', _} = (catch global:trans({id, self()}, {m,f}, [node()], -1)), + ?line Pid = whereis(global_name_server), + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + +names_and_locks(suite) -> []; +names_and_locks(Config) when is_list(Config) -> + Timeout = 30, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + ?line OrigNames = global:registered_names(), + + ?line {ok, Cp1} = start_node(cp1, Config), + ?line {ok, Cp2} = start_node(cp2, Config), + ?line {ok, Cp3} = start_node(cp3, Config), + + % start one proc on each node + ?line PidTS = start_proc(), + ?line Pid1 = rpc:call(Cp1, ?MODULE, start_proc, []), + ?line Pid2 = rpc:call(Cp2, ?MODULE, start_proc, []), + ?line Pid3 = rpc:call(Cp3, ?MODULE, start_proc, []), + % register some of them + ?line yes = global:register_name(test1, Pid1), + ?line yes = global:register_name(test2, Pid2), + ?line yes = global:register_name(test3, Pid3), + ?line no = global:register_name(test3, PidTS), + ?line yes = global:register_name(test4, PidTS), + + % set lock on two nodes + ?line true = req(PidTS, {set_lock, test_lock, self(), [node(), Cp1]}), + ?line false = req(Pid1, {set_lock, test_lock, self(), [node(), Cp1]}), + % set same lock on other two nodes + ?line true = req(Pid2, {set_lock, test_lock, self(), [Cp2, Cp3]}), + ?line false = req(Pid3, {set_lock, test_lock, self(), [Cp2, Cp3]}), + % release lock + Pid2 ! {del_lock, test_lock, [Cp2, Cp3]}, + ?line test_server:sleep(100), + % try to set lock on a node that already has the lock + ?line false = req(Pid2, {set_lock, test_lock, self(), [Cp1, Cp2, Cp3]}), + % set two locks + ?line true = req(Pid2, {set_lock, test_lock, self(), [Cp2, Cp3]}), + ?line true = req(Pid2, {set_lock, test_lock2, self(), [Cp2, Cp3]}), + + % kill some processes, make sure all locks/names are released + exit_p(PidTS), + ?line ?UNTIL(undefined =:= global:whereis_name(test4)), + ?line true = global:set_lock({test_lock, self()}, [node(), Cp1], 1), + global:del_lock({test_lock, self()}, [node(), Cp1]), + + exit_p(Pid2), + ?line + ?UNTIL((undefined =:= global:whereis_name(test2)) and + (true =:= global:set_lock({test_lock, self()}, [Cp2, Cp3], 1)) and + (true =:= global:set_lock({test_lock2, self()}, [Cp2, Cp3], 1))), + + global:del_lock({test_lock, self()}, [Cp2, Cp3]), + global:del_lock({test_lock2, self()}, [Cp2, Cp3]), + + exit_p(Pid1), + exit_p(Pid3), + + ?line ?UNTIL(OrigNames =:= global:registered_names()), + + write_high_level_trace(Config), + stop_node(Cp1), + stop_node(Cp2), + stop_node(Cp3), + + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + +lock_die(suite) -> []; +lock_die(doc) -> + ["OTP-6341. Remove locks using monitors."]; +lock_die(Config) when is_list(Config) -> + Timeout = 30, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + ?line OrigNames = global:registered_names(), + + ?line {ok, Cp1} = start_node(cp1, Config), + ?line {ok, Cp2} = start_node(cp2, Config), + + %% First test. + LockId = {id, self()}, + ?line Pid2 = start_proc(), + ?line true = req(Pid2, {set_lock2, LockId, self()}), + + ?line true = global:set_lock(LockId, [Cp1]), + %% Id is locked on Cp1 and Cp2 (by Pid2) but not by self(): + %% (there is no mon. ref) + ?line _ = global:del_lock(LockId, [node(), Cp1, Cp2]), + + ?line exit_p(Pid2), + + %% Second test. + ?line Pid3 = start_proc(), + ?line true = req(Pid3, {set_lock, id, self(), [Cp1]}), + %% The lock is removed from Cp1 thanks to monitors. + ?line exit_p(Pid3), + + ?line true = global:set_lock(LockId, [node(), Cp1]), + ?line _ = global:del_lock(LockId, [node(), Cp1]), + + ?line ?UNTIL(OrigNames =:= global:registered_names()), + write_high_level_trace(Config), + stop_node(Cp1), + stop_node(Cp2), + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + +name_die(suite) -> []; +name_die(doc) -> + ["OTP-6341. Remove names using monitors."]; +name_die(Config) when is_list(Config) -> + Timeout = 30, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + ?line OrigNames = global:registered_names(), + ?line [Cp1] = Cps = start_nodes([z], peer, Config), % z > test_server + Nodes = lists:sort([node() | Cps]), + ?line wait_for_ready_net(Config), + + Name = name_die, + ?line Pid = rpc:call(Cp1, ?MODULE, start_proc, []), + + %% Test 1. No resolver is called if the same pid is registered on + %% both partitions. + T1 = node(), + Part1 = [T1], + Part2 = [Cp1], + ?line rpc_cast(Cp1, + ?MODULE, part_2_2, [Config, + Part1, + Part2, + []]), + ?line ?UNTIL(is_ready_partition(Config)), + ?line ?UNTIL(undefined =:= global:whereis_name(Name)), + ?line yes = global:register_name(Name, Pid), + + ?line pong = net_adm:ping(Cp1), + ?line wait_for_ready_net(Nodes, Config), + ?line assert_pid(global:whereis_name(Name)), + exit_p(Pid), + ?line ?UNTIL(OrigNames =:= global:registered_names()), + + %% Test 2. Register a name running outside the current partition. + %% Killing the pid will not remove the name from the current + %% partition, unless monitors are used. + ?line Pid2 = rpc:call(Cp1, ?MODULE, start_proc, []), + Dir = ?config(priv_dir, Config), + KillFile = filename:join([Dir, "kill.txt"]), + file:delete(KillFile), + ?line erlang:spawn(Cp1, fun() -> kill_pid(Pid2, KillFile, Config) end), + ?line rpc_cast(Cp1, + ?MODULE, part_2_2, [Config, + Part1, + Part2, + []]), + ?line ?UNTIL(is_ready_partition(Config)), + ?line ?UNTIL(undefined =:= global:whereis_name(Name)), + ?line yes = global:register_name(Name, Pid2), + ?line touch(KillFile, "kill"), + ?line file_contents(KillFile, "done", Config), + file:delete(KillFile), + + ?line ?UNTIL(OrigNames =:= global:registered_names()), + write_high_level_trace(Config), + stop_nodes(Cps), + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + +kill_pid(Pid, File, Config) -> + file_contents(File, "kill", Config), + exit_p(Pid), + touch(File, "done"). + +basic_partition(suite) -> []; +basic_partition(doc) -> + ["Tests that two partitioned networks exchange correct info."]; +basic_partition(Config) when is_list(Config) -> + Timeout = 30, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + ?line OrigNames = global:registered_names(), + + ?line [Cp1, Cp2, Cp3] = start_nodes([cp1, cp2, cp3], peer, Config), + ?line [Cp1, Cp2, Cp3] = lists:sort(nodes()), + + ?line wait_for_ready_net(Config), + + % make cp2 and cp3 connected, partitioned from us and cp1 + ?line rpc_cast(Cp2, ?MODULE, part1, [Config, node(), Cp1, Cp3]), + ?line ?UNTIL(is_ready_partition(Config)), + + % start different processes in both partitions + ?line {Pid, yes} = start_proc(test), + + % connect to other partition + ?line pong = net_adm:ping(Cp2), + ?line pong = net_adm:ping(Cp3), + ?line [Cp1, Cp2, Cp3] = lists:sort(nodes()), + + % check names + ?line ?UNTIL(Pid =:= rpc:call(Cp2, global, whereis_name, [test])), + ?line ?UNTIL(undefined =/= global:whereis_name(test2)), + ?line Pid2 = global:whereis_name(test2), + ?line Pid2 = rpc:call(Cp2, global, whereis_name, [test2]), + ?line assert_pid(Pid2), + ?line Pid3 = global:whereis_name(test4), + ?line ?UNTIL(Pid3 =:= rpc:call(Cp1, global, whereis_name, [test4])), + ?line assert_pid(Pid3), + + % kill all procs + ?line Pid3 = global:send(test4, die), + % sleep to let the proc die + wait_for_exit(Pid3), + ?line ?UNTIL(undefined =:= global:whereis_name(test4)), + + exit_p(Pid), + exit_p(Pid2), + + ?line ?UNTIL(OrigNames =:= global:registered_names()), + + write_high_level_trace(Config), + stop_node(Cp1), + stop_node(Cp2), + stop_node(Cp3), + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + +basic_name_partition(suite) -> + []; +basic_name_partition(doc) -> + ["Creates two partitions with two nodes in each partition.", + "Tests that names are exchanged correctly, and that EXITs", + "during connect phase are handled correctly."]; +basic_name_partition(Config) when is_list(Config) -> + Timeout = 60, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + ?line OrigNames = global:registered_names(), + + ?line [Cp1, Cp2, Cp3] = start_nodes([cp1, cp2, cp3], peer, Config), + ?line [Cp1, Cp2, Cp3] = lists:sort(nodes()), + Nodes = ?NODES, + + ?line wait_for_ready_net(Config), + + % There used to be more than one name registered for some + % processes. That was a mistake; there is no support for more than + % one name per process, and the manual is quite clear about that + % ("equivalent to the register/2 and whereis/1 BIFs"). The + % resolver procedure did not take care of such "duplicated" names, + % which caused this testcase to fail every now and then. + + % make cp2 and cp3 connected, partitioned from us and cp1 + % us: register name03 + % cp1: register name12 + % cp2: register name12 + % cp3: register name03 + + ?line rpc_cast(Cp2, ?MODULE, part1_5, [Config, node(), Cp1, Cp3]), + ?line ?UNTIL(is_ready_partition(Config)), + + % start different processes in both partitions + ?line {_, yes} = start_proc_basic(name03), + ?line {_, yes} = rpc:call(Cp1, ?MODULE, start_proc_basic, [name12]), + test_server:sleep(1000), + + % connect to other partition + ?line pong = net_adm:ping(Cp3), + + ?line ?UNTIL([Cp1, Cp2, Cp3] =:= lists:sort(nodes())), + ?line wait_for_ready_net(Config), + % check names + ?line Pid03 = global:whereis_name(name03), + ?line assert_pid(Pid03), + ?line true = lists:member(node(Pid03), [node(), Cp3]), + ?line check_everywhere(Nodes, name03, Config), + + ?line Pid12 = global:whereis_name(name12), + ?line assert_pid(Pid12), + ?line true = lists:member(node(Pid12), [Cp1, Cp2]), + ?line check_everywhere(Nodes, name12, Config), + + % kill all procs + ?line Pid12 = global:send(name12, die), + ?line Pid03 = global:send(name03, die), + % sleep to let the procs die + wait_for_exit(Pid12), + wait_for_exit(Pid03), + ?line + ?UNTIL(begin + Names = [name03, name12], + lists:duplicate(length(Names), undefined) + =:= [global:whereis_name(Name) || Name <- Names] + end), + + ?line ?UNTIL(OrigNames =:= global:registered_names()), + + write_high_level_trace(Config), + stop_node(Cp1), + stop_node(Cp2), + stop_node(Cp3), + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + +%Peer nodes cp0 - cp6 are started. Break apart the connections from +%cp3-cp6 to cp0-cp2 and test_server so we get two partitions. +%In the cp3-cp6 partition, start one process on each node and register +%using both erlang:register, and global:register (test1 on cp3, test2 on +%cp4, test3 on cp5, test4 on cp6), using different resolution functions: +%default for test1, notify_all_name for test2, random_notify_name for test3 +%and one for test4 that sends a message to test_server and keeps the +%process which is greater in the standard ordering. In the other partition, +%do the same (test1 on test_server, test2 on cp0, test3 on cp1, test4 on cp2). +%Sleep a little, then from test_server, connect to cp3-cp6 in order. +%Check that the values for the registered names are the expected ones, and +%that the messages from test4 arrive. + +advanced_partition(suite) -> + []; +advanced_partition(doc) -> + ["Test that names are resolved correctly when two", + "partitioned networks connect."]; +advanced_partition(Config) when is_list(Config) -> + Timeout = 60, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + ?line OrigNames = global:registered_names(), + + ?line [Cp0, Cp1, Cp2, Cp3, Cp4, Cp5, Cp6] + = start_nodes([cp0, cp1, cp2, cp3, cp4, cp5, cp6], peer, Config), + Nodes = lists:sort([node(), Cp0, Cp1, Cp2, Cp3, Cp4, Cp5, Cp6]), + ?line wait_for_ready_net(Config), + + % make cp3-cp6 connected, partitioned from us and cp0-cp2 + ?line rpc_cast(Cp3, ?MODULE, part2, + [Config, self(), node(), Cp0, Cp1, Cp2, Cp3, Cp4, Cp5,Cp6]), + ?line ?UNTIL(is_ready_partition(Config)), + + % start different processes in this partition + ?line start_procs(self(), Cp0, Cp1, Cp2, Config), + + % connect to other partition + ?line pong = net_adm:ping(Cp3), + ?line pong = net_adm:ping(Cp4), + ?line pong = net_adm:ping(Cp5), + ?line pong = net_adm:ping(Cp6), + + ?line wait_for_ready_net(Config), + + ?line + ?UNTIL(lists:member(undefined, + [rpc:call(Cp3, erlang, whereis, [test1]), + rpc:call(node(), erlang, whereis, [test1])])), + + Nt1 = rpc:call(Cp3, erlang, whereis, [test1]), + Nt2 = rpc:call(Cp4, erlang, whereis, [test2]), + Nt3 = rpc:call(Cp5, erlang, whereis, [test3]), + Nt4 = rpc:call(Cp6, erlang, whereis, [test4]), + + Mt1 = rpc:call(node(), erlang, whereis, [test1]), + Mt2 = rpc:call(Cp0, erlang, whereis, [test2]), + Mt3 = rpc:call(Cp1, erlang, whereis, [test3]), + _Mt4 = rpc:call(Cp2, erlang, whereis, [test4]), + + % check names + ?line Pid1 = global:whereis_name(test1), + ?line Pid1 = rpc:call(Cp3, global, whereis_name, [test1]), + ?line assert_pid(Pid1), + ?line true = lists:member(Pid1, [Nt1, Mt1]), + ?line true = lists:member(undefined, [Nt1, Mt1]), + ?line check_everywhere(Nodes, test1, Config), + + ?line undefined = global:whereis_name(test2), + ?line undefined = rpc:call(Cp3, global, whereis_name, [test2]), + ?line yes = sreq(Nt2, {got_notify, self()}), + ?line yes = sreq(Mt2, {got_notify, self()}), + ?line check_everywhere(Nodes, test2, Config), + + ?line Pid3 = global:whereis_name(test3), + ?line Pid3 = rpc:call(Cp3, global, whereis_name, [test3]), + ?line assert_pid(Pid3), + ?line true = lists:member(Pid3, [Nt3, Mt3]), + ?line no = sreq(Pid3, {got_notify, self()}), + ?line yes = sreq(other(Pid3, [Nt2, Nt3]), {got_notify, self()}), + ?line check_everywhere(Nodes, test3, Config), + + ?line Pid4 = global:whereis_name(test4), + ?line Pid4 = rpc:call(Cp3, global, whereis_name, [test4]), + ?line assert_pid(Pid4), +% ?line true = lists:member(Pid4, [Nt4, Mt4]), + ?line Pid4 = Nt4, + ?line check_everywhere(Nodes, test4, Config), + + ?line 1 = collect_resolves(), + + ?line Pid1 = global:send(test1, die), + exit_p(Pid3), + exit_p(Pid4), + wait_for_exit(Pid1), + wait_for_exit(Pid3), + ?line ?UNTIL(OrigNames =:= global:registered_names()), + + write_high_level_trace(Config), + stop_node(Cp0), + stop_node(Cp1), + stop_node(Cp2), + stop_node(Cp3), + stop_node(Cp4), + stop_node(Cp5), + stop_node(Cp6), + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + +%Peer nodes cp0 - cp6 are started, and partitioned just like in +%advanced_partition. Start cp8, only connected to test_server. Let cp6 +%break apart from the rest, and 12 s later, ping cp0 and cp3, and +%register the name test5. After the same 12 s, let cp5 halt. +%Wait for the death of cp5. Ping cp3 (at the same time as cp6 does). +%Take down cp2. Start cp7, restart cp2. Ping cp4, cp6 and cp8. +%Now, expect all nodes to be connected and have the same picture of all +%registered names. + +stress_partition(suite) -> + []; +stress_partition(doc) -> + ["Stress global, make a partitioned net, make some nodes", + "go up/down a bit."]; +stress_partition(Config) when is_list(Config) -> + Timeout = 90, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + ?line OrigNames = global:registered_names(), + + ?line [Cp0, Cp1, Cp2, Cp3, Cp4, Cp5, Cp6] + = start_nodes([cp0, cp1, cp2, cp3, cp4, cp5, cp6], peer, Config), + + ?line wait_for_ready_net(Config), + + % make cp3-cp5 connected, partitioned from us and cp0-cp2 + % cp6 is alone (single node). cp6 pings cp0 and cp3 in 12 secs... + ?line rpc_cast(Cp3, ?MODULE, part3, + [Config, self(), node(), Cp0, Cp1, Cp2, Cp3, Cp4, Cp5,Cp6]), + ?line ?UNTIL(is_ready_partition(Config)), + + % start different processes in this partition + ?line start_procs(self(), Cp0, Cp1, Cp2, Config), + + ?line {ok, Cp8} = start_peer_node(cp8, Config), + + monitor_node(Cp5, true), + receive + {nodedown, Cp5} -> ok + after + 20000 -> test_server:fail({no_nodedown, Cp5}) + end, + monitor_node(Cp5, false), + + % Ok, now cp6 pings us, and cp5 will go down. + + % connect to other partition + ?line pong = net_adm:ping(Cp3), + ?line rpc_cast(Cp2, ?MODULE, crash, [0]), + + % Start new nodes + ?line {ok, Cp7} = start_peer_node(cp7, Config), + ?line {ok, Cp2_2} = start_peer_node(cp2, Config), + Nodes = lists:sort([node(), Cp0, Cp1, Cp2_2, Cp3, Cp4, Cp6, Cp7, Cp8]), + put(?nodes_tag, Nodes), + + ?line pong = net_adm:ping(Cp4), + ?line pong = net_adm:ping(Cp6), + ?line pong = net_adm:ping(Cp8), + + ?line wait_for_ready_net(Nodes, Config), + + % Make sure that all nodes have the same picture of all names + ?line check_everywhere(Nodes, test1, Config), + ?line assert_pid(global:whereis_name(test1)), + + ?line check_everywhere(Nodes, test2, Config), + ?line undefined = global:whereis_name(test2), + + ?line check_everywhere(Nodes, test3, Config), + ?line assert_pid(global:whereis_name(test3)), + + ?line check_everywhere(Nodes, test4, Config), + ?line assert_pid(global:whereis_name(test4)), + + ?line check_everywhere(Nodes, test5, Config), + ?line ?UNTIL(undefined =:= global:whereis_name(test5)), + + ?line assert_pid(global:send(test1, die)), + ?line assert_pid(global:send(test3, die)), + ?line assert_pid(global:send(test4, die)), + + ?line ?UNTIL(OrigNames =:= global:registered_names()), + + write_high_level_trace(Config), + stop_node(Cp0), + stop_node(Cp1), + stop_node(Cp2_2), + stop_node(Cp3), + stop_node(Cp4), + stop_node(Cp5), + stop_node(Cp6), + stop_node(Cp7), + stop_node(Cp8), + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + + +%% Use this one to test alot of connection tests +%% erl -sname ts -rsh ctrsh -pa /clearcase/otp/internal_tools/test_server/ebin/ -ring_line 10000 -s test_server run_test global_SUITE + +ring_line(suite) -> []; +ring_line(doc) -> [""]; +ring_line(Config) when is_list(Config) -> + {ok, [[N]]} = init:get_argument(ring_line), + loop_it(list_to_integer(N), Config). + +loop_it(N, Config) -> loop_it(N,N, Config). + +loop_it(0,_, _Config) -> ok; +loop_it(N,M, Config) -> + test_server:format(1, "Round: ~w", [M-N]), + ring(Config), + line(Config), + loop_it(N-1,M, Config). + + +ring(suite) -> + []; +ring(doc) -> + ["Make 10 single nodes, all having the same name.", + "Make all ping its predecessor, pinging in a ring.", + "Make sure that there's just one winner."]; +ring(Config) when is_list(Config) -> + Timeout = 60, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + ?line OrigNames = global:registered_names(), + + ?line [Cp0, Cp1, Cp2, Cp3, Cp4, Cp5, Cp6, Cp7, Cp8] + = start_nodes([cp0, cp1, cp2, cp3, cp4, cp5, cp6, cp7, cp8], + peer, Config), + Nodes = lists:sort([node(), Cp0, Cp1, Cp2, Cp3, Cp4, Cp5, Cp6, Cp7, Cp8]), + + ?line wait_for_ready_net(Config), + + Time = msec() + 7000, + + ?line rpc_cast(Cp0, ?MODULE, single_node, [Time, Cp8, Config]), + ?line rpc_cast(Cp1, ?MODULE, single_node, [Time, Cp0, Config]), + ?line rpc_cast(Cp2, ?MODULE, single_node, [Time, Cp1, Config]), + ?line rpc_cast(Cp3, ?MODULE, single_node, [Time, Cp2, Config]), + ?line rpc_cast(Cp4, ?MODULE, single_node, [Time, Cp3, Config]), + ?line rpc_cast(Cp5, ?MODULE, single_node, [Time, Cp4, Config]), + ?line rpc_cast(Cp6, ?MODULE, single_node, [Time, Cp5, Config]), + ?line rpc_cast(Cp7, ?MODULE, single_node, [Time, Cp6, Config]), + ?line rpc_cast(Cp8, ?MODULE, single_node, [Time, Cp7, Config]), + + % sleep to make the partitioned net ready + test_server:sleep(Time - msec()), + + ?line pong = net_adm:ping(Cp0), + ?line pong = net_adm:ping(Cp1), + ?line pong = net_adm:ping(Cp2), + ?line pong = net_adm:ping(Cp3), + ?line pong = net_adm:ping(Cp4), + ?line pong = net_adm:ping(Cp5), + ?line pong = net_adm:ping(Cp6), + ?line pong = net_adm:ping(Cp7), + ?line pong = net_adm:ping(Cp8), + + ?line pong = net_adm:ping(Cp0), + ?line pong = net_adm:ping(Cp1), + ?line pong = net_adm:ping(Cp2), + ?line pong = net_adm:ping(Cp3), + ?line pong = net_adm:ping(Cp4), + ?line pong = net_adm:ping(Cp5), + ?line pong = net_adm:ping(Cp6), + ?line pong = net_adm:ping(Cp7), + ?line pong = net_adm:ping(Cp8), + + ?line wait_for_ready_net(Nodes, Config), + + % Just make sure that all nodes have the same picture of all names + ?line check_everywhere(Nodes, single_name, Config), + ?line assert_pid(global:whereis_name(single_name)), + + ?line + ?UNTIL(begin + {Ns2, []} = rpc:multicall(Nodes, erlang, whereis, + [single_name]), + 9 =:= lists:foldl(fun(undefined, N) -> N + 1; + (_, N) -> N + end, + 0, Ns2) + end), + + ?line assert_pid(global:send(single_name, die)), + + ?line ?UNTIL(OrigNames =:= global:registered_names()), + + write_high_level_trace(Config), + stop_node(Cp0), + stop_node(Cp1), + stop_node(Cp2), + stop_node(Cp3), + stop_node(Cp4), + stop_node(Cp5), + stop_node(Cp6), + stop_node(Cp7), + stop_node(Cp8), + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + +simple_ring(suite) -> + []; +simple_ring(doc) -> + ["Simpler version of the ring case. Used because there are some", + "distribution problems with many nodes.", + "Make 6 single nodes, all having the same name.", + "Make all ping its predecessor, pinging in a ring.", + "Make sure that there's just one winner."]; +simple_ring(Config) when is_list(Config) -> + Timeout = 60, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + ?line OrigNames = global:registered_names(), + + Names = [cp0, cp1, cp2, cp3, cp4, cp5], + ?line [Cp0, Cp1, Cp2, Cp3, Cp4, Cp5] + = start_nodes(Names, peer, Config), + Nodes = lists:sort([node(), Cp0, Cp1, Cp2, Cp3, Cp4, Cp5]), + + ?line wait_for_ready_net(Config), + + Time = msec() + 5000, + + ?line rpc_cast(Cp0, ?MODULE, single_node, [Time, Cp5, Config]), + ?line rpc_cast(Cp1, ?MODULE, single_node, [Time, Cp0, Config]), + ?line rpc_cast(Cp2, ?MODULE, single_node, [Time, Cp1, Config]), + ?line rpc_cast(Cp3, ?MODULE, single_node, [Time, Cp2, Config]), + ?line rpc_cast(Cp4, ?MODULE, single_node, [Time, Cp3, Config]), + ?line rpc_cast(Cp5, ?MODULE, single_node, [Time, Cp4, Config]), + + % sleep to make the partitioned net ready + test_server:sleep(Time - msec()), + + ?line pong = net_adm:ping(Cp0), + ?line pong = net_adm:ping(Cp1), + ?line pong = net_adm:ping(Cp2), + ?line pong = net_adm:ping(Cp3), + ?line pong = net_adm:ping(Cp4), + ?line pong = net_adm:ping(Cp5), + + ?line pong = net_adm:ping(Cp0), + ?line pong = net_adm:ping(Cp1), + ?line pong = net_adm:ping(Cp2), + ?line pong = net_adm:ping(Cp3), + ?line pong = net_adm:ping(Cp4), + ?line pong = net_adm:ping(Cp5), + + ?line wait_for_ready_net(Nodes, Config), + + % Just make sure that all nodes have the same picture of all names + ?line check_everywhere(Nodes, single_name, Config), + ?line assert_pid(global:whereis_name(single_name)), + + ?line + ?UNTIL(begin + {Ns2, []} = rpc:multicall(Nodes, erlang, whereis, + [single_name]), + 6 =:= lists:foldl(fun(undefined, N) -> N + 1; + (_, N) -> N + end, + 0, Ns2) + end), + + ?line assert_pid(global:send(single_name, die)), + + ?line ?UNTIL(OrigNames =:= global:registered_names()), + + write_high_level_trace(Config), + stop_node(Cp0), + stop_node(Cp1), + stop_node(Cp2), + stop_node(Cp3), + stop_node(Cp4), + stop_node(Cp5), + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + +line(suite) -> + []; +line(doc) -> + ["Make 6 single nodes, all having the same name.", + "Make all ping its predecessor, pinging in a line.", + "Make sure that there's just one winner."]; +line(Config) when is_list(Config) -> + Timeout = 60, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + ?line OrigNames = global:registered_names(), + + ?line [Cp0, Cp1, Cp2, Cp3, Cp4, Cp5, Cp6, Cp7, Cp8] + = start_nodes([cp0, cp1, cp2, cp3, cp4, cp5, cp6, cp7, cp8], + peer, Config), + Nodes = lists:sort([node(), Cp0, Cp1, Cp2, Cp3, Cp4, Cp5, Cp6, Cp7, Cp8]), + + ?line wait_for_ready_net(Config), + + Time = msec() + 7000, + + ?line rpc_cast(Cp0, ?MODULE, single_node, + [Time, Cp0, Config]), % ping ourself! + ?line rpc_cast(Cp1, ?MODULE, single_node, [Time, Cp0, Config]), + ?line rpc_cast(Cp2, ?MODULE, single_node, [Time, Cp1, Config]), + ?line rpc_cast(Cp3, ?MODULE, single_node, [Time, Cp2, Config]), + ?line rpc_cast(Cp4, ?MODULE, single_node, [Time, Cp3, Config]), + ?line rpc_cast(Cp5, ?MODULE, single_node, [Time, Cp4, Config]), + ?line rpc_cast(Cp6, ?MODULE, single_node, [Time, Cp5, Config]), + ?line rpc_cast(Cp7, ?MODULE, single_node, [Time, Cp6, Config]), + ?line rpc_cast(Cp8, ?MODULE, single_node, [Time, Cp7, Config]), + + % sleep to make the partitioned net ready + test_server:sleep(Time - msec()), + + ?line pong = net_adm:ping(Cp0), + ?line pong = net_adm:ping(Cp1), + ?line pong = net_adm:ping(Cp2), + ?line pong = net_adm:ping(Cp3), + ?line pong = net_adm:ping(Cp4), + ?line pong = net_adm:ping(Cp5), + ?line pong = net_adm:ping(Cp6), + ?line pong = net_adm:ping(Cp7), + ?line pong = net_adm:ping(Cp8), + + ?line pong = net_adm:ping(Cp0), + ?line pong = net_adm:ping(Cp1), + ?line pong = net_adm:ping(Cp2), + ?line pong = net_adm:ping(Cp3), + ?line pong = net_adm:ping(Cp4), + ?line pong = net_adm:ping(Cp5), + ?line pong = net_adm:ping(Cp6), + ?line pong = net_adm:ping(Cp7), + ?line pong = net_adm:ping(Cp8), + + ?line wait_for_ready_net(Nodes, Config), + + % Just make sure that all nodes have the same picture of all names + ?line check_everywhere(Nodes, single_name, Config), + ?line assert_pid(global:whereis_name(single_name)), + + ?line + ?UNTIL(begin + {Ns2, []} = rpc:multicall(Nodes, erlang, whereis, + [single_name]), + 9 =:= lists:foldl(fun(undefined, N) -> N + 1; + (_, N) -> N + end, + 0, Ns2) + end), + + ?line assert_pid(global:send(single_name, die)), + + ?line ?UNTIL(OrigNames =:= global:registered_names()), + + write_high_level_trace(Config), + stop_node(Cp0), + stop_node(Cp1), + stop_node(Cp2), + stop_node(Cp3), + stop_node(Cp4), + stop_node(Cp5), + stop_node(Cp6), + stop_node(Cp7), + stop_node(Cp8), + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + + +simple_line(suite) -> + []; +simple_line(doc) -> + ["Simpler version of the line case. Used because there are some", + "distribution problems with many nodes.", + "Make 6 single nodes, all having the same name.", + "Make all ping its predecessor, pinging in a line.", + "Make sure that there's just one winner."]; +simple_line(Config) when is_list(Config) -> + Timeout = 60, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + ?line OrigNames = global:registered_names(), + + ?line [Cp0, Cp1, Cp2, Cp3, Cp4, Cp5] + = start_nodes([cp0, cp1, cp2, cp3, cp4, cp5], peer, Config), + Nodes = lists:sort([node(), Cp0, Cp1, Cp2, Cp3, Cp4, Cp5]), + + ?line wait_for_ready_net(Config), + + Time = msec() + 5000, + + ?line rpc_cast(Cp0, ?MODULE, single_node, + [Time, Cp0, Config]), % ping ourself! + ?line rpc_cast(Cp1, ?MODULE, single_node, [Time, Cp0, Config]), + ?line rpc_cast(Cp2, ?MODULE, single_node, [Time, Cp1, Config]), + ?line rpc_cast(Cp3, ?MODULE, single_node, [Time, Cp2, Config]), + ?line rpc_cast(Cp4, ?MODULE, single_node, [Time, Cp3, Config]), + ?line rpc_cast(Cp5, ?MODULE, single_node, [Time, Cp4, Config]), + + % sleep to make the partitioned net ready + test_server:sleep(Time - msec()), + + ?line pong = net_adm:ping(Cp0), + ?line pong = net_adm:ping(Cp1), + ?line pong = net_adm:ping(Cp2), + ?line pong = net_adm:ping(Cp3), + ?line pong = net_adm:ping(Cp4), + ?line pong = net_adm:ping(Cp5), + + ?line pong = net_adm:ping(Cp0), + ?line pong = net_adm:ping(Cp1), + ?line pong = net_adm:ping(Cp2), + ?line pong = net_adm:ping(Cp3), + ?line pong = net_adm:ping(Cp4), + ?line pong = net_adm:ping(Cp5), + + ?line wait_for_ready_net(Nodes, Config), + + % Just make sure that all nodes have the same picture of all names + ?line check_everywhere(Nodes, single_name, Config), + ?line assert_pid(global:whereis_name(single_name)), + + ?line + ?UNTIL(begin + {Ns2, []} = rpc:multicall(Nodes, erlang, whereis, + [single_name]), + 6 =:= lists:foldl(fun(undefined, N) -> N + 1; + (_, N) -> N + end, + 0, Ns2) + end), + + ?line assert_pid(global:send(single_name, die)), + + ?line ?UNTIL(OrigNames =:= global:registered_names()), + + write_high_level_trace(Config), + stop_node(Cp0), + stop_node(Cp1), + stop_node(Cp2), + stop_node(Cp3), + stop_node(Cp4), + stop_node(Cp5), + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + +otp_1849(suite) -> []; +otp_1849(doc) -> + ["Test ticket: Global should keep track of all pids that set the same lock."]; +otp_1849(Config) when is_list(Config) -> + Timeout = 30, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + ?line {ok, Cp1} = start_node(cp1, Config), + ?line {ok, Cp2} = start_node(cp2, Config), + ?line {ok, Cp3} = start_node(cp3, Config), + + ?line wait_for_ready_net(Config), + + % start procs on each node + ?line Pid1 = rpc:call(Cp1, ?MODULE, start_proc, []), + ?line assert_pid(Pid1), + ?line Pid2 = rpc:call(Cp2, ?MODULE, start_proc, []), + ?line assert_pid(Pid2), + ?line Pid3 = rpc:call(Cp3, ?MODULE, start_proc, []), + ?line assert_pid(Pid3), + + % set a lock on every node + ?line true = req(Pid1, {set_lock2, {test_lock, ?MODULE}, self()}), + ?line true = req(Pid2, {set_lock2, {test_lock, ?MODULE}, self()}), + ?line true = req(Pid3, {set_lock2, {test_lock, ?MODULE}, self()}), + + ?line + ?UNTIL(begin + [{test_lock, ?MODULE, Lock1}] = + rpc:call(Cp1, ets, tab2list, [global_locks]), + 3 =:= length(Lock1) + end), + + ?line true = req(Pid3, {del_lock2, {test_lock, ?MODULE}, self()}), + ?line + ?UNTIL(begin + [{test_lock, ?MODULE, Lock2}] = + rpc:call(Cp1, ets, tab2list, [global_locks]), + 2 =:= length(Lock2) + end), + + ?line true = req(Pid2, {del_lock2, {test_lock, ?MODULE}, self()}), + ?line + ?UNTIL(begin + [{test_lock, ?MODULE, Lock3}] = + rpc:call(Cp1, ets, tab2list, [global_locks]), + 1 =:= length(Lock3) + end), + + ?line true = req(Pid1, {del_lock2, {test_lock, ?MODULE}, self()}), + ?line ?UNTIL([] =:= rpc:call(Cp1, ets, tab2list, [global_locks])), + + + ?line true = req(Pid1, {set_lock2, {test_lock, ?MODULE}, self()}), + ?line true = req(Pid2, {set_lock2, {test_lock, ?MODULE}, self()}), + ?line true = req(Pid3, {set_lock2, {test_lock, ?MODULE}, self()}), + ?line false = req(Pid2, {set_lock2, {test_lock, not_valid}, self()}), + + exit_p(Pid1), + ?line + ?UNTIL(begin + [{test_lock, ?MODULE, Lock10}] = + rpc:call(Cp1, ets, tab2list, [global_locks]), + 2 =:= length(Lock10) + end), + ?line + ?UNTIL(begin + [{test_lock, ?MODULE, Lock11}] = + rpc:call(Cp2, ets, tab2list, [global_locks]), + 2 =:= length(Lock11) + end), + ?line + ?UNTIL(begin + [{test_lock, ?MODULE, Lock12}] = + rpc:call(Cp3, ets, tab2list, [global_locks]), + 2 =:= length(Lock12) + end), + + write_high_level_trace(Config), + stop_node(Cp1), + stop_node(Cp2), + stop_node(Cp3), + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + + +otp_3162(suite) -> []; +otp_3162(doc) -> + ["Test ticket: Deadlock in global"]; +otp_3162(Config) when is_list(Config) -> + StartFun = fun() -> + {ok, Cp1} = start_node(cp1, Config), + {ok, Cp2} = start_node(cp2, Config), + {ok, Cp3} = start_node(cp3, Config), + [Cp1, Cp2, Cp3] + end, + do_otp_3162(StartFun, Config). + +do_otp_3162(StartFun, Config) -> + Timeout = 30, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + ?line [Cp1, Cp2, Cp3] = StartFun(), + + ?line wait_for_ready_net(Config), + + % start procs on each node + ?line Pid1 = rpc:call(Cp1, ?MODULE, start_proc4, [kalle]), + ?line assert_pid(Pid1), + ?line Pid2 = rpc:call(Cp2, ?MODULE, start_proc4, [stina]), + ?line assert_pid(Pid2), + ?line Pid3 = rpc:call(Cp3, ?MODULE, start_proc4, [vera]), + ?line assert_pid(Pid3), + + ?line rpc_disconnect_node(Cp1, Cp2, Config), + + ?line ?UNTIL + ([Cp3] =:= lists:sort(rpc:call(Cp1, erlang, nodes, [])) -- [node()]), + + ?line ?UNTIL([kalle, test_server, vera] =:= + lists:sort(rpc:call(Cp1, global, registered_names, []))), + ?line ?UNTIL + ([Cp3] =:= lists:sort(rpc:call(Cp2, erlang, nodes, [])) -- [node()]), + ?line ?UNTIL([stina, test_server, vera] =:= + lists:sort(rpc:call(Cp2, global, registered_names, []))), + ?line ?UNTIL + ([Cp1, Cp2] =:= + lists:sort(rpc:call(Cp3, erlang, nodes, [])) -- [node()]), + ?line ?UNTIL([kalle, stina, test_server, vera] =:= + lists:sort(rpc:call(Cp3, global, registered_names, []))), + + ?line pong = rpc:call(Cp2, net_adm, ping, [Cp1]), + + ?line ?UNTIL + ([Cp2, Cp3] =:= + lists:sort(rpc:call(Cp1, erlang, nodes, [])) -- [node()]), + ?line + ?UNTIL(begin + NN = lists:sort(rpc:call(Cp1, global, registered_names, [])), + [kalle, stina, test_server, vera] =:= NN + end), + ?line ?UNTIL + ([Cp1, Cp3] =:= + lists:sort(rpc:call(Cp2, erlang, nodes, [])) -- [node()]), + ?line ?UNTIL([kalle, stina, test_server, vera] =:= + lists:sort(rpc:call(Cp2, global, registered_names, []))), + ?line ?UNTIL + ([Cp1, Cp2] =:= + lists:sort(rpc:call(Cp3, erlang, nodes, [])) -- [node()]), + ?line ?UNTIL([kalle, stina, test_server, vera] =:= + lists:sort(rpc:call(Cp3, global, registered_names, []))), + + write_high_level_trace(Config), + stop_node(Cp1), + stop_node(Cp2), + stop_node(Cp3), + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + + +otp_5640(suite) -> []; +otp_5640(doc) -> + ["OTP-5640. 'allow' multiple names for registered processes."]; +otp_5640(Config) when is_list(Config) -> + Timeout = 25, + ?line Dog = test_server:timetrap(test_server:seconds(Timeout)), + init_high_level_trace(Timeout), + init_condition(Config), + ?line {ok, B} = start_node(b, Config), + + ?line Nodes = lists:sort([node(), B]), + ?line wait_for_ready_net(Nodes, Config), + + Server = whereis(global_name_server), + ServerB = rpc:call(B, erlang, whereis, [global_name_server]), + + Me = self(), + Proc = spawn(fun() -> otp_5640_proc(Me) end), + + ?line yes = global:register_name(name1, Proc), + ?line no = global:register_name(name2, Proc), + + ?line ok = application:set_env(kernel, global_multi_name_action, allow), + ?line yes = global:register_name(name2, Proc), + + test_server:sleep(100), + ?line Proc = global:whereis_name(name1), + ?line Proc = global:whereis_name(name2), + ?line check_everywhere(Nodes, name1, Config), + ?line check_everywhere(Nodes, name2, Config), + + ?line {monitors_2levels, MonBy1} = mon_by_servers(Proc), + ?line [] = ([Server,Server,ServerB,ServerB] -- MonBy1), + ?line {links,[]} = process_info(Proc, links), + ?line _ = global:unregister_name(name1), + + test_server:sleep(100), + ?line undefined = global:whereis_name(name1), + ?line Proc = global:whereis_name(name2), + ?line check_everywhere(Nodes, name1, Config), + ?line check_everywhere(Nodes, name2, Config), + + ?line {monitors_2levels, MonBy2} = mon_by_servers(Proc), + ?line [] = ([Server,ServerB] -- MonBy2), + TmpMonBy2 = MonBy2 -- [Server,ServerB], + ?line TmpMonBy2 = TmpMonBy2 -- [Server,ServerB], + ?line {links,[]} = process_info(Proc, links), + + ?line yes = global:register_name(name1, Proc), + + Proc ! die, + + test_server:sleep(100), + ?line undefined = global:whereis_name(name1), + ?line undefined = global:whereis_name(name2), + ?line check_everywhere(Nodes, name1, Config), + ?line check_everywhere(Nodes, name2, Config), + ?line {monitors, GMonitors} = process_info(Server, monitors), + ?line false = lists:member({process, Proc}, GMonitors), + + write_high_level_trace(Config), + stop_node(B), + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + +otp_5640_proc(_Parent) -> + receive + die -> + exit(normal) + end. + +otp_5737(suite) -> []; +otp_5737(doc) -> + ["OTP-5737. set_lock/3 and trans/4 accept Retries = 0."]; +otp_5737(Config) when is_list(Config) -> + Timeout = 25, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + + LockId = {?MODULE,self()}, + Nodes = [node()], + ?line {'EXIT', _} = (catch global:set_lock(LockId, Nodes, -1)), + ?line {'EXIT', _} = (catch global:set_lock(LockId, Nodes, a)), + ?line true = global:set_lock(LockId, Nodes, 0), + Time1 = now(), + ?line false = global:set_lock({?MODULE,not_me}, Nodes, 0), + ?line true = timer:now_diff(now(), Time1) < 5000, + ?line _ = global:del_lock(LockId, Nodes), + + Fun = fun() -> ok end, + ?line {'EXIT', _} = (catch global:trans(LockId, Fun, Nodes, -1)), + ?line {'EXIT', _} = (catch global:trans(LockId, Fun, Nodes, a)), + ?line ok = global:trans(LockId, Fun, Nodes, 0), + + write_high_level_trace(Config), + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + +otp_6931(suite) -> []; +otp_6931(doc) -> ["OTP-6931. Ignore nodeup when connect_all=false."]; +otp_6931(Config) when is_list(Config) -> + Me = self(), + ?line {ok, CAf} = start_non_connecting_node(ca_false, Config), + ?line ok = rpc:call(CAf, error_logger, add_report_handler, [?MODULE, Me]), + ?line info = rpc:call(CAf, error_logger, warning_map, []), + ?line {global_name_server,CAf} ! {nodeup, fake_node}, + timer:sleep(100), + stop_node(CAf), + receive {nodeup,fake_node} -> test_server:fail({info_report, was, sent}) + after 1000 -> ok + end, + ok. + +%%%----------------------------------------------------------------- +%%% Testing a disconnected node. Not two partitions. +%%%----------------------------------------------------------------- +simple_disconnect(suite) -> []; +simple_disconnect(doc) -> ["OTP-5563. Disconnected nodes (not partitions)"]; +simple_disconnect(Config) when is_list(Config) -> + Timeout = 30, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + ?line OrigNames = global:registered_names(), + + %% Three nodes (test_server, n_1, n_2). + ?line [Cp1, Cp2] = Cps = start_nodes([n_1, n_2], peer, Config), + ?line wait_for_ready_net(Config), + + Nodes = lists:sort([node() | Cps]), + + lists:foreach(fun(N) -> rpc:call(N, ?MODULE, start_tracer, []) end,Nodes), + + Name = name, + Resolver = {no_module, resolve_none}, % will never be called + PingNode = Cp2, + + ?line {_Pid1, yes} = + rpc:call(Cp1, ?MODULE, start_resolver, [Name, Resolver]), + test_server:sleep(100), + + %% Disconnect test_server and Cp2. + ?line true = erlang:disconnect_node(Cp2), + test_server:sleep(500), + + %% _Pid is registered on Cp1. The exchange of names between Cp2 and + %% test_server sees two identical pids. + ?line pong = net_adm:ping(PingNode), + ?line ?UNTIL(Cps =:= lists:sort(nodes())), + + ?line {_, Trace0} = collect_tracers(Nodes), + ?line Resolvers = [P || {_Node,new_resolver,{pid,P}} <- Trace0], + ?line lists:foreach(fun(P) -> P ! die end, Resolvers), + ?line lists:foreach(fun(P) -> wait_for_exit(P) end, Resolvers), + ?line check_everywhere(Nodes, Name, Config), + ?line undefined = global:whereis_name(Name), + + ?line {_, Trace1} = collect_tracers(Nodes), + Trace = Trace0 ++ Trace1, + ?line [] = [foo || {_, resolve_none, _, _} <- Trace], + + ?line Gs = name_servers(Nodes), + ?line [_, _, _] = monitored_by_node(Trace, Gs), + + lists:foreach(fun(N) -> rpc:call(N, ?MODULE, stop_tracer, []) end, Nodes), + + ?line OrigNames = global:registered_names(), + write_high_level_trace(Config), + stop_nodes(Cps), + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + +%% Not used right now. +simple_dis(Nodes0, Name, Resolver, Config) -> + Nodes = [node() | Nodes0], + NN = lists:zip(Nodes, lists:seq(1, length(Nodes))), + [{_Node,Other} | Dis] = + [{N,[N1 || {N1,I1} <- NN, I1 > I + 1]} || {N,I} <- NN], + lists:foreach( + fun({Node, DisNodes}) -> + Args = [Node, DisNodes, Name, Resolver], + ok = rpc:call(Node, ?MODULE, simple_dis_node, Args) + end, Dis), + ok = simple_dis_node(node(), Other, Name, Resolver, Config). + +simple_dis_node(_Node, DisNodes, _Name, _Resolver, Config) -> + lists:foreach( + fun(OtherNode) -> _ = erlang:disconnect_node(OtherNode) end, DisNodes), + ?line ?UNTIL(DisNodes -- nodes() =:= DisNodes), + ok. + + + +%%%----------------------------------------------------------------- +%%% Testing resolve of name. Many combinations with four nodes. +%%%----------------------------------------------------------------- +-record(cf, { + link, % node expected to have registered process running + ping, % node in partition 2 to be pinged + n1, % node starting registered process in partition 1 + n2, % node starting registered process in partition 2 + nodes, % nodes expected to exist after ping + n_res, % expected number of resolvers after ping + config + }). + +-define(RES(F), {F, fun ?MODULE:F/3}). + +simple_resolve(suite) -> []; +simple_resolve(doc) -> ["OTP-5563. Partitions and names."]; +simple_resolve(Config) when is_list(Config) -> + Timeout = 360, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + ?line OrigNames = global:registered_names(), + + ?line [N1, A2, Z2] = Cps = start_nodes([n_1, a_2, z_2], peer, Config), + Nodes = lists:sort([node() | Cps]), + ?line wait_for_ready_net(Config), + + lists:foreach(fun(N) -> + rpc:call(N, ?MODULE, start_tracer, []) + end, Nodes), + + %% There used to be a link between global_name_server and the + %% registered name. Now there are only monitors, but the field + %% name 'link' remains... + + Cf = #cf{link = none, ping = A2, n1 = node(), n2 = A2, + nodes = [node(), N1, A2, Z2], n_res = 2, config = Config}, + + %% There is no test with a resolver that deletes a pid (like + %% global_exit_name does). The resulting DOWN signal just clears + %% out the pid from the tables, which should be harmless. So all + %% tests are done with resolvers that keep both processes. This + %% should catch all cases which used to result in bogus process + %% links (now: only monitors are used). + + %% Two partitions are created in each case below: [node(), n_1] + %% and [a_2, z_2]. A name ('name') is registered in both + %% partitions whereafter node() or n_1 pings a_2 or z_2. Note that + %% node() = test_server, which means that node() < z_2 and node() + %% > a_2. The lesser node calls the resolver. + + %% [The following comment does not apply now that monitors are used.] + %% The resolver is run on a_2 with the process on node() + %% as first argument. The process registered as 'name' on a_2 is + %% removed from the tables. It is unlinked from a_2, and the new + %% process (on node()) is inserted without trying to link to it + %% (it it known to run on some other node, in the other + %% partition). The new process is not sent to the other partition + %% for update since it already exists there. + res(?RES(resolve_first), Cps, Cf#cf{link = node(), n2 = A2}), + %% The same, but the z_2 takes the place of a_2. + res(?RES(resolve_first), Cps, Cf#cf{link = node(), n2 = Z2}), + %% The resolver is run on test_server. + res(?RES(resolve_first), Cps, Cf#cf{link = A2, n2 = A2, ping = Z2}), + res(?RES(resolve_first), Cps, Cf#cf{link = Z2, n2 = Z2, ping = Z2}), + %% Now the same tests but with n_1 taking the place of test_server. + res(?RES(resolve_first), Cps, Cf#cf{link = N1, n1 = N1, n2 = A2}), + res(?RES(resolve_first), Cps, Cf#cf{link = N1, n1 = N1, n2 = Z2}), + res(?RES(resolve_first), Cps, Cf#cf{link = A2, n1 = N1, n2 = A2, ping = Z2}), + res(?RES(resolve_first), Cps, Cf#cf{link = Z2, n1 = N1, n2 = Z2, ping = Z2}), + + %% [Maybe this set of tests is the same as (ismorphic to?) the last one.] + %% The resolver is run on a_2 with the process on node() + %% as first argument. The process registered as 'name' on a_2 is + %% the one kept. The old process is unlinked on node(), and the + %% new process (on a_2) is inserted without trying to link to it + %% (it it known to run on some other node). + res(?RES(resolve_second), Cps, Cf#cf{link = A2, n2 = A2}), + %% The same, but the z_2 takes the place of a_2. + res(?RES(resolve_second), Cps, Cf#cf{link = Z2, n2 = Z2}), + %% The resolver is run on test_server. + res(?RES(resolve_second), Cps, Cf#cf{link = node(), n2 = A2, ping = Z2}), + res(?RES(resolve_second), Cps, Cf#cf{link = node(), n2 = Z2, ping = Z2}), + %% Now the same tests but with n_1 taking the place of test_server. + res(?RES(resolve_second), Cps, Cf#cf{link = A2, n1 = N1, n2 = A2}), + res(?RES(resolve_second), Cps, Cf#cf{link = Z2, n1 = N1, n2 = Z2}), + res(?RES(resolve_second), Cps, Cf#cf{link = N1, n1 = N1, n2 = A2, ping = Z2}), + res(?RES(resolve_second), Cps, Cf#cf{link = N1, n1 = N1, n2 = Z2, ping = Z2}), + + %% A resolver that does not return one of the pids. + res(?RES(bad_resolver), Cps, Cf#cf{n2 = A2}), + res(?RES(bad_resolver), Cps, Cf#cf{n2 = Z2}), + %% The resolver is run on test_server. + res(?RES(bad_resolver), Cps, Cf#cf{n2 = A2, ping = Z2}), + res(?RES(bad_resolver), Cps, Cf#cf{n2 = Z2, ping = Z2}), + %% Now the same tests but with n_1 taking the place of test_server. + res(?RES(bad_resolver), Cps, Cf#cf{n1 = N1, n2 = A2}), + res(?RES(bad_resolver), Cps, Cf#cf{n1 = N1, n2 = Z2}), + res(?RES(bad_resolver), Cps, Cf#cf{n1 = N1, n2 = A2, ping = Z2}), + res(?RES(bad_resolver), Cps, Cf#cf{n1 = N1, n2 = Z2, ping = Z2}), + + %% Both processes are unlinked (demonitored). + res(?RES(resolve_none), Cps, Cf#cf{n2 = A2}), + res(?RES(resolve_none), Cps, Cf#cf{n2 = Z2}), + res(?RES(resolve_none), Cps, Cf#cf{n2 = A2, ping = Z2}), + res(?RES(resolve_none), Cps, Cf#cf{n2 = Z2, ping = Z2}), + res(?RES(resolve_none), Cps, Cf#cf{n1 = N1, n2 = A2}), + res(?RES(resolve_none), Cps, Cf#cf{n1 = N1, n2 = Z2}), + res(?RES(resolve_none), Cps, Cf#cf{n1 = N1, n2 = A2, ping = Z2}), + res(?RES(resolve_none), Cps, Cf#cf{n1 = N1, n2 = Z2, ping = Z2}), + + %% A resolver faking badrpc. The resolver is run on a_2, and the + %% process on node() is kept. + res(?RES(badrpc_resolver), Cps, Cf#cf{link = node(), n2 = A2}), + + %% An exiting resolver. A kind of badrpc. + res(?RES(exit_resolver), Cps, Cf#cf{link = node(), n2 = A2}), + res(?RES(exit_resolver), Cps, Cf#cf{link = node(), n2 = Z2}), + res(?RES(exit_resolver), Cps, Cf#cf{link = A2, n2 = A2, ping = Z2}), + res(?RES(exit_resolver), Cps, Cf#cf{link = Z2, n2 = Z2, ping = Z2}), + res(?RES(exit_resolver), Cps, Cf#cf{link = N1, n1 = N1, n2 = A2}), + res(?RES(exit_resolver), Cps, Cf#cf{link = N1, n1 = N1, n2 = Z2}), + res(?RES(exit_resolver), Cps, Cf#cf{link = A2, n1 = N1, n2 = A2, ping = Z2}), + res(?RES(exit_resolver), Cps, Cf#cf{link = Z2, n1 = N1, n2 = Z2, ping = Z2}), + + %% A locker that takes a lock. It used to be that the + %% global_name_server was busy exchanging names, which caused a + %% deadlock. + res(?RES(lock_resolver), Cps, Cf#cf{link = node()}), + + %% A resolver that disconnects from the node of the first pid + %% once. The nodedown message is processed (the resolver killed), + %% then a new attempt (nodeup etc.) is made. This time the + %% resolver does not disconnect any node. + res(?RES(disconnect_first), Cps, Cf#cf{link = Z2, n2 = Z2, + nodes = [node(), N1, A2, Z2]}), + + ?line lists:foreach(fun(N) -> + rpc:call(N, ?MODULE, stop_tracer, []) + end, Nodes), + + ?line OrigNames = global:registered_names(), + write_high_level_trace(Config), + stop_nodes(Cps), + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + +simple_resolve2(suite) -> []; +simple_resolve2(doc) -> ["OTP-5563. Partitions and names."]; +simple_resolve2(Config) when is_list(Config) -> + %% Continuation of simple_resolve. Of some reason it did not + %% always work to re-start z_2. "Cannot be a global bug." + + Timeout = 30, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + ?line OrigNames = global:registered_names(), + + ?line [N1, A2, Z2] = Cps = start_nodes([n_1, a_2, z_2], peer, Config), + ?line wait_for_ready_net(Config), + Nodes = lists:sort([node() | Cps]), + + lists:foreach(fun(N) -> + rpc:call(N, ?MODULE, start_tracer, []) + end, Nodes), + + Cf = #cf{link = none, ping = A2, n1 = node(), n2 = A2, + nodes = [node(), N1, A2, Z2], n_res = 2, config = Config}, + + %% Halt z_2. + res(?RES(halt_second), Cps, Cf#cf{link = N1, n1 = N1, n2 = Z2, ping = A2, + nodes = [node(), N1, A2], n_res = 1}), + + ?line lists:foreach(fun(N) -> + rpc:call(N, ?MODULE, stop_tracer, []) + end, Nodes), + + ?line OrigNames = global:registered_names(), + write_high_level_trace(Config), + stop_nodes(Cps), % Not all nodes may be present, but it works anyway. + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + +simple_resolve3(suite) -> []; +simple_resolve3(doc) -> ["OTP-5563. Partitions and names."]; +simple_resolve3(Config) when is_list(Config) -> + %% Continuation of simple_resolve. + + Timeout = 30, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + ?line OrigNames = global:registered_names(), + + ?line [N1, A2, Z2] = Cps = start_nodes([n_1, a_2, z_2], peer, Config), + ?line wait_for_ready_net(Config), + Nodes = lists:sort([node() | Cps]), + + lists:foreach(fun(N) -> + rpc:call(N, ?MODULE, start_tracer, []) + end, Nodes), + + Cf = #cf{link = none, ping = A2, n1 = node(), n2 = A2, + nodes = [node(), N1, A2, Z2], n_res = 2, config = Config}, + + %% Halt a_2. + res(?RES(halt_second), Cps, Cf#cf{link = node(), n2 = A2, + nodes = [node(), N1], n_res = 1}), + + ?line lists:foreach(fun(N) -> + rpc:call(N, ?MODULE, stop_tracer, []) + end, Nodes), + + ?line OrigNames = global:registered_names(), + write_high_level_trace(Config), + stop_nodes(Cps), % Not all nodes may be present, but it works anyway. + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + +res({Res,Resolver}, [N1, A2, Z2], Cf) -> + %% Note: there are no links anymore, but monitors. + #cf{link = LinkedNode, ping = PingNode, n1 = Res1, n2 = OtherNode, + nodes = Nodes0, n_res = NRes, config = Config} = Cf, + ?t:format("~n~nResolver: ~p", [Res]), + ?t:format(" Registered on partition 1: ~p", [Res1]), + ?t:format(" Registered on partition 2: ~p", [OtherNode]), + ?t:format(" Pinged node: ~p", [PingNode]), + ?t:format(" Linked node: ~p", [LinkedNode]), + ?t:format(" Expected # resolvers: ~p", [NRes]), + Nodes = lists:sort(Nodes0), + T1 = node(), + Part1 = [T1, N1], + Part2 = [A2, Z2], + Name = name, + + %% A registered name is resolved in different scenarios with just + %% four nodes. In each scenario it is checked that exactly the + %% expected monitors remain between registered processes and the + %% global_name_server. + + ?line rpc_cast(OtherNode, + ?MODULE, + part_2_2, + [Config, Part1, Part2, [{Name, Resolver}]]), + ?line ?UNTIL(is_ready_partition(Config)), + ?line {_Pid1, yes} = + rpc:call(Res1, ?MODULE, start_resolver, [Name, Resolver]), + + ?line pong = net_adm:ping(PingNode), + ?line wait_for_ready_net(Nodes, Config), + + ?line check_everywhere(Nodes, Name, Config), + ?line case global:whereis_name(Name) of + undefined when LinkedNode =:= none -> ok; + Pid -> assert_pid(Pid) + end, + + ?line {_, Trace0} = collect_tracers(Nodes), + ?line Resolvers = [P || {_Node,new_resolver,{pid,P}} <- Trace0], + + ?line NRes = length(Resolvers), + + %% Wait for extra monitor processes to be created. + %% This applies as long as global:do_monitor/1 spawns processes. + %% (Some day monitor() will be truly synchronous.) + test_server:sleep(100), + + ?line lists:foreach(fun(P) -> P ! die end, Resolvers), + ?line lists:foreach(fun(P) -> wait_for_exit(P) end, Resolvers), + + ?line check_everywhere(Nodes, Name, Config), + ?line undefined = global:whereis_name(Name), + + %% Wait for monitors to remove names. + test_server:sleep(100), + + ?line {_, Trace1} = collect_tracers(Nodes), + Trace = Trace0 ++ Trace1, + + ?line Gs = name_servers([T1, N1, A2, Z2]), + ?line MonitoredByNode = monitored_by_node(Trace, Gs), + ?line MonitoredBy = [M || {_N,M} <- MonitoredByNode], + + X = MonitoredBy -- Gs, + LengthGs = length(Gs), + ?line case MonitoredBy of + [] when LinkedNode =:= none -> ok; + Gs -> ok; + _ when LengthGs < 4, X =:= [] -> ok; + _ -> ?t:format("ERROR:~nMonitoredBy ~p~n" + "global_name_servers ~p~n", + [MonitoredByNode, Gs]), + ?t:fail(monitor_mismatch) + end, + ok. + +name_servers(Nodes) -> + lists:sort([rpc:call(N, erlang, whereis, [global_name_server]) || + N <- Nodes, + pong =:= net_adm:ping(N)]). + +monitored_by_node(Trace, Servers) -> + lists:sort([{node(M),M} || + {_Node,_P,died,{monitors_2levels,ML}} <- Trace, + M <- ML, + lists:member(M, Servers)]). + +%% Runs on a node in Part2 +part_2_2(Config, Part1, Part2, NameResolvers) -> + make_partition(Config, Part1, Part2), + lists:foreach + (fun({Name, Resolver}) -> + ?line {Pid2, yes} = start_resolver(Name, Resolver), + trace_message({node(), part_2_2, nodes(), {pid2,Pid2}}) + end, NameResolvers). + +resolve_first(name, Pid1, _Pid2) -> + Pid1. + +resolve_second(name, _Pid1, Pid2) -> + Pid2. + +resolve_none(name, _Pid1, _Pid2) -> + none. + +bad_resolver(name, _Pid1, _Pid2) -> + bad_answer. + +badrpc_resolver(name, _Pid1, _Pid2) -> + {badrpc, badrpc}. + +exit_resolver(name, _Pid1, _Pid2) -> + erlang:error(bad_resolver). + +lock_resolver(name, Pid1, _Pid2) -> + Id = {?MODULE, self()}, + Nodes = [node()], + ?line true = global:set_lock(Id, Nodes), + _ = global:del_lock(Id, Nodes), + Pid1. + +disconnect_first(name, Pid1, Pid2) -> + Name = disconnect_first_name, + case whereis(Name) of + undefined -> + spawn(fun() -> disconnect_first_name(Name) end), + true = erlang:disconnect_node(node(Pid1)); + Pid when is_pid(Pid) -> + Pid ! die + end, + Pid2. + +disconnect_first_name(Name) -> + register(Name, self()), + receive die -> ok end. + +halt_second(name, _Pid1, Pid2) -> + rpc:call(node(Pid2), erlang, halt, []), + Pid2. + +start_resolver(Name, Resolver) -> + Self = self(), + Pid = spawn(fun() -> init_resolver(Self, Name, Resolver) end), + trace_message({node(), new_resolver, {pid, Pid}}), + receive + {Pid, Res} -> {Pid, Res} + end. + +init_resolver(Parent, Name, Resolver) -> + X = global:register_name(Name, self(), Resolver), + Parent ! {self(), X}, + loop_resolver(). + +loop_resolver() -> + receive + die -> + trace_message({node(), self(), died, mon_by_servers(self())}), + exit(normal) + end. + +%% The server sometimes uses an extra process for monitoring. +%% The server monitors that extra process. +mon_by_servers(Proc) -> + {monitored_by, ML} = process_info(Proc, monitored_by), + {monitors_2levels, + lists:append([ML | + [begin + {monitored_by, MML} = rpc:call(node(M), + erlang, + process_info, + [M, monitored_by]), + MML + end || M <- ML]])}. + +-define(REGNAME, contact_a_2). + +leftover_name(suite) -> []; +leftover_name(doc) -> ["OTP-5563. Bug: nodedown while synching."]; +leftover_name(Config) when is_list(Config) -> + Timeout = 30, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + ?line OrigNames = global:registered_names(), + ?line [N1, A2, Z2] = Cps = start_nodes([n_1, a_2, z_2], peer, Config), + Nodes = lists:sort([node() | Cps]), + ?line wait_for_ready_net(Config), + + lists:foreach(fun(N) -> + rpc:call(N, ?MODULE, start_tracer, []) + end, Nodes), + + Name = name, % registered on a_2 + ResName = resolved_name, % registered on n_1 and a_2 + %% + ?line _Pid = ping_a_2_fun(?REGNAME, N1, A2), + + T1 = node(), + Part1 = [T1, N1], + Part2 = [A2, Z2], + NoResolver = {no_module, resolve_none}, + Resolver = fun contact_a_2/3, + ?line rpc_cast(A2, + ?MODULE, part_2_2, [Config, + Part1, + Part2, + [{Name, NoResolver}, + {ResName, Resolver}]]), + ?line ?UNTIL(is_ready_partition(Config)), + + %% resolved_name is resolved to run on a_2, an insert operation is + %% sent to n_1. The resolver function halts a_2, but the nodedown + %% message is handled by n_1 _before_ the insert operation is run + %% (at least every now and then; sometimes it seems to be + %% delayed). Unless "artificial" nodedown messages are sent the + %% name would linger on indefinitely. [There is no test case for + %% the situation that no nodedown message at all is sent.] + ?line {_Pid1, yes} = + rpc:call(N1, ?MODULE, start_resolver, + [ResName, fun contact_a_2/3]), + test_server:sleep(1000), + + ?line trace_message({node(), pinging, z_2}), + ?line pong = net_adm:ping(Z2), + ?line ?UNTIL((Nodes -- [A2]) =:= lists:sort(?NODES)), + ?t:sleep(1000), + + ?line {_,Trace0} = collect_tracers(Nodes), + + ?line Resolvers = [P || {_Node,new_resolver,{pid,P}} <- Trace0], + ?line lists:foreach(fun(P) -> P ! die end, Resolvers), + ?line lists:foreach(fun(P) -> wait_for_exit(P) end, Resolvers), + + ?line lists:foreach(fun(N) -> + rpc:call(N, ?MODULE, stop_tracer, []) + end, Nodes), + + ?line ?UNTIL(OrigNames =:= global:registered_names()), + write_high_level_trace(Config), + stop_nodes(Cps), + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + +%% Runs on n_1 +contact_a_2(resolved_name, Pid1, Pid2) -> + trace_message({node(), ?REGNAME, {pid1,Pid1}, {pid2,Pid2}, + {node1,node(Pid1)}, {node2,node(Pid2)}}), + ?REGNAME ! doit, + Pid2. + +ping_a_2_fun(RegName, N1, A2) -> + spawn(N1, fun() -> ping_a_2(RegName, N1, A2) end). + +ping_a_2(RegName, N1, A2) -> + register(RegName, self()), + receive doit -> + trace_message({node(), ping_a_2, {a2, A2}}), + monitor_node(A2, true), + %% Establish contact with a_2, then take it down. + rpc:call(N1, ?MODULE, halt_node, [A2]), + receive + {nodedown, A2} -> ok + end + end. + +halt_node(Node) -> + rpc:call(Node, erlang, halt, []). + +%%%----------------------------------------------------------------- +%%% Testing re-registration of a name. +%%%----------------------------------------------------------------- +re_register_name(suite) -> []; +re_register_name(doc) -> ["OTP-5563. Name is re-registered."]; +re_register_name(Config) when is_list(Config) -> + %% When re-registering a name the link to the old pid used to + %% linger on. Don't think is was a serious bug though--some memory + %% occupied by links, that's all. + %% Later: now monitors are checked. + Timeout = 15, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + Me = self(), + Pid1 = spawn(fun() -> proc(Me) end), + ?line yes = global:register_name(name, Pid1), + Pid2 = spawn(fun() -> proc(Me) end), + ?line _ = global:re_register_name(name, Pid2), + Pid2 ! die, + Pid1 ! die, + receive {Pid1, MonitoredBy1} -> [] = MonitoredBy1 end, + receive {Pid2, MonitoredBy2} -> [_] = MonitoredBy2 end, + ?line _ = global:unregister_name(name), + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + +proc(Parent) -> + receive die -> ok end, + {monitored_by, MonitoredBy} = process_info(self(), monitored_by), + Parent ! {self(), MonitoredBy}. + + +%%%----------------------------------------------------------------- +%%% +%%%----------------------------------------------------------------- +name_exit(suite) -> []; +name_exit(doc) -> ["OTP-5563. Registered process dies."]; +name_exit(Config) when is_list(Config) -> + case ?t:is_release_available("r11b") of + true -> + StartOldFun = + fun() -> + {ok, N1} = start_node_rel(n_1, r11b, Config), + {ok, N2} = start_node_rel(n_2, this, Config), + [N1, N2] + end, + ?t:format("Test of r11~n"), + do_name_exit(StartOldFun, old, Config); + false -> + ok + end, + StartFun = fun() -> + {ok, N1} = start_node_rel(n_1, this, Config), + {ok, N2} = start_node_rel(n_2, this, Config), + [N1, N2] + end, + ?t:format("Test of current release~n"), + do_name_exit(StartFun, current, Config). + +do_name_exit(StartFun, Version, Config) -> + %% When a registered process dies, the node where it is registered + %% removes the name from the table immediately, and then removes + %% it from other nodes using a lock. + %% This is perhaps not how it should work, but it is not easy to + %% change. + %% See also OTP-3737. + %% + %% The current release uses monitors so this test is not so relevant. + + Timeout = 60, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + ?line OrigNames = global:registered_names(), + + %% Three nodes (test_server, n_1, n_2). + ?line Cps = StartFun(), + Nodes = lists:sort([node() | Cps]), + ?line wait_for_ready_net(Config), + lists:foreach(fun(N) -> rpc:call(N, ?MODULE, start_tracer, []) end,Nodes), + + Name = name, + ?line {Pid, yes} = start_proc(Name), + + Me = self(), + LL = spawn(fun() -> long_lock(Me) end), + receive + long_lock_taken -> ok + end, + + Pid ! die, + wait_for_exit_fast(Pid), + + ?t:sleep(100), + %% Name has been removed from node()'s table, but nowhere else + %% since there is a lock on 'global'. + {R1,[]} = rpc:multicall(Nodes, global, whereis_name, [Name]), + ?line case Version of + old -> [_,_] = lists:usort(R1); + current -> [undefined, undefined, undefined] = R1 + end, + ?t:sleep(3000), + ?line check_everywhere(Nodes, Name, Config), + + lists:foreach(fun(N) -> rpc:call(N, ?MODULE, stop_tracer, []) end, Nodes), + ?line OrigNames = global:registered_names(), + exit(LL, kill), + write_high_level_trace(Config), + stop_nodes(Cps), + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + +long_lock(Parent) -> + global:trans({?GLOBAL_LOCK,self()}, + fun() -> + Parent ! long_lock_taken, + timer:sleep(3000) + end). + +%%%----------------------------------------------------------------- +%%% Testing the support for external nodes (cnodes) +%%%----------------------------------------------------------------- +external_nodes(suite) -> []; +external_nodes(doc) -> ["OTP-5563. External nodes (cnodes)."]; +external_nodes(Config) when is_list(Config) -> + Timeout = 30, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + ?line OrigNames = global:registered_names(), + + ?line [NodeB, NodeC] = start_nodes([b, c], peer, Config), + ?line wait_for_ready_net(Config), + + %% Nodes = ?NODES, + %% lists:foreach(fun(N) -> rpc:call(N, ?MODULE, start_tracer, []) end, + %% Nodes), + Name = name, + + %% Two partitions: [test_server] and [b, c]. + %% c registers an external name on b + ?line rpc_cast(NodeB, ?MODULE, part_ext, + [Config, node(), NodeC, Name]), + ?line ?UNTIL(is_ready_partition(Config)), + + ?line pong = net_adm:ping(NodeB), + ?line ?UNTIL([NodeB, NodeC] =:= lists:sort(nodes())), + ?line wait_for_ready_net(Config), + + ?line Cpid = rpc:call(NodeC, erlang, whereis, [Name]), + ExternalName = [{name,Cpid,NodeB}], + ?line ExternalName = get_ext_names(), + ?line ExternalName = rpc:call(NodeB, gen_server, call, + [global_name_server, get_names_ext]), + ?line ExternalName = rpc:call(NodeC, gen_server, call, + [global_name_server, get_names_ext]), + + ?line [_] = cnode_links(Cpid), + ?line [_,_,_] = cnode_monitored_by(Cpid), + ?line no = global:register_name(Name, self()), + ?line yes = global:re_register_name(Name, self()), + ?line ?UNTIL([] =:= cnode_monitored_by(Cpid)), + ?line ?UNTIL([] =:= cnode_links(Cpid)), + ?line [] = gen_server:call(global_name_server, get_names_ext, infinity), + + ?line Cpid ! {register, self(), Name}, + ?line receive {Cpid, Reply1} -> no = Reply1 end, + ?line _ = global:unregister_name(Name), + test_server:sleep(1000), + ?line Cpid ! {register, self(), Name}, + ?line ?UNTIL(length(get_ext_names()) =:= 1), + ?line receive {Cpid, Reply2} -> yes = Reply2 end, + + ?line Cpid ! {unregister, self(), Name}, + ?line ?UNTIL(length(get_ext_names()) =:= 0), + ?line receive {Cpid, Reply3} -> ok = Reply3 end, + + Cpid ! die, + ?line ?UNTIL(OrigNames =:= global:registered_names()), + ?line [] = get_ext_names(), + ?line [] = rpc:call(NodeB, gen_server, call, + [global_name_server, get_names_ext]), + ?line [] = rpc:call(NodeC, gen_server, call, + [global_name_server, get_names_ext]), + + ?line Cpid2 = erlang:spawn(NodeC, fun() -> cnode_proc(NodeB) end), + ?line Cpid2 ! {register, self(), Name}, + ?line receive {Cpid2, Reply4} -> yes = Reply4 end, + + %% It could be a bug that Cpid2 is linked to 'global_name_server' + %% at node 'b'. The effect: Cpid2 dies when node 'b' crashes. + stop_node(NodeB), + ?line ?UNTIL(OrigNames =:= global:registered_names()), + ?line [] = get_ext_names(), + ?line [] = rpc:call(NodeC, gen_server, call, + [global_name_server, get_names_ext]), + + %% ?line {_, Trace} = collect_tracers(Nodes), + %% lists:foreach(fun(M) -> erlang:display(M) end, Trace), + + ThisNode = node(), + ?line Cpid3 = erlang:spawn(NodeC, fun() -> cnode_proc(ThisNode) end), + ?line Cpid3 ! {register, self(), Name}, + ?line receive {Cpid3, Reply5} -> yes = Reply5 end, + + ?line ?UNTIL(length(get_ext_names()) =:= 1), + stop_node(NodeC), + ?line ?UNTIL(length(get_ext_names()) =:= 0), + + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + +get_ext_names() -> + gen_server:call(global_name_server, get_names_ext, infinity). + +%% Runs at B +part_ext(Config, Main, C, Name) -> + make_partition(Config, [Main], [node(), C]), + ThisNode = node(), + Pid = erlang:spawn(C, fun() -> cnode_proc(ThisNode) end), + Pid ! {register, self(), Name}, + receive {Pid, Reply} -> yes = Reply end, + rpc:call(C, erlang, register, [Name, Pid]). + +cnode_links(Pid) -> + Pid ! {links, self()}, + receive + {links, Links} -> + Links + end. + +cnode_monitored_by(Pid) -> + Pid ! {monitored_by, self()}, + receive + {monitored_by, MonitoredBy} -> + MonitoredBy + end. + +cnode_proc(E) -> + receive + {register, From, Name} -> + Rep = rpc:call(E, global, register_name_external, [Name, self()]), + From ! {self(), Rep}; + {unregister, From, Name} -> + _ = rpc:call(E, global, unregister_name_external, [Name]), + From ! {self(), ok}; + {links, From} -> + From ! process_info(self(), links); + {monitored_by, From} -> + From ! process_info(self(), monitored_by); + die -> + exit(normal) + end, + cnode_proc(E). + + +many_nodes(suite) -> + []; +many_nodes(doc) -> + ["OTP-5770. Start many nodes. Make them connect at the same time."]; +many_nodes(Config) when is_list(Config) -> + Timeout = 180, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + ?line OrigNames = global:registered_names(), + + {Rels, N_cps} = + case ?t:os_type() of + {unix, Osname} when Osname =:= linux; + Osname =:= openbsd; + Osname =:= darwin -> + N_nodes = quite_a_few_nodes(32), + {node_rel(1, N_nodes, this), N_nodes}; + {unix, _} -> + case ?t:is_release_available("r11b") of + true -> + This = node_rel(1, 16, this), + R11B = node_rel(17, 32, r11b), + {This ++ R11B, 32}; + false -> + {node_rel(1, 32, this), 32} + end; + _ -> + {node_rel(1, 32, this), 32} + end, + ?line Cps = [begin {ok, Cp} = start_node_rel(Name, Rel, Config), Cp end || + {Name,Rel} <- Rels], + Nodes = lists:sort(?NODES), + ?line wait_for_ready_net(Nodes, Config), + + ?line Dir = ?config(priv_dir, Config), + GoFile = filename:join([Dir, "go.txt"]), + file:delete(GoFile), + + CpsFiles = [{N, filename:join([Dir, atom_to_list(N)++".node"])} || + N <- Cps], + IsoFun = + fun({N, File}) -> + file:delete(File), + rpc_cast(N, ?MODULE, isolated_node, [File, GoFile, Cps, Config]) + end, + ?line lists:foreach(IsoFun, CpsFiles), + + ?line all_nodes_files(CpsFiles, "isolated", Config), + ?line Time = msec(), + ?line sync_until(), + erlang:display(ready_to_go), + ?line touch(GoFile, "go"), + ?line all_nodes_files(CpsFiles, "done", Config), + ?line Time2 = msec(), + + ?line lists:foreach(fun(N) -> pong = net_adm:ping(N) end, Cps), + + ?line wait_for_ready_net(Config), + + write_high_level_trace(Config), % The test succeeded, but was it slow? + + ?line lists:foreach(fun({_N, File}) -> file:delete(File) end, CpsFiles), + ?line file:delete(GoFile), + + ?line ?UNTIL(OrigNames =:= global:registered_names()), + write_high_level_trace(Config), + ?line stop_nodes(Cps), + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + Diff = Time2 - Time, + Return = lists:flatten(io_lib:format("~w nodes took ~w ms", + [N_cps, Diff])), + erlang:display({{nodes,N_cps},{time,Diff}}), + ?t:format("~s~n", [Return]), + {comment, Return}. + +node_rel(From, To, Rel) -> + [{lists:concat([cp, N]), Rel} || N <- lists:seq(From, To)]. + +isolated_node(File, GoFile, Nodes, Config) -> + Ns = lists:sort(Nodes), + exit(erlang:whereis(user), kill), + touch(File, "start_isolated"), + NodesList = nodes(), + append_to_file(File, [{nodes,Nodes},{nodes_list,NodesList}]), + Replies = + lists:map(fun(N) -> _ = erlang:disconnect_node(N) end, NodesList), + append_to_file(File, {replies,Replies}), + ?UNTIL(begin + Known = get_known(node()), + append_to_file(File, {known,Known}), + Known =:= [node()] + end), + touch(File, "isolated"), + sync_until(File), + file_contents(GoFile, "go", Config, File), + touch(File, "got_go"), + lists:foreach(fun(N) -> _ = net_adm:ping(N) end, shuffle(Nodes)), + touch(File, "pinged"), + ?line ?UNTIL((Ns -- get_known(node())) =:= []), + touch(File, "done"). + +touch(File, List) -> + ok = file:write_file(File, list_to_binary(List)). + +append_to_file(File, Term) -> + {ok, Fd} = file:open(File, [raw,binary,append]), + ok = file:write(Fd, io_lib:format("~p.~n", [Term])), + ok = file:close(Fd). + +all_nodes_files(CpsFiles, ContentsList, Config) -> + lists:all(fun({_N,File}) -> + file_contents(File, ContentsList, Config) + end, CpsFiles). + +file_contents(File, ContentsList, Config) -> + file_contents(File, ContentsList, Config, no_log_file). + +file_contents(File, ContentsList, Config, LogFile) -> + Contents = list_to_binary(ContentsList), + Sz = size(Contents), + ?UNTIL(begin + case file:read_file(File) of + {ok, FileContents}=Reply -> + case catch split_binary(FileContents, Sz) of + {Contents,_} -> + true; + _ -> + catch append_to_file(LogFile, + {File,Contents,Reply}), + false + end; + Reply -> + catch append_to_file(LogFile, {File, Contents, Reply}), + false + end + end). + +sync_until() -> + sync_until(no_log_file). + +sync_until(LogFile) -> + Time = ?UNTIL_LOOP - (msec(now()) rem ?UNTIL_LOOP), + catch append_to_file(LogFile, {sync_until, Time}), + timer:sleep(Time). + +shuffle(L) -> + [E || {_, E} <- lists:keysort(1, [{random:uniform(), E} || E <- L])]. + +sync_0(suite) -> []; +sync_0(doc) -> + ["OTP-5770. sync/0."]; +sync_0(Config) when is_list(Config) -> + Timeout = 180, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + + N_cps = + case ?t:os_type() of + {unix, Osname} when Osname =:= linux; + Osname =:= openbsd; + Osname =:= darwin -> + quite_a_few_nodes(30); + {unix, sunos} -> + 30; + {unix, _} -> + 16; + _ -> + 30 + end, + + Names = [lists:concat([cp,N]) || N <- lists:seq(1, N_cps)], + Cps = start_and_sync(Names), + ?line wait_for_ready_net(Config), + write_high_level_trace(Config), + stop_nodes(Cps), + + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + +start_and_sync([]) -> + []; +start_and_sync([Name | Names]) -> + ?line {ok, N} = start_node(Name, slave, []), + ?line {Time, _Void} = rpc:call(N, timer, tc, [global, sync, []]), + ?t:format("~p: ~p~n", [Name, Time]), + [N | start_and_sync(Names)]. + +%%%----------------------------------------------------------------- +%%% Testing of change of global_groups parameter. +%%%----------------------------------------------------------------- +global_groups_change(suite) -> []; +global_groups_change(doc) -> ["Test change of global_groups parameter."]; +global_groups_change(Config) -> + Timeout = 90, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + ?line M = from($@, atom_to_list(node())), + + % Create the .app files and the boot script + ?line {KernelVer, StdlibVer} = create_script_dc("dc"), + ?line case is_real_system(KernelVer, StdlibVer) of + true -> + Options = []; + false -> + Options = [local] + end, + + ?line ok = systools:make_script("dc", Options), + + [Ncp1,Ncp2,Ncp3,Ncp4,Ncp5,NcpA,NcpB,NcpC,NcpD,NcpE] = + node_names([cp1,cp2,cp3,cp4,cp5,cpA,cpB,cpC,cpD,cpE], Config), + + % Write config files + ?line Dir = ?config(priv_dir,Config), + ?line {ok, Fd_dc} = file:open(filename:join(Dir, "sys.config"), [write]), + ?line config_dc1(Fd_dc, Ncp1, Ncp2, Ncp3, NcpA, NcpB, NcpC, NcpD, NcpE), + ?line file:close(Fd_dc), + ?line Config1 = filename:join(Dir, "sys"), + + % Test [cp1, cp2, cp3] + ?line {ok, Cp1} = start_node_boot(Ncp1, Config1, dc), + ?line {ok, Cp2} = start_node_boot(Ncp2, Config1, dc), + ?line {ok, Cp3} = start_node_boot(Ncp3, Config1, dc), + ?line {ok, CpA} = start_node_boot(NcpA, Config1, dc), + ?line {ok, CpB} = start_node_boot(NcpB, Config1, dc), + ?line {ok, CpC} = start_node_boot(NcpC, Config1, dc), + ?line {ok, CpD} = start_node_boot(NcpD, Config1, dc), + ?line {ok, CpE} = start_node_boot(NcpE, Config1, dc), + + ?line pong = rpc:call(Cp1, net_adm, ping, [Cp2]), + ?line pong = rpc:call(Cp1, net_adm, ping, [Cp3]), + ?line pang = rpc:call(Cp1, net_adm, ping, + [list_to_atom(lists:concat(["cp5@", M]))]), + ?line pong = rpc:call(Cp2, net_adm, ping, [Cp3]), + ?line pang = rpc:call(Cp2, net_adm, ping, + [list_to_atom(lists:concat(["cp5@", M]))]), + + ?line {TestGG4, yes} = rpc:call(CpB, ?MODULE, start_proc, [test]), + ?line {TestGG5, yes} = rpc:call(CpE, ?MODULE, start_proc, [test]), + + + ?line pong = rpc:call(CpA, net_adm, ping, [CpC]), + ?line pong = rpc:call(CpC, net_adm, ping, [CpB]), + ?line pong = rpc:call(CpD, net_adm, ping, [CpC]), + ?line pong = rpc:call(CpE, net_adm, ping, [CpD]), + + ?line + ?UNTIL(begin + TestGG4_1 = rpc:call(CpA, global, whereis_name, [test]), + TestGG4_2 = rpc:call(CpB, global, whereis_name, [test]), + TestGG4_3 = rpc:call(CpC, global, whereis_name, [test]), + + TestGG5_1 = rpc:call(CpD, global, whereis_name, [test]), + TestGG5_2 = rpc:call(CpE, global, whereis_name, [test]), + io:format("~p~n", [[TestGG4, TestGG4_1, TestGG4_2,TestGG4_3]]), + io:format("~p~n", [[TestGG5, TestGG5_1, TestGG5_2]]), + (TestGG4_1 =:= TestGG4) and + (TestGG4_2 =:= TestGG4) and + (TestGG4_3 =:= TestGG4) and + (TestGG5_1 =:= TestGG5) and + (TestGG5_2 =:= TestGG5) + end), + + ?line ?t:format( "#### nodes() ~p~n",[nodes()]), + + ?line XDcWa1 = rpc:call(Cp1, global_group, info, []), + ?line XDcWa2 = rpc:call(Cp2, global_group, info, []), + ?line XDcWa3 = rpc:call(Cp3, global_group, info, []), + ?line ?t:format( "#### XDcWa1 ~p~n",[XDcWa1]), + ?line ?t:format( "#### XDcWa2 ~p~n",[XDcWa2]), + ?line ?t:format( "#### XDcWa3 ~p~n",[XDcWa3]), + + ?line stop_node(CpC), + + %% Read the current configuration parameters, and change them + ?line OldEnv = + rpc:call(Cp1, application_controller, prep_config_change, []), + ?line {value, {kernel, OldKernel}} = lists:keysearch(kernel, 1, OldEnv), + + ?line GG1 = + lists:sort([mk_node(Ncp1, M), mk_node(Ncp2, M), mk_node(Ncp5, M)]), + ?line GG2 = lists:sort([mk_node(Ncp3, M)]), + ?line GG3 = lists:sort([mk_node(Ncp4, M)]), + ?line GG4 = lists:sort([mk_node(NcpA, M), mk_node(NcpB, M)]), + ?line GG5 = + lists:sort([mk_node(NcpC, M), mk_node(NcpD, M), mk_node(NcpE, M)]), + + ?line NewNG = {global_groups,[{gg1, normal, GG1}, + {gg2, normal, GG2}, + {gg3, normal, GG3}, + {gg4, normal, GG4}, + {gg5, hidden, GG5}]}, + + ?line NewKernel = + [{kernel, lists:keyreplace(global_groups, 1, OldKernel, NewNG)}], + ?line ok = rpc:call(Cp1, application_controller, test_change_apps, + [[kernel], [NewKernel]]), + ?line ok = rpc:call(Cp2, application_controller, test_change_apps, + [[kernel], [NewKernel]]), + ?line ok = rpc:call(Cp3, application_controller, test_change_apps, + [[kernel], [NewKernel]]), + ?line ok = rpc:call(CpA, application_controller, test_change_apps, + [[kernel], [NewKernel]]), + ?line ok = rpc:call(CpB, application_controller, test_change_apps, + [[kernel], [NewKernel]]), + ?line ok = rpc:call(CpD, application_controller, test_change_apps, + [[kernel], [NewKernel]]), + ?line ok = rpc:call(CpE, application_controller, test_change_apps, + [[kernel], [NewKernel]]), + + ?line ?t:format("#### ~p~n",[multicall]), + ?line ?t:format( "#### ~p~n",[multicall]), + %% no idea to check the result from the rpc because the other + %% nodes will disconnect test server, and thus the result will + %% always be {badrpc, nodedown} + ?line rpc:multicall([Cp1, Cp2, Cp3, CpA, CpB, CpD, CpE], + application_controller, config_change, [OldEnv]), + + ?line {ok, Fd_dc2} = file:open(filename:join(Dir, "sys2.config"), [write]), + ?line config_dc2(Fd_dc2, NewNG, Ncp1, Ncp2, Ncp3), + ?line file:close(Fd_dc2), + ?line Config2 = filename:join(Dir, "sys2"), + ?line {ok, CpC} = start_node_boot(NcpC, Config2, dc), + + ?line sync_and_wait(CpA), + ?line sync_and_wait(CpD), + + ?line pong = rpc:call(CpA, net_adm, ping, [CpC]), + ?line pong = rpc:call(CpC, net_adm, ping, [CpB]), + ?line pong = rpc:call(CpD, net_adm, ping, [CpC]), + ?line pong = rpc:call(CpE, net_adm, ping, [CpD]), + + ?line GG5 = + lists:sort([mk_node(NcpC, M)|rpc:call(CpC, erlang, nodes, [])]), + ?line GG5 = + lists:sort([mk_node(NcpD, M)|rpc:call(CpD, erlang, nodes, [])]), + ?line GG5 = + lists:sort([mk_node(NcpE, M)|rpc:call(CpE, erlang, nodes, [])]), + + ?line false = + lists:member(mk_node(NcpC, M), rpc:call(CpA, erlang, nodes, [])), + ?line false = + lists:member(mk_node(NcpC, M), rpc:call(CpB, erlang, nodes, [])), + + ?line + ?UNTIL(begin + TestGG4a = rpc:call(CpA, global, whereis_name, [test]), + TestGG4b = rpc:call(CpB, global, whereis_name, [test]), + + TestGG5c = rpc:call(CpC, global, whereis_name, [test]), + TestGG5d = rpc:call(CpD, global, whereis_name, [test]), + TestGG5e = rpc:call(CpE, global, whereis_name, [test]), + io:format("~p~n", [[TestGG4, TestGG4a, TestGG4b]]), + io:format("~p~n", [[TestGG5, TestGG5c, TestGG5d, TestGG5e]]), + (TestGG4 =:= TestGG4a) and + (TestGG4 =:= TestGG4b) and + (TestGG5 =:= TestGG5c) and + (TestGG5 =:= TestGG5d) and + (TestGG5 =:= TestGG5e) + end), + + ?line Info1 = rpc:call(Cp1, global_group, info, []), + ?line Info2 = rpc:call(Cp2, global_group, info, []), + ?line Info3 = rpc:call(Cp3, global_group, info, []), + ?line InfoA = rpc:call(CpA, global_group, info, []), + ?line InfoB = rpc:call(CpB, global_group, info, []), + ?line InfoC = rpc:call(CpC, global_group, info, []), + ?line InfoD = rpc:call(CpD, global_group, info, []), + ?line InfoE = rpc:call(CpE, global_group, info, []), + ?line ?t:format( "#### Info1 ~p~n",[Info1]), + ?line ?t:format( "#### Info2 ~p~n",[Info2]), + ?line ?t:format( "#### Info3 ~p~n",[Info3]), + ?line ?t:format( "#### InfoA ~p~n",[InfoA]), + ?line ?t:format( "#### InfoB ~p~n",[InfoB]), + ?line ?t:format( "#### InfoC ~p~n",[InfoC]), + ?line ?t:format( "#### InfoD ~p~n",[InfoD]), + ?line ?t:format( "#### InfoE ~p~n",[InfoE]), + + ?line {global_groups, GGNodes} = NewNG, + + ?line Info1ok = [{state, synced}, + {own_group_name, gg1}, + {own_group_nodes, GG1}, + {synced_nodes, [mk_node(Ncp2, M)]}, + {sync_error, []}, + {no_contact, [mk_node(Ncp5, M)]}, + {other_groups, remove_gg_pub_type(lists:keydelete + (gg1, 1, GGNodes))}, + {monitoring, []}], + + + ?line Info2ok = [{state, synced}, + {own_group_name, gg1}, + {own_group_nodes, GG1}, + {synced_nodes, [mk_node(Ncp1, M)]}, + {sync_error, []}, + {no_contact, [mk_node(Ncp5, M)]}, + {other_groups, remove_gg_pub_type(lists:keydelete + (gg1, 1, GGNodes))}, + {monitoring, []}], + + ?line Info3ok = [{state, synced}, + {own_group_name, gg2}, + {own_group_nodes, GG2}, + {synced_nodes, []}, + {sync_error, []}, + {no_contact, []}, + {other_groups, remove_gg_pub_type(lists:keydelete + (gg2, 1, GGNodes))}, + {monitoring, []}], + + ?line InfoAok = [{state, synced}, + {own_group_name, gg4}, + {own_group_nodes, GG4}, + {synced_nodes, lists:delete(mk_node(NcpA, M), GG4)}, + {sync_error, []}, + {no_contact, []}, + {other_groups, remove_gg_pub_type(lists:keydelete + (gg4, 1, GGNodes))}, + {monitoring, []}], + + ?line InfoBok = [{state, synced}, + {own_group_name, gg4}, + {own_group_nodes, GG4}, + {synced_nodes, lists:delete(mk_node(NcpB, M), GG4)}, + {sync_error, []}, + {no_contact, []}, + {other_groups, remove_gg_pub_type(lists:keydelete + (gg4, 1, GGNodes))}, + {monitoring, []}], + + ?line InfoCok = [{state, synced}, + {own_group_name, gg5}, + {own_group_nodes, GG5}, + {synced_nodes, lists:delete(mk_node(NcpC, M), GG5)}, + {sync_error, []}, + {no_contact, []}, + {other_groups, remove_gg_pub_type(lists:keydelete + (gg5, 1, GGNodes))}, + {monitoring, []}], + + ?line InfoDok = [{state, synced}, + {own_group_name, gg5}, + {own_group_nodes, GG5}, + {synced_nodes, lists:delete(mk_node(NcpD, M), GG5)}, + {sync_error, []}, + {no_contact, []}, + {other_groups, remove_gg_pub_type(lists:keydelete + (gg5, 1, GGNodes))}, + {monitoring, []}], + + ?line InfoEok = [{state, synced}, + {own_group_name, gg5}, + {own_group_nodes, GG5}, + {synced_nodes, lists:delete(mk_node(NcpE, M), GG5)}, + {sync_error, []}, + {no_contact, []}, + {other_groups, remove_gg_pub_type(lists:keydelete + (gg5, 1, GGNodes))}, + {monitoring, []}], + + + ?line case Info1 of + Info1ok -> + ok; + _ -> + test_server:fail({{"could not change the global groups" + " in node", Cp1}, {Info1, Info1ok}}) + end, + + ?line case Info2 of + Info2ok -> + ok; + _ -> + test_server:fail({{"could not change the global groups" + " in node", Cp2}, {Info2, Info2ok}}) + end, + + ?line case Info3 of + Info3ok -> + ok; + _ -> + test_server:fail({{"could not change the global groups" + " in node", Cp3}, {Info3, Info3ok}}) + end, + + ?line case InfoA of + InfoAok -> + ok; + _ -> + test_server:fail({{"could not change the global groups" + " in node", CpA}, {InfoA, InfoAok}}) + end, + + ?line case InfoB of + InfoBok -> + ok; + _ -> + test_server:fail({{"could not change the global groups" + " in node", CpB}, {InfoB, InfoBok}}) + end, + + + ?line case InfoC of + InfoCok -> + ok; + _ -> + test_server:fail({{"could not change the global groups" + " in node", CpC}, {InfoC, InfoCok}}) + end, + + ?line case InfoD of + InfoDok -> + ok; + _ -> + test_server:fail({{"could not change the global groups" + " in node", CpD}, {InfoD, InfoDok}}) + end, + + ?line case InfoE of + InfoEok -> + ok; + _ -> + test_server:fail({{"could not change the global groups" + " in node", CpE}, {InfoE, InfoEok}}) + end, + + write_high_level_trace(Config), % no good since CpC was restarted + stop_node(Cp1), + stop_node(Cp2), + stop_node(Cp3), + stop_node(CpA), + stop_node(CpB), + stop_node(CpC), + stop_node(CpD), + stop_node(CpE), + + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + +sync_and_wait(Node) -> + Ref = make_ref(), + Self = self(), + spawn(Node, fun () -> + global_group:sync(), + case whereis(global_group_check) of + P when is_pid(P) -> + Self ! {Ref, P}; + _ -> + Self ! {Ref, done} + end + end), + receive + {Ref, P} when is_pid(P) -> + MonRef = erlang:monitor(process, P), + receive + {'DOWN',MonRef,process,P,_} -> + ok + end; + {Ref, _} -> + ok + end. + +%%% Copied from init_SUITE.erl. +is_real_system(KernelVsn, StdlibVsn) -> + LibDir = code:lib_dir(), + filelib:is_dir(filename:join(LibDir, "kernel-" ++ KernelVsn)) + andalso + filelib:is_dir(filename:join(LibDir, "stdlib-" ++ StdlibVsn)). + +create_script_dc(ScriptName) -> + ?line Name = filename:join(".", ScriptName), + ?line Apps = application_controller:which_applications(), + ?line {value,{_,_,KernelVer}} = lists:keysearch(kernel,1,Apps), + ?line {value,{_,_,StdlibVer}} = lists:keysearch(stdlib,1,Apps), + ?line {ok,Fd} = file:open(Name ++ ".rel", [write]), + ?line {_, Version} = init:script_id(), + ?line io:format(Fd, + "{release, {\"Test release 3\", \"~s\"}, \n" + " {erts, \"4.4\"}, \n" + " [{kernel, \"~s\"}, {stdlib, \"~s\"}]}.\n", + [Version, KernelVer, StdlibVer]), + ?line file:close(Fd), + {KernelVer, StdlibVer}. + +%% Not used? +config_dc(Fd, Ncp1, Ncp2, Ncp3) -> + M = from($@, atom_to_list(node())), + io:format(Fd, "[{kernel, [{sync_nodes_optional, ['~s@~s','~s@~s','~s@~s']}," + "{sync_nodes_timeout, 1000}," + "{global_groups, [{gg1, ['~s@~s', '~s@~s']}," + " {gg2, ['~s@~s']}]}" + " ]}].~n", + [Ncp1, M, Ncp2, M, Ncp3, M, Ncp1, M, Ncp2, M, Ncp3, M]). + + +config_dc1(Fd, Ncp1, Ncp2, Ncp3, NcpA, NcpB, NcpC, NcpD, NcpE) -> + M = from($@, atom_to_list(node())), + io:format(Fd, "[{kernel, [{sync_nodes_optional, ['~s@~s','~s@~s','~s@~s','~s@~s','~s@~s','~s@~s','~s@~s','~s@~s']}," + "{sync_nodes_timeout, 1000}," + "{global_groups, [{gg1, ['~s@~s', '~s@~s']}," + " {gg2, ['~s@~s']}," + " {gg4, normal, ['~s@~s','~s@~s','~s@~s']}," + " {gg5, hidden, ['~s@~s','~s@~s']}]}]}].~n", + [Ncp1, M, Ncp2, M, Ncp3, M, + NcpA, M, NcpB, M, NcpC, M, NcpD, M, NcpE, M, + Ncp1, M, Ncp2, M, + Ncp3, M, + NcpA, M, NcpB, M, NcpC, M, + NcpD, M, NcpE, M]). + +config_dc2(Fd, NewGG, Ncp1, Ncp2, Ncp3) -> + M = from($@, atom_to_list(node())), + io:format(Fd, "[{kernel, [{sync_nodes_optional, ['~s@~s','~s@~s','~s@~s']}," + "{sync_nodes_timeout, 1000}," + "~p]}].~n", + [Ncp1, M, Ncp2, M, Ncp3, M, NewGG]). + + +from(H, [H | T]) -> T; +from(H, [_ | T]) -> from(H, T); +from(_H, []) -> []. + + + +other(A, [A, _B]) -> A; +other(_, [_A, B]) -> B. + + +%% this one runs at cp2 +part1(Config, Main, Cp1, Cp3) -> + case catch begin + make_partition(Config, [Main, Cp1], [node(), Cp3]), + ?line {_Pid, yes} = start_proc(test2), + ?line {_Pid2, yes} = start_proc(test4) + end of + {_, yes} -> ok; % w("ok", []); + {'EXIT', _R} -> + ok + % w("global_SUITE line:~w: ~p", [?LINE, _R]) + end. + +%% Runs at Cp2 +part1_5(Config, Main, Cp1, Cp3) -> + case catch begin + make_partition(Config, [Main, Cp1], [node(), Cp3]), + ?line {_Pid1, yes} = start_proc_basic(name12), + ?line {_Pid2, yes} = + rpc:call(Cp3, ?MODULE, start_proc_basic, [name03]) + end of + {_, yes} -> ok; % w("ok", []); + {'EXIT', _R} -> + ok + % w("global_SUITE line:~w: ~p", [?LINE, _R]) + end. + +w(X,Y) -> + {ok, F} = file:open("cp2.log", [write]), + io:format(F, X, Y), + file:close(F). + +%% this one runs on one node in Part2 +%% The partition is ready when is_ready_partition(Config) returns (true). +make_partition(Config, Part1, Part2) -> + Dir = ?config(priv_dir, Config), + Ns = [begin + Name = lists:concat([atom_to_list(N),"_",msec(),".part"]), + File = filename:join([Dir, Name]), + file:delete(File), + rpc_cast(N, ?MODULE, mk_part_node, [File, Part, Config], File), + {N, File} + end || Part <- [Part1, Part2], N <- Part], + all_nodes_files(Ns, "done", Config), + lists:foreach(fun({_N,File}) -> file:delete(File) end, Ns), + PartFile = make_partition_file(Config), + touch(PartFile, "done"). + +%% The node signals its success by touching a file. +mk_part_node(File, MyPart0, Config) -> + touch(File, "start"), % debug + MyPart = lists:sort(MyPart0), + ?UNTIL(is_node_in_part(File, MyPart)), + touch(File, "done"). + +%% The calls to append_to_file are for debugging. +is_node_in_part(File, MyPart) -> + lists:foreach(fun(N) -> + _ = erlang:disconnect_node(N) + end, nodes() -- MyPart), + case {(Known = get_known(node())) =:= MyPart, + (Nodes = lists:sort([node() | nodes()])) =:= MyPart} of + {true, true} -> + %% Make sure the resolvers have been terminated, + %% otherwise they may pop up and send some message. + %% (This check is probably unnecessary.) + case element(5, global:info()) of + [] -> + true; + Rs -> + erlang:display({is_node_in_part, resolvers, Rs}), + trace_message({node(), is_node_in_part, Rs}), + append_to_file(File, {now(), Known, Nodes, Rs}), + false + end; + _ -> + append_to_file(File, {now(), Known, Nodes}), + false + end. + +is_ready_partition(Config) -> + File = make_partition_file(Config), + file_contents(File, "done", Config), + file:delete(File), + true. + +make_partition_file(Config) -> + Dir = ?config(priv_dir, Config), + filename:join([Dir, atom_to_list(make_partition_done)]). + +%% this one runs at cp3 +part2(Config, Parent, Main, Cp0, Cp1, Cp2, Cp3, Cp4, Cp5, Cp6) -> + make_partition(Config, [Main, Cp0, Cp1, Cp2], [Cp3, Cp4, Cp5, Cp6]), + start_procs(Parent, Cp4, Cp5, Cp6, Config). + +part3(Config, Parent, Main, Cp0, Cp1, Cp2, Cp3, Cp4, Cp5, Cp6) -> + make_partition(Config, [Main, Cp0, Cp1, Cp2], [Cp3, Cp4, Cp5, Cp6]), + start_procs(Parent, Cp4, Cp5, Cp6, Config), + % Make Cp6 alone + ?line rpc_cast(Cp5, ?MODULE, crash, [12000]), + ?line rpc_cast(Cp6, ?MODULE, alone, [Cp0, Cp3]). + +start_procs(Parent, N1, N2, N3, Config) -> + S1 = lists:sort([N1, N2, N3]), + ?line + ?UNTIL(begin + NN = lists:sort(nodes()), + S1 =:= NN + end), + ?line Pid3 = start_proc3(test1), + ?line Pid4 = rpc:call(N1, ?MODULE, start_proc3, [test2]), + ?line assert_pid(Pid4), + ?line Pid5 = rpc:call(N2, ?MODULE, start_proc3, [test3]), + ?line assert_pid(Pid5), + ?line Pid6 = rpc:call(N3, ?MODULE, start_proc3, [test4]), + ?line assert_pid(Pid6), + ?line yes = global:register_name(test1, Pid3), + ?line yes = global:register_name(test2, Pid4, {global, notify_all_name}), + ?line yes = global:register_name(test3, Pid5, {global, random_notify_name}), + Resolve = fun(Name, Pid1, Pid2) -> + Parent ! {resolve_called, Name, node()}, + {Min, Max} = minmax(Pid1, Pid2), + exit(Min, kill), + Max + end, + ?line yes = global:register_name(test4, Pid6, Resolve). + + + +collect_resolves() -> cr(0). +cr(Res) -> + receive + {resolve_called, Name, Node} -> + io:format("resolve called: ~w ~w~n", [Name, Node]), + cr(Res+1) + after + 0 -> Res + end. + +minmax(P1,P2) -> + if node(P1) < node(P2) -> {P1, P2}; true -> {P2, P1} end. + +fix_basic_name(name03, Pid1, Pid2) -> + case atom_to_list(node(Pid1)) of + [$c, $p, $3|_] -> exit(Pid2, kill), Pid1; + _ -> exit(Pid1, kill), Pid2 + end; +fix_basic_name(name12, Pid1, Pid2) -> + case atom_to_list(node(Pid1)) of + [$c, $p, $2|_] -> exit(Pid2, kill), Pid1; + _ -> exit(Pid1, kill), Pid2 + end. + +start_proc() -> + Pid = spawn(?MODULE, p_init, [self()]), + receive + Pid -> Pid + end. + + +start_proc(Name) -> + Pid = spawn(?MODULE, p_init, [self(), Name]), + receive + {Pid, Res} -> {Pid, Res} + end. + +start_proc2(Name) -> + Pid = spawn(?MODULE, p_init2, [self(), Name]), + receive + Pid -> Pid + end. + +start_proc3(Name) -> + Pid = spawn(?MODULE, p_init, [self()]), + register(Name, Pid), + receive + Pid -> Pid + end. + +start_proc4(Name) -> + Pid = spawn(?MODULE, p_init, [self()]), + yes = global:register_name(Name, Pid), + receive + Pid -> Pid + end. + +start_proc_basic(Name) -> + Pid = spawn(?MODULE, init_proc_basic, [self(), Name]), + receive + {Pid, Res} -> {Pid, Res} + end. + +init_proc_basic(Parent, Name) -> + X = global:register_name(Name, self(), {?MODULE, fix_basic_name}), + Parent ! {self(),X}, + loop(). + +single_node(Time, Node, Config) -> + exit(erlang:whereis(user), kill), + lists:foreach(fun(N) -> _ = erlang:disconnect_node(N) end, nodes()), + ?UNTIL(get_known(node()) =:= [node()]), + spawn(?MODULE, init_2, []), + test_server:sleep(Time - msec()), + net_adm:ping(Node). + +init_2() -> + register(single_name, self()), + yes = global:register_name(single_name, self()), + loop_2(). + +loop_2() -> + receive + die -> ok + end. + +msec() -> + msec(now()). + +msec(T) -> + element(1,T)*1000000000 + element(2,T)*1000 + element(3,T) div 1000. + +assert_pid(Pid) -> + if + is_pid(Pid) -> true; + true -> exit({not_a_pid, Pid}) + end. + +check_same([H|T]) -> check_same(T, H). + +check_same([H|T], H) -> check_same(T, H); +check_same([], _H) -> ok. + +check_same_p([H|T]) -> check_same_p(T, H). + +check_same_p([H|T], H) -> check_same_p(T, H); +check_same_p([], _H) -> true; +check_same_p(_, _) -> false. + +p_init(Parent) -> + Parent ! self(), + loop(). + +p_init(Parent, Name) -> + X = global:register_name(Name, self()), + Parent ! {self(),X}, + loop(). + +p_init2(Parent, Name) -> + _ = global:re_register_name(Name, self()), + Parent ! self(), + loop(). + +req(Pid, Msg) -> + Pid ! Msg, + receive X -> X end. + +sreq(Pid, Msg) -> + Ref = make_ref(), + Pid ! {Msg, Ref}, + receive {Ref, X} -> X end. + +alone(N1, N2) -> + lists:foreach(fun(Node) -> true = erlang:disconnect_node(Node) end, + nodes()), + test_server:sleep(12000), + net_adm:ping(N1), + net_adm:ping(N2), + yes = global:register_name(test5, self()). + +crash(Time) -> + test_server:sleep(Time), + erlang:halt(). + +loop() -> + receive + {ping, From} -> + From ! {pong, node()}, + loop(); + {del_lock, Id} -> + global:del_lock({Id, self()}), + loop(); + {del_lock_sync, Id, From} -> + global:del_lock({Id, self()}), + From ! true, + loop(); + {del_lock, Id, Nodes} -> + global:del_lock({Id, self()}, Nodes), + loop(); + {del_lock2, Id, From} -> + global:del_lock(Id), + From ! true, + loop(); + {del_lock2, Id, From, Nodes} -> + global:del_lock(Id, Nodes), + From ! true, + loop(); + {set_lock, Id, From} -> + Res = global:set_lock({Id, self()}, ?NODES, 1), + From ! Res, + loop(); + {set_lock, Id, From, Nodes} -> + Res = global:set_lock({Id, self()}, Nodes, 1), + From ! Res, + loop(); + {set_lock_loop, Id, From} -> + true = global:set_lock({Id, self()}, ?NODES), + From ! {got_lock, self()}, + loop(); + {set_lock2, Id, From} -> + Res = global:set_lock(Id, ?NODES, 1), + From ! Res, + loop(); + {{got_notify, From}, Ref} -> + receive + X when element(1, X) =:= global_name_conflict -> + From ! {Ref, yes} + after + 0 -> From ! {Ref, no} + end, + loop(); + die -> + exit(normal); + drop_dead -> + exit(drop_dead) + end. + +-ifdef(unused). +pr_diff(Str, T0, T1) -> + Diff = begin + {_, {H,M,S}} = calendar:time_difference(T0, T1), + ((H*60+M)*60)+S + end, + test_server:format(1,"~13s: ~w (diff: ~w)",[Str, T1, Diff]), + if + Diff > 100 -> + test_server:format(1,"~s: ** LARGE DIFF ~w~n", [Str, Diff]); + true -> + ok + end. +-endif. + +now_diff({A1,B1,C1},{A2,B2,C2}) -> + C1-C2 + 1000000*((B1-B2) + 1000000*(A1-A2)). + +start_node_boot(Name, Config, Boot) -> + Pa = filename:dirname(code:which(?MODULE)), + Res = test_server:start_node(Name, peer, [{args, " -pa " ++ Pa ++ + " -config " ++ Config ++ + " -boot " ++ atom_to_list(Boot)}]), + record_started_node(Res). + +%% Increase the timeout for when an upcoming connection is teared down +%% again (default is 7 seconds, and can be exceeded by some tests). +%% The default remains in effect for the test_server node itself, though. +start_node(Name, Config) -> + start_node(Name, slave, Config). + +start_hidden_node(Name, Config) -> + start_node(Name, slave, "-hidden", Config). + +start_non_connecting_node(Name, Config) -> + start_node(Name, slave, "-connect_all false +W i", Config). + +start_peer_node(Name, Config) -> + start_node(Name, peer, Config). + +start_node(Name, How, Config) -> + start_node(Name, How, "", Config). + +start_node(Name0, How, Args, Config) -> + Name = node_name(Name0, Config), + Pa = filename:dirname(code:which(?MODULE)), + R = test_server:start_node(Name, How, [{args, + Args ++ " " ++ + "-kernel net_setuptime 100 " +% "-noshell " + "-pa " ++ Pa}, + {linked, false} +]), + %% {linked,false} only seems to work for slave nodes. +% test_server:sleep(1000), + record_started_node(R). + +start_node_rel(Name0, Rel, Config) -> + Name = node_name(Name0, Config), + {Release, Compat} = case Rel of + this -> + {[this], "+R8"}; + Rel when is_atom(Rel) -> + {[{release, atom_to_list(Rel)}], ""}; + RelList -> + {RelList, ""} + end, + Env = case Rel of + r11b -> + [{env, [{"ERL_R11B_FLAGS", []}]}]; + _ -> + [] + end, + Pa = filename:dirname(code:which(?MODULE)), + Res = test_server:start_node(Name, peer, + [{args, + Compat ++ + " -kernel net_setuptime 100 " + " -pa " ++ Pa}, + {erl, Release}] ++ Env), + record_started_node(Res). + +record_started_node({ok, Node}) -> + case erase(?nodes_tag) of + undefined -> ok; + Nodes -> put(?nodes_tag, [Node | Nodes]) + end, + {ok, Node}; +record_started_node(R) -> + R. + +node_names(Names, Config) -> + [node_name(Name, Config) || Name <- Names]. + +%% simple_resolve assumes that the node name comes first. +node_name(Name, Config) -> + U = "_", + {{Y,M,D}, {H,Min,S}} = calendar:now_to_local_time(now()), + Date = io_lib:format("~4w_~2..0w_~2..0w__~2..0w_~2..0w_~2..0w", + [Y,M,D, H,Min,S]), + L = lists:flatten(Date), + lists:concat([Name,U,?testcase,U,U,L]). + +stop_nodes(Nodes) -> + lists:foreach(fun(Node) -> stop_node(Node) end, Nodes). + +stop_node(Node) -> + ?line ?t:stop_node(Node). + + +stop() -> + lists:foreach(fun(Node) -> + ?t:stop_node(Node) + end, nodes()). + +dbg_logs(Name) -> dbg_logs(Name, ?NODES). + +dbg_logs(Name, Nodes) -> + lists:foreach(fun(N) -> + F = lists:concat([Name, ".log.", N, ".txt"]), + ?line ok = sys:log_to_file({global_name_server, N}, F) + end, Nodes). + + +global_lost_nodes(suite) -> + []; +global_lost_nodes(doc) -> + ["Tests that locally loaded nodes do not loose contact with other nodes."]; +global_lost_nodes(Config) when is_list(Config) -> + Timeout = 60, + Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + + ?line {ok, Node1} = start_node(node1, Config), + ?line {ok, Node2} = start_node(node2, Config), + + ?line wait_for_ready_net(Config), + + ?line io:format("Nodes: ~p", [nodes()]), + ?line io:format("Nodes at node1: ~p", + [rpc:call(Node1, erlang, nodes, [])]), + ?line io:format("Nodes at node2: ~p", + [rpc:call(Node2, erlang, nodes, [])]), + + ?line rpc_cast(Node1, ?MODULE, global_load, [node_1,Node2,node_2]), + ?line rpc_cast(Node2, ?MODULE, global_load, [node_2,Node1,node_1]), + + lost_nodes_waiter(Node1, Node2), + + write_high_level_trace(Config), + ?line stop_node(Node1), + ?line stop_node(Node2), + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + +global_load(MyName, OtherNode, OtherName) -> + ?line yes = global:register_name(MyName, self()), + io:format("Registered ~p",[MyName]), + global_load1(OtherNode, OtherName, 0). + +global_load1(_OtherNode, _OtherName, 2) -> + io:format("*** ~p giving up. No use.", [node()]), + init:stop(); +global_load1(OtherNode, OtherName, Fails) -> + test_server:sleep(1000), + ?line case catch global:whereis_name(OtherName) of + Pid when is_pid(Pid) -> + io:format("~p says: ~p is still there.", + [node(),OtherName]), + global_load1(OtherNode, OtherName, Fails); + Other -> + io:format("~p says: ~p is lost (~p) Pinging.", + [ node(), OtherName, Other]), + case net_adm:ping(OtherNode) of + pong -> + io:format("Re-established contact to ~p", + [OtherName]); + pang -> + io:format("PANIC! Other node is DEAD.", []), + init:stop() + end, + global_load1(OtherNode, OtherName, Fails+1) + end. + +lost_nodes_waiter(N1, N2) -> + ?line net_kernel:monitor_nodes(true), + receive + {nodedown, Node} when Node =:= N1 ; Node =:= N2 -> + io:format("~p went down!",[Node]), + ?line ?t:fail("Node went down.") + after 10000 -> + ok + end, + ok. + + + +mass_death(suite) -> + []; +mass_death(doc) -> + ["Tests the simultaneous death of many processes with registered names"]; +mass_death(Config) when is_list(Config) -> + Timeout = 90, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + ?line OrigNames = global:registered_names(), + %% Start nodes + ?line Cps = [cp1,cp2,cp3,cp4,cp5], + ?line Nodes = [begin {ok, Node} = start_node(Cp, Config), Node end || + Cp <- Cps], + ?line io:format("Nodes: ~p~n", [Nodes]), + ?line Ns = lists:seq(1, 40), + %% Start processes with globally registered names on the nodes + ?line {Pids,[]} = rpc:multicall(Nodes, ?MODULE, mass_spawn, [Ns]), + ?line io:format("Pids: ~p~n", [Pids]), + %% Wait... + ?line test_server:sleep(10000), + %% Check the globally registered names + ?line NewNames = global:registered_names(), + ?line io:format("NewNames: ~p~n", [NewNames]), + ?line Ndiff = lists:sort(NewNames--OrigNames), + ?line io:format("Ndiff: ~p~n", [Ndiff]), + ?line Ndiff = lists:sort(mass_names(Nodes, Ns)), + %% + %% Kill the root pids + ?line lists:foreach(fun (Pid) -> Pid ! drop_dead end, Pids), + %% Start probing and wait for all registered names to disappear + {YYYY,MM,DD} = date(), + {H,M,S} = time(), + io:format("Started probing: ~.4.0w-~.2.0w-~.2.0w ~.2.0w:~.2.0w:~.2.0w~n", + [YYYY,MM,DD,H,M,S]), + wait_mass_death(Dog, Nodes, OrigNames, erlang:now(), Config). + +wait_mass_death(Dog, Nodes, OrigNames, Then, Config) -> + ?line Names = global:registered_names(), + ?line + case Names--OrigNames of + [] -> + ?line T = now_diff(erlang:now(), Then) div 1000, + ?line lists:foreach( + fun (Node) -> + stop_node(Node) + end, Nodes), + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + {comment,lists:flatten(io_lib:format("~.3f s~n", [T/1000.0]))}; + Ndiff -> + ?line io:format("Ndiff: ~p~n", [Ndiff]), + ?line test_server:sleep(1000), + ?line wait_mass_death(Dog, Nodes, OrigNames, Then, Config) + end. + +mass_spawn([]) -> + ok; +mass_spawn([N|T]) -> + Parent = self(), + Pid = + spawn_link( + fun () -> + Name = mass_name(node(), N), + yes = global:register_name(Name, self()), + mass_spawn(T), + Parent ! self(), + loop() + end), + receive Pid -> Pid end. + +mass_names([], _) -> + []; +mass_names([Node|T],Ns) -> + [mass_name(Node, N) || N <- Ns] ++ mass_names(T, Ns). + +mass_name(Node, N) -> + list_to_atom(atom_to_list(Node)++"_"++integer_to_list(N)). + + + +start_nodes(L, How, Config) -> + start_nodes2(L, How, 0, Config), + Nodes = collect_nodes(0, length(L)), + ?line ?UNTIL([] =:= Nodes -- nodes()), + put(?nodes_tag, Nodes), + %% Pinging doesn't help, we have to wait too, for nodes() to become + %% correct on the other node. + lists:foreach(fun(E) -> + net_adm:ping(E) + end, + Nodes), + verify_nodes(Nodes, Config), + Nodes. + +%% Not used? +start_nodes_serially([], _, _Config) -> + []; +start_nodes_serially([Name | Rest], How, Config) -> + {ok, R} = start_node(Name, How, Config), + [R | start_nodes_serially(Rest, How, Config)]. + +verify_nodes(Nodes, Config) -> + verify_nodes(Nodes, lists:sort([node() | Nodes]), Config). + +verify_nodes([], _N, _Config) -> + []; +verify_nodes([Node | Rest], N, Config) -> + ?line ?UNTIL( + case rpc:call(Node, erlang, nodes, []) of + Nodes when is_list(Nodes) -> + case N =:= lists:sort([Node | Nodes]) of + true -> + true; + false -> + lists:foreach(fun(Nd) -> + rpc:call(Nd, net_adm, ping, + [Node]) + end, + nodes()), + false + end; + _ -> + false + end + ), + verify_nodes(Rest, N, Config). + + +start_nodes2([], _How, _, _Config) -> + []; +start_nodes2([Name | Rest], How, N, Config) -> + Self = self(), + spawn(fun() -> + erlang:display({starting, Name}), + {ok, R} = start_node(Name, How, Config), + erlang:display({started, Name, R}), + Self ! {N, R}, + %% sleeping is necessary, or with peer nodes, they will + %% go down again, despite {linked, false}. + test_server:sleep(100000) + end), + start_nodes2(Rest, How, N+1, Config). + +collect_nodes(N, N) -> + []; +collect_nodes(N, Max) -> + receive + {N, Node} -> + [Node | collect_nodes(N+1, Max)] + end. + +only_element(_E, []) -> + true; +only_element(E, [E|R]) -> + only_element(E, R); +only_element(_E, _) -> + false. + +exit_p(Pid) -> + Ref = erlang:monitor(process, Pid), + Pid ! die, + receive + {'DOWN', Ref, process, Pid, _Reason} -> + ok + end. + +wait_for_exit(Pid) -> + Ref = erlang:monitor(process, Pid), + receive + {'DOWN', Ref, process, Pid, _Reason} -> + ok + end. + +wait_for_exit_fast(Pid) -> + Ref = erlang:monitor(process, Pid), + receive + {'DOWN', Ref, process, Pid, _Reason} -> + ok + end. + +check_everywhere(Nodes, Name, Config) -> + ?UNTIL(begin + case rpc:multicall(Nodes, global, whereis_name, [Name]) of + {Ns1, []} -> + check_same_p(Ns1); + _R -> + false + end + end). + +init_condition(Config) -> + io:format("globally registered names: ~p~n", [global:registered_names()]), + io:format("nodes: ~p~n", [nodes()]), + io:format("known: ~p~n", [get_known(node()) -- [node()]]), + io:format("Info ~p~n", [setelement(11, global:info(), trace)]), + _ = [io:format("~s: ~p~n", [TN, ets:tab2list(T)]) || + {TN, T} <- [{"Global Names (ETS)", global_names}, + {"Global Names Ext (ETS)", global_names_ext}, + {"Global Locks (ETS)", global_locks}, + {"Global Pid Names (ETS)", global_pid_names}, + {"Global Pid Ids (ETS)", global_pid_ids}]], + ?UNTIL([test_server] =:= global:registered_names()), + ?UNTIL([] =:= nodes()), + ?UNTIL([node()] =:= get_known(node())), + ok. + +mk_node(N, H) when is_list(N), is_list(H) -> + list_to_atom(N ++ "@" ++ H). + +remove_gg_pub_type([]) -> + []; +remove_gg_pub_type([{GG, Nodes}|Rest]) -> + [{GG, Nodes}|remove_gg_pub_type(Rest)]; +remove_gg_pub_type([{GG, _, Nodes}|Rest]) -> + [{GG, Nodes}|remove_gg_pub_type(Rest)]. + +%% Send garbage message to all processes that are linked to global. +%% Better do this in a slave node. +%% (The transition from links to monitors does not affect this case.) + +garbage_messages(suite) -> + []; +garbage_messages(Config) when is_list(Config) -> + Timeout = 25, + ?line Dog = test_server:timetrap({seconds,Timeout}), + init_high_level_trace(Timeout), + ?line init_condition(Config), + ?line [Slave] = start_nodes([garbage_messages], slave, Config), + Fun = fun() -> + {links,L} = process_info(whereis(global_name_server), links), + lists:foreach(fun(Pid) -> Pid ! {garbage,to,you} end, L), + receive + _Any -> ok + end + end, + ?line Pid = spawn_link(Slave, erlang, apply, [Fun,[]]), + ?t:sleep(2000), + ?line Global = rpc:call(Slave, erlang, whereis, [global_name_server]), + ?line {registered_name,global_name_server} = + rpc:call(Slave, erlang, process_info, [Global,registered_name]), + ?line true = unlink(Pid), + write_high_level_trace(Config), + ?line stop_node(Slave), + ?line init_condition(Config), + ?line test_server:timetrap_cancel(Dog), + ok. + +wait_for_ready_net(Config) -> + wait_for_ready_net(?NODES, Config). + +wait_for_ready_net(Nodes0, Config) -> + Nodes = lists:sort(Nodes0), + ?t:format("wait_for_ready_net ~p~n", [Nodes]), + ?UNTIL(begin + lists:all(fun(N) -> Nodes =:= get_known(N) end, Nodes) and + lists:all(fun(N) -> + LNs = rpc:call(N, erlang, nodes, []), + Nodes =:= lists:sort([N | LNs]) + end, Nodes) + end). + +get_known(Node) -> + case catch gen_server:call({global_name_server,Node},get_known,infinity) of + {'EXIT', _} -> + [list, without, nodenames]; + Known when is_list(Known) -> + lists:sort([Node | Known]) + end. + +quite_a_few_nodes(Max) -> + N = try + ulimit("ulimit -u") + catch _:_ -> + ulimit("ulimit -p") % can fail... + end, + lists:min([(N - 40) div 3, Max]). + +ulimit(Cmd) -> + N0 = os:cmd(Cmd), + N1 = lists:reverse(N0), + N2 = lists:dropwhile(fun($\r) -> true; + ($\n) -> true; + (_) -> false + end, N1), + case lists:reverse(N2) of + "unlimited" -> 10000; + N -> list_to_integer(N) + end. + +%% To make it less probable that some low-level problem causes +%% problems, the receiving node is ping:ed. +rpc_cast(Node, Module, Function, Args) -> + {_,pong,Node}= {node(),net_adm:ping(Node),Node}, + rpc:cast(Node, Module, Function, Args). + +rpc_cast(Node, Module, Function, Args, File) -> + case net_adm:ping(Node) of + pong -> + rpc:cast(Node, Module, Function, Args); + Else -> + append_to_file(File, {now(), {rpc_cast, Node, Module, Function, + Args, Else}}) + %% Maybe we should crash, but it probably doesn't matter. + end. + +%% The emulator now ensures that the node has been removed from +%% nodes(). +rpc_disconnect_node(Node, DisconnectedNode, _Config) -> + True = rpc:call(Node, erlang, disconnect_node, [DisconnectedNode]), + False = lists:member(DisconnectedNode, rpc:call(Node, erlang, nodes, [])), + {true, false} = {True, False}. + +%%% +%%% Utility +%%% + +%% It is a bit awkward to collect data from different nodes. One way +%% of doing is to use a named tracer process on each node. Interesting +%% data is banged to the tracer and when the test is finished data is +%% collected on some node by sending messages to the tracers. One +%% cannot do this if the net has been set up to be less than fully +%% connected. One can also prepare other modules, such as 'global', by +%% inserting lines like +%% trace_message({node(), {at,?LINE}, {tag, message}) +%% where appropriate. + +start_tracer() -> + Pid = spawn(fun() -> tracer([]) end), + case catch register(my_tracer, Pid) of + {'EXIT', _} -> + ?t:fail(re_register_my_tracer); + _ -> + ok + end. + +tracer(L) -> + receive + % {save, Term} -> + % tracer([{now(),Term} | L]); + {get, From} -> + From ! {trace, lists:reverse(L)}, + tracer([]); + stop -> + exit(normal); + Term -> + tracer([{now(),Term} | L]) + end. + +stop_tracer() -> + trace_message(stop). + +get_trace() -> + trace_message({get, self()}), + receive {trace, L} -> + L + end. + +collect_tracers(Nodes) -> + Traces0 = [rpc:call(N, ?MODULE, get_trace, []) || N <- Nodes], + Traces = [L || L <- Traces0, is_list(L)], + try begin + Stamped = lists:keysort(1, lists:append(Traces)), + NotStamped = [T || {_, T} <- Stamped], + {Stamped, NotStamped} + end + catch _:_ -> {[], []} + end. + +trace_message(M) -> + case catch my_tracer ! M of + {'EXIT', _} -> + ?t:fail(my_tracer_not_registered); + _ -> + ok + end. + +%%----------------------------------------------------------------- +%% The error_logger handler used for OTP-6931. +%%----------------------------------------------------------------- +init(Tester) -> + {ok, Tester}. + +handle_event({_, _GL, {_Pid,_String,[{nodeup,fake_node}=Msg]}}, Tester) -> + Tester ! Msg, + {ok, Tester}; +handle_event(_Event, State) -> + {ok, State}. + +handle_info(_Info, State) -> + {ok, State}. + +handle_call(_Query, State) -> {ok, {error, bad_query}, State}. + +terminate(_Reason, State) -> + State. + |