diff options
Diffstat (limited to 'lib/kernel/test/erl_distribution_SUITE.erl')
| -rw-r--r-- | lib/kernel/test/erl_distribution_SUITE.erl | 1235 |
1 files changed, 1235 insertions, 0 deletions
diff --git a/lib/kernel/test/erl_distribution_SUITE.erl b/lib/kernel/test/erl_distribution_SUITE.erl new file mode 100644 index 0000000000..8f2e2512e0 --- /dev/null +++ b/lib/kernel/test/erl_distribution_SUITE.erl @@ -0,0 +1,1235 @@ +%% +%% %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(erl_distribution_SUITE). + +%-define(line_trace, 1). +-include("test_server.hrl"). + +-export([all/1]). + +-export([tick/1, tick_change/1, illegal_nodenames/1, hidden_node/1, + table_waste/1, net_setuptime/1, + monitor_nodes/1, + monitor_nodes_nodedown_reason/1, + monitor_nodes_complex_nodedown_reason/1, + monitor_nodes_node_type/1, + monitor_nodes_misc/1, + monitor_nodes_otp_6481/1, + monitor_nodes_errors/1, + monitor_nodes_combinations/1, + monitor_nodes_cleanup/1, + monitor_nodes_many/1]). + +%% Performs the test at another node. +-export([tick_cli_test/1, tick_cli_test1/1, + tick_serv_test/2, tick_serv_test1/1, + keep_conn/1, time_ping/1]). + +-export([init_per_testcase/2, fin_per_testcase/2]). + +-export([start_node/2]). + +-export([pinger/1]). + + +-define(DUMMY_NODE,dummy@test01). + +%%----------------------------------------------------------------- +%% The distribution is mainly tested in the big old test_suite. +%% This test only tests the net_ticktime configuration flag. +%% Should be started in a CC view with: +%% erl -sname master -rsh ctrsh +%%----------------------------------------------------------------- + +all(suite) -> + [tick, tick_change, illegal_nodenames, hidden_node, + table_waste, net_setuptime, + monitor_nodes]. + +init_per_testcase(Func, Config) when atom(Func), list(Config) -> + Dog=?t:timetrap(?t:minutes(4)), + [{watchdog, Dog}|Config]. + +fin_per_testcase(_Func, Config) -> + Dog=?config(watchdog, Config), + ?t:timetrap_cancel(Dog). + +tick(suite) -> []; +tick(doc) -> []; +tick(Config) when list(Config) -> + ?line Dog = test_server:timetrap(test_server:seconds(120)), + PaDir = filename:dirname(code:which(erl_distribution_SUITE)), + + %% First check that the normal case is OK! + ?line {ok, Node} = start_node(dist_test, "-pa " ++ PaDir), + rpc:call(Node, erl_distribution_SUITE, tick_cli_test, [node()]), + + erlang:monitor_node(Node, true), + receive + {nodedown, Node} -> + test_server:fail("nodedown from other node") + after 30000 -> + erlang:monitor_node(Node, false), + stop_node(Node) + end, + + %% Now, set the net_ticktime for the other node to 12 secs. + %% After the sleep(2sec) and cast the other node shall destroy + %% the connection as it has not received anything on the connection. + %% The nodedown message should arrive within 8 < T < 16 secs. + + %% We must have two slave nodes as the slave mechanism otherwise + %% halts the client node after tick timeout (the connection is down + %% and the slave node decides to halt !! + + %% Set the ticktime on the server node to 100 secs so the server + %% node doesn't tick the client node within the interval ... + + ?line {ok, ServNode} = start_node(dist_test_server, + "-kernel net_ticktime 100 " + "-pa " ++ PaDir), + rpc:call(ServNode, erl_distribution_SUITE, tick_serv_test, [Node, node()]), + + ?line {ok, _} = start_node(dist_test, + "-kernel net_ticktime 12 " + "-pa " ++ PaDir), + rpc:call(Node, erl_distribution_SUITE, tick_cli_test, [ServNode]), + + spawn_link(erl_distribution_SUITE, keep_conn, [Node]), + + {tick_serv, ServNode} ! {i_want_the_result, self()}, + + monitor_node(ServNode, true), + monitor_node(Node, true), + + receive + {tick_test, T} when integer(T) -> + stop_node(ServNode), + stop_node(Node), + T; + {tick_test, Error} -> + stop_node(ServNode), + stop_node(Node), + test_server:fail(Error); + {nodedown, Node} -> + stop_node(ServNode), + test_server:fail("client node died"); + {nodedown, ServNode} -> + stop_node(Node), + test_server:fail("server node died") + end, + ?line test_server:timetrap_cancel(Dog), + ok. + +table_waste(doc) -> + ["Checks that pinging nonexistyent nodes does not waste space in distribution table"]; +table_waste(suite) -> + []; +table_waste(Config) when list(Config) -> + ?line {ok, HName} = inet:gethostname(), + F = fun(0,_F) -> []; + (N,F) -> + ?line Name = list_to_atom("erl_distribution_"++integer_to_list(N)++ + "@"++HName), + ?line pang = net_adm:ping(Name), + ?line F(N-1,F) + end, + ?line F(256,F), + ?line {ok, N} = start_node(erl_distribution_300,""), + ?line stop_node(N), + ok. + + + +illegal_nodenames(doc) -> + ["Test that pinging an illegal nodename does not kill the node"]; +illegal_nodenames(suite) -> + []; +illegal_nodenames(Config) when list(Config) -> + ?line Dog=?t:timetrap(?t:minutes(2)), + PaDir = filename:dirname(code:which(erl_distribution_SUITE)), + ?line {ok, Node}=start_node(illegal_nodenames, "-pa " ++ PaDir), + monitor_node(Node, true), + ?line RPid=rpc:call(Node, erlang, spawn, + [?MODULE, pinger, [self()]]), + receive + {RPid, pinged} -> + ok; + {nodedown, Node} -> + ?t:fail("Remote node died.") + end, + stop_node(Node), + ?t:timetrap_cancel(Dog), + ok. + +pinger(Starter) -> + io:format("Starter:~p~n",[Starter]), + net_adm:ping(a@b@c), + Starter ! {self(), pinged}, + ok. + + +net_setuptime(doc) -> ["Test that you can set the net_setuptime properly"]; +net_setuptime(Config) when is_list(Config) -> + %% In this test case, we reluctantly accept shorter times than the given + %% setup time, because the connection attempt can end in a + %% "Host unreachable" error before the timeout fires. + + Res0 = do_test_setuptime("2"), + io:format("Res0 = ~p", [Res0]), + ?line true = (Res0 =< 4000), + Res1 = do_test_setuptime("0.3"), + io:format("Res1 = ~p", [Res1]), + ?line true = (Res1 =< 500), + ok. + +do_test_setuptime(Setuptime) when is_list(Setuptime) -> + ?line PaDir = filename:dirname(code:which(?MODULE)), + ?line {ok, Node} = start_node(dist_setuptime_test, "-pa " ++ PaDir ++ + " -kernel net_setuptime " ++ Setuptime), + ?line Res = rpc:call(Node,?MODULE,time_ping,[?DUMMY_NODE]), + ?line stop_node(Node), + Res. + +time_ping(Node) -> + T0 = erlang:now(), + pang = net_adm:ping(Node), + T1 = erlang:now(), + time_diff(T0,T1). + + +%% Keep the connection with the client node up. +%% This is neccessary as the client node runs with much shorter +%% tick time !! +keep_conn(Node) -> + sleep(1), + rpc:cast(Node, erlang, time, []), + keep_conn(Node). + +tick_serv_test(Node, MasterNode) -> + spawn(erl_distribution_SUITE, keep_conn, [MasterNode]), + spawn(erl_distribution_SUITE, tick_serv_test1, [Node]). + +tick_serv_test1(Node) -> + register(tick_serv, self()), + TestServer = receive {i_want_the_result, TS} -> TS end, + monitor_node(Node, true), + receive + {nodedown, Node} -> + net_adm:ping(Node), %% Set up the connection again !! + + {tick_test, Node} ! {whats_the_result, self()}, + receive + {tick_test, Res} -> + TestServer ! {tick_test, Res} + end + end. + +tick_cli_test(Node) -> + spawn(erl_distribution_SUITE, tick_cli_test1, [Node]). + +tick_cli_test1(Node) -> + register(tick_test, self()), + erlang:monitor_node(Node, true), + sleep(2), + rpc:call(Node, erlang, time, []), %% simulate action on the connection + T1 = now(), + receive + {nodedown, Node} -> + T2 = now(), + receive + {whats_the_result, From} -> + case time_diff(T1, T2) of + T when T > 8000, T < 16000 -> + From ! {tick_test, T}; + T -> + From ! {tick_test, + {"T not in interval 8000 < T < 16000", + T}} + end + end + end. + + +tick_change(doc) -> ["OTP-4255"]; +tick_change(suite) -> []; +tick_change(Config) when list(Config) -> + ?line PaDir = filename:dirname(code:which(?MODULE)), + ?line [BN, CN] = get_nodenames(2, tick_change), + ?line DefaultTT = net_kernel:get_net_ticktime(), + ?line case DefaultTT of + I when integer(I) -> ?line ok; + _ -> ?line ?t:fail(DefaultTT) + end, + + % In case other nodes are connected + case nodes(connected) of + [] -> ?line net_kernel:set_net_ticktime(10, 0); + _ -> ?line rpc:multicall(nodes([this, connected]), net_kernel, + set_net_ticktime, [10, 5]) + end, + + ?line wait_until(fun () -> 10 == net_kernel:get_net_ticktime() end), + ?line {ok, B} = start_node(BN, "-kernel net_ticktime 10 -pa " ++ PaDir), + ?line {ok, C} = start_node(CN, "-kernel net_ticktime 10 -hidden -pa " + ++ PaDir), + + ?line OTE = process_flag(trap_exit, true), + case catch begin + ?line run_tick_change_test(B, C, 10, 1, PaDir), + ?line run_tick_change_test(B, C, 1, 10, PaDir) + end of + {'EXIT', Reason} -> + ?line stop_node(B), + ?line stop_node(C), + %% In case other nodes are connected + case nodes(connected) of + [] -> ?line net_kernel:set_net_ticktime(DefaultTT, 0); + _ -> ?line rpc:multicall(nodes([this, connected]), net_kernel, + set_net_ticktime, [DefaultTT, 10]) + end, + ?line wait_until(fun () -> + DefaultTT == net_kernel:get_net_ticktime() + end), + ?line process_flag(trap_exit, OTE), + ?t:fail(Reason); + _ -> + ok + end, + ?line process_flag(trap_exit, OTE), + ?line stop_node(B), + ?line stop_node(C), + + % In case other nodes are connected + case nodes(connected) of + [] -> ?line net_kernel:set_net_ticktime(DefaultTT, 0); + _ -> ?line rpc:multicall(nodes([this, connected]), net_kernel, + set_net_ticktime, [DefaultTT, 5]) + end, + + ?line wait_until(fun () -> DefaultTT == net_kernel:get_net_ticktime() end), + ?line ok. + + +wait_for_nodedowns(Tester, Ref) -> + receive + {nodedown, Node} -> + ?t:format("~p~n", [{node(), {nodedown, Node}}]), + ?line Tester ! {Ref, {node(), {nodedown, Node}}} + end, + wait_for_nodedowns(Tester, Ref). + +run_tick_change_test(B, C, PrevTT, TT, PaDir) -> + ?line [DN, EN] = get_nodenames(2, tick_change), + + ?line Tester = self(), + ?line Ref = make_ref(), + ?line MonitorNodes = fun (Nodes) -> + ?line lists:foreach( + fun (N) -> + ?line monitor_node(N,true) + end, + Nodes), + wait_for_nodedowns(Tester, Ref) + end, + + ?line {ok, D} = start_node(DN, "-kernel net_ticktime " + ++ integer_to_list(PrevTT) ++ " -pa " ++ PaDir), + + ?line NMA = spawn_link(fun () -> MonitorNodes([B, C, D]) end), + ?line NMB = spawn_link(B, fun () -> MonitorNodes([node(), C, D]) end), + ?line NMC = spawn_link(C, fun () -> MonitorNodes([node(), B, D]) end), + + ?line MaxTT = case PrevTT > TT of + true -> ?line PrevTT; + false -> ?line TT + end, + + ?line CheckResult = make_ref(), + ?line spawn_link(fun () -> + receive + after (25 + MaxTT)*1000 -> + Tester ! CheckResult + end + end), + + % In case other nodes than these are connected + case nodes(connected) -- [B, C, D] of + [] -> ?line ok; + OtherNodes -> ?line rpc:multicall(OtherNodes, net_kernel, + set_net_ticktime, [TT, 20]) + end, + + ?line change_initiated = net_kernel:set_net_ticktime(TT,20), + ?line sleep(3), + ?line change_initiated = rpc:call(B,net_kernel,set_net_ticktime,[TT,15]), + ?line sleep(7), + ?line change_initiated = rpc:call(C,net_kernel,set_net_ticktime,[TT,10]), + + ?line {ok, E} = start_node(EN, "-kernel net_ticktime " + ++ integer_to_list(TT) ++ " -pa " ++ PaDir), + ?line NME = spawn_link(E, fun () -> MonitorNodes([node(), B, C, D]) end), + ?line NMA2 = spawn_link(fun () -> MonitorNodes([E]) end), + ?line NMB2 = spawn_link(B, fun () -> MonitorNodes([E]) end), + ?line NMC2 = spawn_link(C, fun () -> MonitorNodes([E]) end), + + receive CheckResult -> ?line ok end, + + ?line unlink(NMA), exit(NMA, kill), + ?line unlink(NMB), exit(NMB, kill), + ?line unlink(NMC), exit(NMC, kill), + ?line unlink(NME), exit(NME, kill), + ?line unlink(NMA2), exit(NMA2, kill), + ?line unlink(NMB2), exit(NMB2, kill), + ?line unlink(NMC2), exit(NMC2, kill), + + %% The node not changing ticktime should have been disconnected from the + %% other nodes + receive {Ref, {Node, {nodedown, D}}} when Node == node() -> ?line ok + after 0 -> ?line exit({?LINE, no_nodedown}) + end, + receive {Ref, {B, {nodedown, D}}} -> ?line ok + after 0 -> ?line exit({?LINE, no_nodedown}) + end, + receive {Ref, {C, {nodedown, D}}} -> ?line ok + after 0 -> ?line exit({?LINE, no_nodedown}) + end, + receive {Ref, {E, {nodedown, D}}} -> ?line ok + after 0 -> ?line exit({?LINE, no_nodedown}) + end, + + %% No other connections should have been broken + receive + {Ref, Reason} -> + ?line stop_node(E), + ?line exit({?LINE, Reason}); + {'EXIT', Pid, Reason} when Pid == NMA; + Pid == NMB; + Pid == NMC; + Pid == NME; + Pid == NMA2; + Pid == NMB2; + Pid == NMC2 -> + ?line stop_node(E), + + ?line exit({?LINE, {node(Pid), Reason}}) + after 0 -> + ?line TT = net_kernel:get_net_ticktime(), + ?line TT = rpc:call(B, net_kernel, get_net_ticktime, []), + ?line TT = rpc:call(C, net_kernel, get_net_ticktime, []), + ?line TT = rpc:call(E, net_kernel, get_net_ticktime, []), + ?line stop_node(E), + ?line ok + end. + +%% +%% Basic tests of hidden node. +%% +hidden_node(doc) -> + ["Basic test of hidden node"]; +hidden_node(suite) -> + []; +hidden_node(Config) when list(Config) -> + ?line Dog = ?t:timetrap(?t:seconds(40)), + PaDir = filename:dirname(code:which(?MODULE)), + VArgs = "-pa " ++ PaDir, + HArgs = "-hidden -pa " ++ PaDir, + ?line {ok, V} = start_node(visible_node, VArgs), + VMN = start_monitor_nodes_proc(V), + ?line {ok, H} = start_node(hidden_node, HArgs), + % Connect visible_node -> hidden_node + connect_nodes(V, H), + test_nodes(V, H), + stop_node(H), + sleep(5), + check_monitor_nodes_res(VMN, H), + stop_node(V), + ?line {ok, H} = start_node(hidden_node, HArgs), + HMN = start_monitor_nodes_proc(H), + ?line {ok, V} = start_node(visible_node, VArgs), + % Connect hidden_node -> visible_node + connect_nodes(H, V), + test_nodes(V, H), + stop_node(V), + sleep(5), + check_monitor_nodes_res(HMN, V), + stop_node(H), + ?line ?t:timetrap_cancel(Dog), + ok. + +connect_nodes(A, B) -> + % Check that they haven't already connected. + ?line false = lists:member(A, rpc:call(B, erlang, nodes, [connected])), + ?line false = lists:member(B, rpc:call(A, erlang, nodes, [connected])), + % Connect them. + ?line pong = rpc:call(A, net_adm, ping, [B]). + + +test_nodes(V, H) -> + % No nodes should be visible on hidden_node + ?line [] = rpc:call(H, erlang, nodes, []), + % visible_node should be hidden on hidden_node + ?line true = lists:member(V, rpc:call(H, erlang, nodes, [hidden])), + % hidden_node node shouldn't be visible on visible_node + ?line false = lists:member(H, rpc:call(V, erlang, nodes, [])), + % hidden_node should be hidden on visible_node + ?line true = lists:member(H, rpc:call(V, erlang, nodes, [hidden])). + +mn_loop(MNs) -> + receive + {nodeup, N} -> + mn_loop([{nodeup, N}|MNs]); + {nodedown, N} -> + mn_loop([{nodedown, N}|MNs]); + {monitor_nodes_result, Ref, From} -> + From ! {Ref, MNs}; + _ -> + mn_loop(MNs) + end. + +start_monitor_nodes_proc(Node) -> + Ref = make_ref(), + Starter = self(), + Pid = spawn(Node, + fun() -> + net_kernel:monitor_nodes(true), + Starter ! Ref, + mn_loop([]) + end), + receive + Ref -> + ok + end, + Pid. + + +check_monitor_nodes_res(Pid, Node) -> + Ref = make_ref(), + Pid ! {monitor_nodes_result, Ref, self()}, + receive + {Ref, MNs} -> + ?line false = lists:keysearch(Node, 2, MNs) + end. + + +monitor_nodes(doc) -> + []; +monitor_nodes(suite) -> + [monitor_nodes_nodedown_reason, + monitor_nodes_complex_nodedown_reason, + monitor_nodes_node_type, + monitor_nodes_misc, + monitor_nodes_otp_6481, + monitor_nodes_errors, + monitor_nodes_combinations, + monitor_nodes_cleanup, + monitor_nodes_many]. + +%% +%% Testcase: +%% monitor_nodes_nodedown_reason +%% + +monitor_nodes_nodedown_reason(doc) -> []; +monitor_nodes_nodedown_reason(suite) -> []; +monitor_nodes_nodedown_reason(Config) when list(Config) -> + ?line MonNodeState = monitor_node_state(), + ?line ok = net_kernel:monitor_nodes(true), + ?line ok = net_kernel:monitor_nodes(true, [nodedown_reason]), + + ?line Names = get_numbered_nodenames(5, node), + ?line [NN1, NN2, NN3, NN4, NN5] = Names, + + ?line {ok, N1} = start_node(NN1), + ?line {ok, N2} = start_node(NN2), + ?line {ok, N3} = start_node(NN3), + ?line {ok, N4} = start_node(NN4, "-hidden"), + + ?line receive {nodeup, N1} -> ok end, + ?line receive {nodeup, N2} -> ok end, + ?line receive {nodeup, N3} -> ok end, + + ?line receive {nodeup, N1, []} -> ok end, + ?line receive {nodeup, N2, []} -> ok end, + ?line receive {nodeup, N3, []} -> ok end, + + ?line stop_node(N1), + ?line stop_node(N4), + ?line true = net_kernel:disconnect(N2), + ?line TickTime = net_kernel:get_net_ticktime(), + ?line SleepTime = TickTime + (TickTime div 4), + ?line spawn(N3, fun () -> + block_emu(SleepTime*1000), + halt() + end), + + ?line receive {nodedown, N1} -> ok end, + ?line receive {nodedown, N2} -> ok end, + ?line receive {nodedown, N3} -> ok end, + + ?line receive {nodedown, N1, [{nodedown_reason, R1}]} -> connection_closed = R1 end, + ?line receive {nodedown, N2, [{nodedown_reason, R2}]} -> disconnect = R2 end, + ?line receive {nodedown, N3, [{nodedown_reason, R3}]} -> net_tick_timeout = R3 end, + + ?line ok = net_kernel:monitor_nodes(false, [nodedown_reason]), + + ?line {ok, N5} = start_node(NN5), + ?line stop_node(N5), + + ?line receive {nodeup, N5} -> ok end, + ?line receive {nodedown, N5} -> ok end, + ?line print_my_messages(), + ?line ok = check_no_nodedown_nodeup(1000), + ?line ok = net_kernel:monitor_nodes(false), + ?line MonNodeState = monitor_node_state(), + ?line ok. + + +monitor_nodes_complex_nodedown_reason(doc) -> []; +monitor_nodes_complex_nodedown_reason(suite) -> []; +monitor_nodes_complex_nodedown_reason(Config) when list(Config) -> + ?line MonNodeState = monitor_node_state(), + ?line Me = self(), + ?line ok = net_kernel:monitor_nodes(true, [nodedown_reason]), + ?line [Name] = get_nodenames(1, monitor_nodes_complex_nodedown_reason), + ?line {ok, Node} = start_node(Name, ""), + ?line Pid = spawn(Node, + fun() -> + Me ! {stuff, + self(), + [make_ref(), + {processes(), erlang:ports()}]} + end), + ?line receive {nodeup, Node, []} -> ok end, + ?line {ok, NodeInfo} = net_kernel:node_info(Node), + ?line {value,{owner, Owner}} = lists:keysearch(owner, 1, NodeInfo), + ?line ComplexTerm = receive {stuff, Pid, _} = Msg -> + {Msg, term_to_binary(Msg)} + end, + ?line exit(Owner, ComplexTerm), + ?line receive + {nodedown, Node, [{nodedown_reason, NodeDownReason}]} -> + ?line ok + end, + %% If the complex nodedown_reason messed something up garbage collections + %% are likely to dump core + ?line garbage_collect(), + ?line garbage_collect(), + ?line garbage_collect(), + ?line ComplexTerm = NodeDownReason, + ?line ok = net_kernel:monitor_nodes(false, [nodedown_reason]), + ?line no_msgs(), + ?line MonNodeState = monitor_node_state(), + ?line ok. + + + + +%% +%% Testcase: +%% monitor_nodes_node_type +%% + +monitor_nodes_node_type(doc) -> []; +monitor_nodes_node_type(suite) -> []; +monitor_nodes_node_type(Config) when is_list(Config) -> + ?line MonNodeState = monitor_node_state(), + ?line ok = net_kernel:monitor_nodes(true), + ?line ok = net_kernel:monitor_nodes(true, [{node_type, all}]), + ?line Names = get_numbered_nodenames(9, node), +% ?line ?t:format("Names: ~p~n", [Names]), + ?line [NN1, NN2, NN3, NN4, NN5, NN6, NN7, NN8, NN9] = Names, + + ?line {ok, N1} = start_node(NN1), + ?line {ok, N2} = start_node(NN2), + ?line {ok, N3} = start_node(NN3, "-hidden"), + ?line {ok, N4} = start_node(NN4, "-hidden"), + + ?line receive {nodeup, N1} -> ok end, + ?line receive {nodeup, N2} -> ok end, + + ?line receive {nodeup, N1, [{node_type, visible}]} -> ok end, + ?line receive {nodeup, N2, [{node_type, visible}]} -> ok end, + ?line receive {nodeup, N3, [{node_type, hidden}]} -> ok end, + ?line receive {nodeup, N4, [{node_type, hidden}]} -> ok end, + + ?line stop_node(N1), + ?line stop_node(N2), + ?line stop_node(N3), + ?line stop_node(N4), + + ?line receive {nodedown, N1} -> ok end, + ?line receive {nodedown, N2} -> ok end, + + ?line receive {nodedown, N1, [{node_type, visible}]} -> ok end, + ?line receive {nodedown, N2, [{node_type, visible}]} -> ok end, + ?line receive {nodedown, N3, [{node_type, hidden}]} -> ok end, + ?line receive {nodedown, N4, [{node_type, hidden}]} -> ok end, + + ?line ok = net_kernel:monitor_nodes(false, [{node_type, all}]), + ?line {ok, N5} = start_node(NN5), + + ?line receive {nodeup, N5} -> ok end, + ?line stop_node(N5), + ?line receive {nodedown, N5} -> ok end, + + ?line ok = net_kernel:monitor_nodes(true, [{node_type, hidden}]), + ?line {ok, N6} = start_node(NN6), + ?line {ok, N7} = start_node(NN7, "-hidden"), + + + ?line receive {nodeup, N6} -> ok end, + ?line receive {nodeup, N7, [{node_type, hidden}]} -> ok end, + ?line stop_node(N6), + ?line stop_node(N7), + + ?line receive {nodedown, N6} -> ok end, + ?line receive {nodedown, N7, [{node_type, hidden}]} -> ok end, + + ?line ok = net_kernel:monitor_nodes(true, [{node_type, visible}]), + ?line ok = net_kernel:monitor_nodes(false, [{node_type, hidden}]), + ?line ok = net_kernel:monitor_nodes(false), + + ?line {ok, N8} = start_node(NN8), + ?line {ok, N9} = start_node(NN9, "-hidden"), + + ?line receive {nodeup, N8, [{node_type, visible}]} -> ok end, + ?line stop_node(N8), + ?line stop_node(N9), + + ?line receive {nodedown, N8, [{node_type, visible}]} -> ok end, + ?line print_my_messages(), + ?line ok = check_no_nodedown_nodeup(1000), + ?line ok = net_kernel:monitor_nodes(false, [{node_type, visible}]), + ?line MonNodeState = monitor_node_state(), + ?line ok. + + +%% +%% Testcase: +%% monitor_nodes +%% + +monitor_nodes_misc(doc) -> []; +monitor_nodes_misc(suite) -> []; +monitor_nodes_misc(Config) when is_list(Config) -> + ?line MonNodeState = monitor_node_state(), + ?line ok = net_kernel:monitor_nodes(true), + ?line ok = net_kernel:monitor_nodes(true, [{node_type, all}, nodedown_reason]), + ?line ok = net_kernel:monitor_nodes(true, [nodedown_reason, {node_type, all}]), + ?line Names = get_numbered_nodenames(3, node), +% ?line ?t:format("Names: ~p~n", [Names]), + ?line [NN1, NN2, NN3] = Names, + + ?line {ok, N1} = start_node(NN1), + ?line {ok, N2} = start_node(NN2, "-hidden"), + + ?line receive {nodeup, N1} -> ok end, + + ?line receive {nodeup, N1, [{node_type, visible}]} -> ok end, + ?line receive {nodeup, N1, [{node_type, visible}]} -> ok end, + ?line receive {nodeup, N2, [{node_type, hidden}]} -> ok end, + ?line receive {nodeup, N2, [{node_type, hidden}]} -> ok end, + + ?line stop_node(N1), + ?line stop_node(N2), + + ?line VisbleDownInfo = lists:sort([{node_type, visible}, + {nodedown_reason, connection_closed}]), + ?line HiddenDownInfo = lists:sort([{node_type, hidden}, + {nodedown_reason, connection_closed}]), + + ?line receive {nodedown, N1} -> ok end, + + ?line receive {nodedown, N1, Info1A} -> VisbleDownInfo = lists:sort(Info1A) end, + ?line receive {nodedown, N1, Info1B} -> VisbleDownInfo = lists:sort(Info1B) end, + ?line receive {nodedown, N2, Info2A} -> HiddenDownInfo = lists:sort(Info2A) end, + ?line receive {nodedown, N2, Info2B} -> HiddenDownInfo = lists:sort(Info2B) end, + + ?line ok = net_kernel:monitor_nodes(false, [{node_type, all}, nodedown_reason]), + + ?line {ok, N3} = start_node(NN3), + ?line receive {nodeup, N3} -> ok end, + ?line stop_node(N3), + ?line receive {nodedown, N3} -> ok end, + ?line print_my_messages(), + ?line ok = check_no_nodedown_nodeup(1000), + ?line ok = net_kernel:monitor_nodes(false), + ?line MonNodeState = monitor_node_state(), + ?line ok. + + +monitor_nodes_otp_6481(doc) -> + ["Tests that {nodeup, Node} messages are received before " + "messages from Node and that {nodedown, Node} messages are" + "received after messages from Node"]; +monitor_nodes_otp_6481(suite) -> + []; +monitor_nodes_otp_6481(Config) when is_list(Config) -> + ?line ?t:format("Testing nodedown...~n"), + ?line monitor_nodes_otp_6481_test(Config, nodedown), + ?line ?t:format("ok~n"), + ?line ?t:format("Testing nodeup...~n"), + ?line monitor_nodes_otp_6481_test(Config, nodeup), + ?line ?t:format("ok~n"), + ?line ok. + +monitor_nodes_otp_6481_test(Config, TestType) when is_list(Config) -> + ?line MonNodeState = monitor_node_state(), + ?line NodeMsg = make_ref(), + ?line Me = self(), + ?line [Name] = get_nodenames(1, monitor_nodes_otp_6481), + ?line case TestType of + nodedown -> ?line ok = net_kernel:monitor_nodes(true); + nodeup -> ?line ok + end, + ?line Seq = lists:seq(1,10000), + ?line MN = spawn_link( + fun () -> + ?line lists:foreach( + fun (_) -> + ?line ok = net_kernel:monitor_nodes(true) + end, + Seq), + ?line Me ! {mon_set, self()}, + ?line receive after infinity -> ok end + end), + ?line receive {mon_set, MN} -> ok end, + ?line case TestType of + nodedown -> ?line ok; + nodeup -> ?line ok = net_kernel:monitor_nodes(true) + end, + + %% Whitebox: + %% nodedown test: Since this process was the first one monitoring + %% nodes this process will be the first one notified + %% on nodedown. + %% nodeup test: Since this process was the last one monitoring + %% nodes this process will be the last one notified + %% on nodeup + + %% Verify the monitor_nodes order expected + ?line TestMonNodeState = monitor_node_state(), + %?line ?t:format("~p~n", [TestMonNodeState]), + ?line TestMonNodeState = + MonNodeState + ++ case TestType of + nodedown -> [{self(), []}]; + nodeup -> [] + end + ++ lists:map(fun (_) -> {MN, []} end, Seq) + ++ case TestType of + nodedown -> []; + nodeup -> [{self(), []}] + end, + + + ?line {ok, Node} = start_node(Name, "", this), + ?line receive {nodeup, Node} -> ok end, + + ?line spawn(Node, + fun () -> + receive after 1000 -> ok end, + lists:foreach(fun (No) -> + Me ! {NodeMsg, No} + end, + Seq), + halt() + end), + + ?line net_kernel:disconnect(Node), + ?line receive {nodedown, Node} -> ok end, + + %% Verify that '{nodeup, Node}' comes before '{NodeMsg, 1}' (the message + %% bringing up the connection). + %%?line no_msgs(500), % Why wait? It fails test sometimes /sverker + ?line {nodeup, Node} = receive Msg1 -> Msg1 end, + ?line {NodeMsg, 1} = receive Msg2 -> Msg2 end, + + %% Verify that '{nodedown, Node}' comes after the last '{NodeMsg, N}' + %% message. + ?line {nodedown, Node} = flush_node_msgs(NodeMsg, 2), + ?line no_msgs(500), + + ?line Mon = erlang:monitor(process, MN), + ?line unlink(MN), + ?line exit(MN, bang), + ?line receive {'DOWN', Mon, process, MN, bang} -> ok end, + ?line ok = net_kernel:monitor_nodes(false), + ?line MonNodeState = monitor_node_state(), + ?line ok. + +flush_node_msgs(NodeMsg, No) -> + case receive Msg -> Msg end of + {NodeMsg, No} -> flush_node_msgs(NodeMsg, No+1); + OtherMsg -> OtherMsg + end. + +monitor_nodes_errors(doc) -> + []; +monitor_nodes_errors(suite) -> + []; +monitor_nodes_errors(Config) when list(Config) -> + ?line MonNodeState = monitor_node_state(), + ?line error = net_kernel:monitor_nodes(asdf), + ?line {error, + {unknown_options, + [gurka]}} = net_kernel:monitor_nodes(true, + [gurka]), + ?line {error, + {options_not_a_list, + gurka}} = net_kernel:monitor_nodes(true, + gurka), + ?line {error, + {option_value_mismatch, + [{node_type,visible}, + {node_type,hidden}]}} + = net_kernel:monitor_nodes(true, + [{node_type,hidden}, + {node_type,visible}]), + ?line {error, + {option_value_mismatch, + [{node_type,visible}, + {node_type,all}]}} + = net_kernel:monitor_nodes(true, + [{node_type,all}, + {node_type,visible}]), + ?line {error, + {bad_option_value, + {node_type, + blaha}}} + = net_kernel:monitor_nodes(true, [{node_type, blaha}]), + ?line MonNodeState = monitor_node_state(), + ?line ok. + +monitor_nodes_combinations(doc) -> + []; +monitor_nodes_combinations(suite) -> + []; +monitor_nodes_combinations(Config) when list(Config) -> + ?line MonNodeState = monitor_node_state(), + ?line monitor_nodes_all_comb(true), + ?line [VisibleName, HiddenName] = get_nodenames(2, + monitor_nodes_combinations), + ?line {ok, Visible} = start_node(VisibleName, ""), + ?line receive_all_comb_nodeup_msgs(visible, Visible), + ?line no_msgs(), + ?line stop_node(Visible), + ?line receive_all_comb_nodedown_msgs(visible, Visible, connection_closed), + ?line no_msgs(), + ?line {ok, Hidden} = start_node(HiddenName, "-hidden"), + ?line receive_all_comb_nodeup_msgs(hidden, Hidden), + ?line no_msgs(), + ?line stop_node(Hidden), + ?line receive_all_comb_nodedown_msgs(hidden, Hidden, connection_closed), + ?line no_msgs(), + ?line monitor_nodes_all_comb(false), + ?line MonNodeState = monitor_node_state(), + ?line no_msgs(), + ?line ok. + +monitor_nodes_all_comb(Flag) -> + ?line ok = net_kernel:monitor_nodes(Flag), + ?line ok = net_kernel:monitor_nodes(Flag, + [nodedown_reason]), + ?line ok = net_kernel:monitor_nodes(Flag, + [{node_type, hidden}]), + ?line ok = net_kernel:monitor_nodes(Flag, + [{node_type, visible}]), + ?line ok = net_kernel:monitor_nodes(Flag, + [{node_type, all}]), + ?line ok = net_kernel:monitor_nodes(Flag, + [nodedown_reason, + {node_type, hidden}]), + ?line ok = net_kernel:monitor_nodes(Flag, + [nodedown_reason, + {node_type, visible}]), + ?line ok = net_kernel:monitor_nodes(Flag, + [nodedown_reason, + {node_type, all}]), + %% There currently are 8 different combinations + ?line 8. + + +receive_all_comb_nodeup_msgs(visible, Node) -> + ?t:format("Receive nodeup visible...~n"), + Exp = [{nodeup, Node}, + {nodeup, Node, []}] + ++ mk_exp_mn_all_comb_nodeup_msgs_common(visible, Node), + receive_mn_msgs(Exp), + ?t:format("ok~n"), + ok; +receive_all_comb_nodeup_msgs(hidden, Node) -> + ?t:format("Receive nodeup hidden...~n"), + Exp = mk_exp_mn_all_comb_nodeup_msgs_common(hidden, Node), + receive_mn_msgs(Exp), + ?t:format("ok~n"), + ok. + +mk_exp_mn_all_comb_nodeup_msgs_common(Type, Node) -> + InfoNt = [{node_type, Type}], + [{nodeup, Node, InfoNt}, + {nodeup, Node, InfoNt}, + {nodeup, Node, InfoNt}, + {nodeup, Node, InfoNt}]. + +receive_all_comb_nodedown_msgs(visible, Node, Reason) -> + ?t:format("Receive nodedown visible...~n"), + Exp = [{nodedown, Node}, + {nodedown, Node, [{nodedown_reason, Reason}]}] + ++ mk_exp_mn_all_comb_nodedown_msgs_common(visible, + Node, + Reason), + receive_mn_msgs(Exp), + ?t:format("ok~n"), + ok; +receive_all_comb_nodedown_msgs(hidden, Node, Reason) -> + ?t:format("Receive nodedown hidden...~n"), + Exp = mk_exp_mn_all_comb_nodedown_msgs_common(hidden, Node, Reason), + receive_mn_msgs(Exp), + ?t:format("ok~n"), + ok. + +mk_exp_mn_all_comb_nodedown_msgs_common(Type, Node, Reason) -> + InfoNt = [{node_type, Type}], + InfoNdrNt = lists:sort([{nodedown_reason, Reason}]++InfoNt), + [{nodedown, Node, InfoNt}, + {nodedown, Node, InfoNt}, + {nodedown, Node, InfoNdrNt}, + {nodedown, Node, InfoNdrNt}]. + +receive_mn_msgs([]) -> + ok; +receive_mn_msgs(Msgs) -> + ?t:format("Expecting msgs: ~p~n", [Msgs]), + receive + {_Dir, _Node} = Msg -> + ?t:format("received ~p~n", [Msg]), + case lists:member(Msg, Msgs) of + true -> receive_mn_msgs(lists:delete(Msg, Msgs)); + false -> ?t:fail({unexpected_message, Msg, + expected_messages, Msgs}) + end; + {Dir, Node, Info} -> + Msg = {Dir, Node, lists:sort(Info)}, + ?t:format("received ~p~n", [Msg]), + case lists:member(Msg, Msgs) of + true -> receive_mn_msgs(lists:delete(Msg, Msgs)); + false -> ?t:fail({unexpected_message, Msg, + expected_messages, Msgs}) + end; + Msg -> + ?t:format("received ~p~n", [Msg]), + ?t:fail({unexpected_message, Msg, + expected_messages, Msgs}) + end. + +monitor_nodes_cleanup(doc) -> + []; +monitor_nodes_cleanup(suite) -> + []; +monitor_nodes_cleanup(Config) when list(Config) -> + ?line MonNodeState = monitor_node_state(), + ?line Me = self(), + ?line No = monitor_nodes_all_comb(true), + ?line Inf = spawn(fun () -> + monitor_nodes_all_comb(true), + Me ! {mons_set, self()}, + receive after infinity -> ok end + end), + ?line TO = spawn(fun () -> + monitor_nodes_all_comb(true), + Me ! {mons_set, self()}, + receive after 500 -> ok end + end), + ?line receive {mons_set, Inf} -> ok end, + ?line receive {mons_set, TO} -> ok end, + ?line MNLen = length(MonNodeState) + No*3, + ?line MNLen = length(monitor_node_state()), + ?line MonInf = erlang:monitor(process, Inf), + ?line MonTO = erlang:monitor(process, TO), + ?line exit(Inf, bang), + ?line No = monitor_nodes_all_comb(false), + ?line receive {'DOWN', MonInf, process, Inf, bang} -> ok end, + ?line receive {'DOWN', MonTO, process, TO, normal} -> ok end, + ?line MonNodeState = monitor_node_state(), + ?line no_msgs(), + ?line ok. + +monitor_nodes_many(doc) -> + []; +monitor_nodes_many(suite) -> + []; +monitor_nodes_many(Config) when list(Config) -> + ?line MonNodeState = monitor_node_state(), + ?line [Name] = get_nodenames(1, monitor_nodes_many), + %% We want to perform more than 2^16 net_kernel:monitor_nodes + %% since this will wrap an internal counter + ?line No = (1 bsl 16) + 17, + ?line repeat(fun () -> ok = net_kernel:monitor_nodes(true) end, No), + ?line No = length(monitor_node_state()) - length(MonNodeState), + ?line {ok, Node} = start_node(Name), + ?line repeat(fun () -> receive {nodeup, Node} -> ok end end, No), + ?line stop_node(Node), + ?line repeat(fun () -> receive {nodedown, Node} -> ok end end, No), + ?line ok = net_kernel:monitor_nodes(false), + ?line no_msgs(10), + ?line MonNodeState = monitor_node_state(), + ?line ok. + +%% Misc. functions + +monitor_node_state() -> + erts_debug:set_internal_state(available_internal_state, true), + MonitoringNodes = erts_debug:get_internal_state(monitoring_nodes), + erts_debug:set_internal_state(available_internal_state, false), + MonitoringNodes. + + +check_no_nodedown_nodeup(TimeOut) -> + ?line receive + {nodeup, _, _} = Msg -> ?line ?t:fail({unexpected_nodeup, Msg}); + {nodeup, _} = Msg -> ?line ?t:fail({unexpected_nodeup, Msg}); + {nodedown, _, _} = Msg -> ?line ?t:fail({unexpected_nodedown, Msg}); + {nodedown, _} = Msg -> ?line ?t:fail({unexpected_nodedown, Msg}) + after TimeOut -> + ok + end. + +print_my_messages() -> + ?line {messages, Messages} = process_info(self(), messages), + ?line ?t:format("Messages: ~p~n", [Messages]), + ?line ok. + +%% Time difference in milliseconds !! +time_diff({TimeM, TimeS, TimeU}, {CurM, CurS, CurU}) when CurM > TimeM -> + ((CurM - TimeM) * 1000000000) + sec_diff({TimeS, TimeU}, {CurS, CurU}); +time_diff({_, TimeS, TimeU}, {_, CurS, CurU}) -> + sec_diff({TimeS, TimeU}, {CurS, CurU}). + +sec_diff({TimeS, TimeU}, {CurS, CurU}) when CurS > TimeS -> + ((CurS - TimeS) * 1000) + micro_diff(TimeU, CurU); +sec_diff({_, TimeU}, {_, CurU}) -> + micro_diff(TimeU, CurU). + +micro_diff(TimeU, CurU) -> + trunc(CurU/1000) - trunc(TimeU/1000). + +sleep(T) -> receive after T * 1000 -> ok end. + +start_node(Name, Param, this) -> + NewParam = Param ++ " -pa " ++ filename:dirname(code:which(?MODULE)), + ?t:start_node(Name, peer, [{args, NewParam}, {erl, [this]}]); +start_node(Name, Param, "this") -> + NewParam = Param ++ " -pa " ++ filename:dirname(code:which(?MODULE)), + ?t:start_node(Name, peer, [{args, NewParam}, {erl, [this]}]); +start_node(Name, Param, Rel) when atom(Rel) -> + NewParam = Param ++ " -pa " ++ filename:dirname(code:which(?MODULE)), + ?t:start_node(Name, peer, [{args, NewParam}, {erl, [{release, atom_to_list(Rel)}]}]); +start_node(Name, Param, Rel) when list(Rel) -> + NewParam = Param ++ " -pa " ++ filename:dirname(code:which(?MODULE)), + ?t:start_node(Name, peer, [{args, NewParam}, {erl, [{release, Rel}]}]). + +start_node(Name, Param) -> + NewParam = Param ++ " -pa " ++ filename:dirname(code:which(?MODULE)), + ?t:start_node(Name, slave, [{args, NewParam}]). +% M = list_to_atom(from($@, atom_to_list(node()))), +% slave:start_link(M, Name, Param). + +start_node(Name) -> + start_node(Name, ""). + +stop_node(Node) -> + ?t:stop_node(Node). +% erlang:monitor_node(Node, true), +% rpc:cast(Node, init, stop, []), +% receive +% {nodedown, Node} -> +% ok +% after 10000 -> +% test_server:fail({stop_node, Node}) +% end. + +% from(H, [H | T]) -> T; +% from(H, [_ | T]) -> from(H, T); +% from(H, []) -> []. + +get_nodenames(N, T) -> + get_nodenames(N, T, []). + +get_nodenames(0, _, Acc) -> + Acc; +get_nodenames(N, T, Acc) -> + {A, B, C} = now(), + get_nodenames(N-1, T, [list_to_atom(atom_to_list(T) + ++ "-" + ++ atom_to_list(?MODULE) + ++ "-" + ++ integer_to_list(A) + ++ "-" + ++ integer_to_list(B) + ++ "-" + ++ integer_to_list(C)) | Acc]). + +get_numbered_nodenames(N, T) -> + get_numbered_nodenames(N, T, []). + +get_numbered_nodenames(0, _, Acc) -> + Acc; +get_numbered_nodenames(N, T, Acc) -> + {A, B, C} = now(), + NL = [list_to_atom(atom_to_list(T) ++ integer_to_list(N) + ++ "-" + ++ atom_to_list(?MODULE) + ++ "-" + ++ integer_to_list(A) + ++ "-" + ++ integer_to_list(B) + ++ "-" + ++ integer_to_list(C)) | Acc], + get_numbered_nodenames(N-1, T, NL). + +wait_until(Fun) -> + case Fun() of + true -> + ok; + _ -> + receive + after 100 -> + wait_until(Fun) + end + end. + +repeat(Fun, 0) when function(Fun) -> + ok; +repeat(Fun, N) when function(Fun), integer(N), N > 0 -> + Fun(), + repeat(Fun, N-1). + +no_msgs(Wait) -> + receive after Wait -> no_msgs() end. + +no_msgs() -> + {messages, []} = process_info(self(), messages). + +block_emu(Ms) -> + erts_debug:set_internal_state(available_internal_state, true), + Res = erts_debug:set_internal_state(block, Ms), + erts_debug:set_internal_state(available_internal_state, false), + Res. |