[esock|test] Add multi async accept TCP test case

Add accept test case testing the abort message received
when "another" process closes a socket. Multiple accept(ors)
for good measure.

1 files changed, 451 insertions, 5 deletions

diff --git a/erts/emulator/test/socket_SUITE.erl b/erts/emulator/test/socket_SUITE.erl
index 079ed76f41..bd5d408add 100644
--- a/erts/emulator/test/socket_SUITE.erl
+++ b/erts/emulator/test/socket_SUITE.erl
@@ -93,6 +93,7 @@
          api_a_recvmsg_cancel_tcp4/1,
          api_a_mrecvfrom_cancel_udp4/1,
          api_a_mrecvmsg_cancel_udp4/1,
+         api_a_maccept_cancel_tcp4/1,
 
 
          %% *** API Options ***
@@ -687,7 +688,8 @@ api_async_cases() ->
      api_a_recv_cancel_tcp4,
      api_a_recvmsg_cancel_tcp4,
      api_a_mrecvfrom_cancel_udp4,
-     api_a_mrecvmsg_cancel_udp4
+     api_a_mrecvmsg_cancel_udp4,
+     api_a_maccept_cancel_tcp4
     ].
 
 api_options_cases() ->
@@ -4465,6 +4467,16 @@ api_a_recv_cancel_tcp(InitState) ->
                            _MRef = erlang:monitor(process, Pid),
                            ok
                    end},
+         #{desc => "monitor alt-server 1",
+           cmd  => fun(#{alt_server1 := Pid} = _State) ->
+                           _MRef = erlang:monitor(process, Pid),
+                           ok
+                   end},
+         #{desc => "monitor alt-server 2",
+           cmd  => fun(#{alt_server2 := Pid} = _State) ->
+                           _MRef = erlang:monitor(process, Pid),
+                           ok
+                   end},
 
          %% Start the server
          #{desc => "order server start",
@@ -4579,7 +4591,7 @@ api_a_recv_cancel_tcp(InitState) ->
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
-%% Basically we make multiple async (Timeout = nowait) call to recvfrom
+%% Basically we make multiple async (Timeout = nowait) call(s) to recvfrom
 %% (from *several* processes), wait some time and then cancel.
 %% This should result in abort messages to the 'other' processes.
 %%
@@ -4608,7 +4620,7 @@ api_a_mrecvfrom_cancel_udp4(_Config) when is_list(_Config) ->
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
-%% Basically we make multiple async (Timeout = nowait) call to recvmsg
+%% Basically we make multiple async (Timeout = nowait) call(s) to recvmsg
 %% (from *several* processes), wait some time and then cancel.
 %% This should result in abort messages to the 'other' processes.
 %%
@@ -4811,6 +4823,7 @@ api_a_mrecv_cancel_udp(InitState) ->
            cmd  => fun(#{tester := Tester} = State) ->
                            case ?SEV_AWAIT_TERMINATE(Tester, tester) of
                                ok ->
+                                   ?SEV_IPRINT("terminating"),
                                    State1 = maps:remove(recv_select_info, State),
                                    State2 = maps:remove(tester,           State1),
                                    State3 = maps:remove(sock,             State2),
@@ -4922,6 +4935,38 @@ api_a_mrecv_cancel_udp(InitState) ->
                    end},
 
          %% Terminations
+         #{desc => "order alt-server 2 to terminate",
+           cmd  => fun(#{alt_server2 := Pid} = _State) ->
+                           ?SEV_ANNOUNCE_TERMINATE(Pid),
+                           ok
+                   end},
+         #{desc => "await alt-server 2 termination",
+           cmd  => fun(#{alt_server2 := Pid} = State) ->
+                           case ?SEV_AWAIT_TERMINATION(Pid) of
+                               ok ->
+                                   State1 = maps:remove(alt_server2, State),
+                                   {ok, State1};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+
+         #{desc => "order alt-server 1 to terminate",
+           cmd  => fun(#{alt_server1 := Pid} = _State) ->
+                           ?SEV_ANNOUNCE_TERMINATE(Pid),
+                           ok
+                   end},
+         #{desc => "await alt-server 1 termination",
+           cmd  => fun(#{alt_server1 := Pid} = State) ->
+                           case ?SEV_AWAIT_TERMINATION(Pid) of
+                               ok ->
+                                   State1 = maps:remove(alt_server1, State),
+                                   {ok, State1};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+
          #{desc => "order server to terminate",
            cmd  => fun(#{server := Pid} = _State) ->
                            ?SEV_ANNOUNCE_TERMINATE(Pid),
@@ -4958,10 +5003,411 @@ api_a_mrecv_cancel_udp(InitState) ->
                         alt_server2 => AltServer2#ev.pid},
     Tester = ?SEV_START("tester", TesterSeq, TesterInitState),
 
-    i("await evaluator"),
-    ok = ?SEV_AWAIT_FINISH([Server, Tester]).
+    i("await evaluator(s)"),
+    ok = ?SEV_AWAIT_FINISH([Server, AltServer1, AltServer2, Tester]).
+
+
+
+
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+%% Basically we make multiple async (Timeout = nowait) call(s) to accept
+%% (from *several* processes), wait some time and then cancel,
+%% This should result in abort messages to the 'other' processes.
+%%
+api_a_maccept_cancel_tcp4(suite) ->
+    [];
+api_a_maccept_cancel_tcp4(doc) ->
+    [];
+api_a_maccept_cancel_tcp4(_Config) when is_list(_Config) ->
+    ?TT(?SECS(20)),
+    tc_try(api_a_maccept_cancel_tcp4,
+           fun() ->
+                   Accept = fun(Sock) ->
+                                    case socket:accept(Sock, nowait) of
+                                        {ok, _} = OK ->
+                                            OK;
+                                        {error, _} = ERROR ->
+                                            ERROR
+                                    end
+                            end,
+                   InitState = #{domain => inet,
+                                 accept => Accept},
+                   ok = api_a_maccept_cancel_tcp(InitState)
+           end).
+
+
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+api_a_maccept_cancel_tcp(InitState) ->
+    process_flag(trap_exit, true),
+    ServerSeq = 
+        [
+         %% *** Wait for start order ***
+         #{desc => "await start (from tester)",
+           cmd  => fun(State) ->
+                           Tester = ?SEV_AWAIT_START(),
+                           {ok, State#{tester => Tester}}
+                   end},
+         #{desc => "monitor tester",
+           cmd  => fun(#{tester := Tester}) ->
+                           _MRef = erlang:monitor(process, Tester),
+                           ok
+                   end},
+
+         %% *** Init part ***
+         #{desc => "which local address",
+           cmd  => fun(#{domain := Domain} = State) ->
+                           LAddr = which_local_addr(Domain),
+                           LSA   = #{family => Domain, addr => LAddr},
+                           {ok, State#{lsa => LSA}}
+                   end},
+         #{desc => "create listen socket",
+           cmd  => fun(#{domain := Domain} = State) ->
+                           case socket:open(Domain, stream, tcp) of
+                               {ok, Sock} ->
+                                   {ok, State#{lsock => Sock}};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+         #{desc => "bind to local address",
+           cmd  => fun(#{lsock := LSock, lsa := LSA} = State) ->
+                           case socket:bind(LSock, LSA) of
+                               {ok, Port} ->
+                                   {ok, State#{lport => Port}};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+         #{desc => "make listen socket",
+           cmd  => fun(#{lsock := LSock}) ->
+                           socket:listen(LSock)
+                   end},
+         #{desc => "announce ready (init)",
+           cmd  => fun(#{tester := Tester, lsock := Sock}) ->
+                           ?SEV_ANNOUNCE_READY(Tester, init, Sock),
+                           ok
+                   end},
 
+         %% The actual test
+         #{desc => "await continue (accept)",
+           cmd  => fun(#{tester := Tester}) ->
+                           ?SEV_AWAIT_CONTINUE(Tester, tester, accept)
+                   end},
+         #{desc => "await connection (nowait)",
+           cmd  => fun(#{lsock := LSock, accept := Accept} = State) ->
+                           case Accept(LSock) of
+                               {ok, {select, T, R} = SelectInfo} ->
+                                   ?SEV_IPRINT("accept select: "
+                                               "~n   T: ~p"
+                                               "~n   R: ~p", [T, R]),
+                                   {ok, State#{accept_select_info => SelectInfo}};
+                               {ok, X} ->
+                                   {error, {unexpected_select_info, X}};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+         #{desc => "announce ready (accept_select)",
+           cmd  => fun(#{tester := Tester}) ->
+                           ?SEV_ANNOUNCE_READY(Tester, accept_select),
+                           ok
+                   end},
+         #{desc => "await select message (without success)",
+           cmd  => fun(#{lsock              := Sock,
+                         accept_select_info := {select, _, Ref}} = State) ->
+                           receive
+                               {'$socket', Sock, select, Ref} ->
+                                   {error, {unexpected_select, Ref}};
+                               {'$socket', Sock, abort, {Ref, closed}} ->
+                                   {ok, maps:remove(lsock, State)}
+                           after 5000 ->
+                                   ?SEV_IPRINT("message queue: ~p",
+                                               [process_info(self(),
+                                                             messages)]),
+                                   {error, timeout}
+                           end
+                   end},
+         #{desc => "announce ready (abort)",
+           cmd  => fun(#{tester := Tester}) ->
+                           ?SEV_ANNOUNCE_READY(Tester, abort),
+                           ok
+                   end},
 
+         %% *** Termination ***
+         #{desc => "await terminate",
+           cmd  => fun(#{tester := Tester} = State) ->
+                           case ?SEV_AWAIT_TERMINATE(Tester, tester) of
+                               ok ->
+                                   {ok, maps:remove(tester, State)};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+
+         %% *** We are done ***
+         ?SEV_FINISH_NORMAL
+        ],
+
+
+    AltServerSeq =
+        [
+         %% *** Wait for start order part ***
+         #{desc => "await start",
+           cmd  => fun(State) ->
+                           {Tester, Sock} = ?SEV_AWAIT_START(),
+                           {ok, State#{tester => Tester, lsock => Sock}}
+                   end},
+         #{desc => "monitor tester",
+           cmd  => fun(#{tester := Tester} = _State) ->
+                           _MRef = erlang:monitor(process, Tester),
+                           ok
+                   end},
+         #{desc => "announce ready (init)",
+           cmd  => fun(#{tester := Tester}) ->
+                           ?SEV_ANNOUNCE_READY(Tester, init),
+                           ok
+                   end},
+
+         %% The actual test
+         #{desc => "await continue (accept)",
+           cmd  => fun(#{tester := Tester} = _State) ->
+                           ?SEV_AWAIT_CONTINUE(Tester, tester, accept)
+                   end},
+         #{desc => "try accept request (with nowait, expect select)",
+           cmd  => fun(#{lsock := Sock, accept := Accept} = State) ->
+                           case Accept(Sock) of
+                               {ok, {select, _, _} = SelectInfo} ->
+                                   {ok, State#{accept_select_info => SelectInfo}};
+                               {ok, X} ->
+                                   {error, {unexpected_select_info, X}};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+         #{desc => "announce ready (accept_select)",
+           cmd  => fun(#{tester := Tester}) ->
+                           ?SEV_ANNOUNCE_READY(Tester, accept_select),
+                           ok
+                   end},
+         #{desc => "await abort message",
+           cmd  => fun(#{lsock              := Sock,
+                         accept_select_info := {select, _, Ref}} = State) ->
+                           receive
+                               {'$socket', Sock, select, Ref} ->
+                                   {error, {unexpected_select, Ref}};
+                               {'$socket', Sock, abort, {Ref, closed}} ->
+                                   {ok, maps:remove(sock, State)}
+                           after 5000 ->
+                                   ?SEV_IPRINT("message queue: ~p",
+                                               [process_info(self(),
+                                                             messages)]),
+                                   {error, timeout}
+                           end
+                   end},
+         #{desc => "announce ready (abort)",
+           cmd  => fun(#{tester := Tester}) ->
+                           ?SEV_ANNOUNCE_READY(Tester, abort),
+                           ok
+                   end},
+
+         %% Termination
+         #{desc => "await terminate (from tester)",
+           cmd  => fun(#{tester := Tester} = State) ->
+                           case ?SEV_AWAIT_TERMINATE(Tester, tester) of
+                               ok ->
+                                   ?SEV_IPRINT("terminating"),
+                                   State1 = maps:remove(tester,             State),
+                                   State2 = maps:remove(accept_select_info, State1),
+                                   State3 = maps:remove(lsock,              State2),
+                                   {ok, State3};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+
+         %% *** We are done ***
+         ?SEV_FINISH_NORMAL
+        ],
+
+
+    TesterSeq =
+        [
+         %% *** Init part ***
+         #{desc => "monitor server",
+           cmd  => fun(#{server := Pid} = _State) ->
+                           _MRef = erlang:monitor(process, Pid),
+                           ok
+                   end},
+         #{desc => "monitor alt-server 1",
+           cmd  => fun(#{alt_server1 := Pid} = _State) ->
+                           _MRef = erlang:monitor(process, Pid),
+                           ok
+                   end},
+         #{desc => "monitor alt-server 2",
+           cmd  => fun(#{alt_server2 := Pid} = _State) ->
+                           _MRef = erlang:monitor(process, Pid),
+                           ok
+                   end},
+
+         %% Start the server
+         #{desc => "order server start",
+           cmd  => fun(#{server := Pid} = _State) ->
+                           ?SEV_ANNOUNCE_START(Pid),
+                           ok
+                   end},
+         #{desc => "await server ready (init)",
+           cmd  => fun(#{server := Pid} = State) ->
+                           {ok, Sock} = ?SEV_AWAIT_READY(Pid, server, init),
+                           {ok, State#{sock => Sock}}
+                   end},
+
+         %% Start the alt-server 1
+         #{desc => "order alt-server 1 start",
+           cmd  => fun(#{alt_server1 := Pid, sock := Sock} = _State) ->
+                           ?SEV_ANNOUNCE_START(Pid, Sock),
+                           ok
+                   end},
+         #{desc => "await alt-server 1 ready (init)",
+           cmd  => fun(#{alt_server1 := Pid} = _State) ->
+                           ?SEV_AWAIT_READY(Pid, alt_server1, init)
+                   end},
+
+         %% Start the alt-server 2
+         #{desc => "order alt-server 2 start",
+           cmd  => fun(#{alt_server2 := Pid, sock := Sock} = _State) ->
+                           ?SEV_ANNOUNCE_START(Pid, Sock),
+                           ok
+                   end},
+         #{desc => "await alt-server 2 ready (init)",
+           cmd  => fun(#{alt_server2 := Pid} = _State) ->
+                           ?SEV_AWAIT_READY(Pid, alt_server2, init)
+                   end},
+
+
+         %% *** The actual test ***
+         #{desc => "order server continue (accept)",
+           cmd  => fun(#{server := Pid} = _State) ->
+                           ?SEV_ANNOUNCE_CONTINUE(Pid, accept),
+                           ok
+                   end},
+         #{desc => "await server ready (accept select)",
+           cmd  => fun(#{server := Pid} = _State) ->
+                           ok = ?SEV_AWAIT_READY(Pid, server, accept_select)
+                   end},
+
+         #{desc => "order alt-server 1 continue (accept)",
+           cmd  => fun(#{alt_server1 := Pid} = _State) ->
+                           ?SEV_ANNOUNCE_CONTINUE(Pid, accept),
+                           ok
+                   end},
+         #{desc => "await alt-server 1 ready (accept select)",
+           cmd  => fun(#{alt_server1 := Pid} = _State) ->
+                           ok = ?SEV_AWAIT_READY(Pid, alt_server1, accept_select)
+                   end},
+
+         #{desc => "order alt-server 2 continue (accept)",
+           cmd  => fun(#{alt_server2 := Pid} = _State) ->
+                           ?SEV_ANNOUNCE_CONTINUE(Pid, accept),
+                           ok
+                   end},
+         #{desc => "await alt-server 2 ready (accept select)",
+           cmd  => fun(#{alt_server2 := Pid} = _State) ->
+                           ok = ?SEV_AWAIT_READY(Pid, alt_server2, accept_select)
+                   end},
+
+         ?SEV_SLEEP(?SECS(1)),
+
+         #{desc => "close the socket",
+           cmd  => fun(#{sock := Sock} = _State) ->
+                           socket:close(Sock)
+                   end},
+
+         #{desc => "await server ready (abort)",
+           cmd  => fun(#{server := Pid} = _State) ->
+                           ok = ?SEV_AWAIT_READY(Pid, server, abort)
+                   end},
+         #{desc => "await alt-server 1 ready (abort)",
+           cmd  => fun(#{alt_server1 := Pid} = _State) ->
+                           ok = ?SEV_AWAIT_READY(Pid, alt_server1, abort)
+                   end},
+         #{desc => "await alt-server 2 ready (abort)",
+           cmd  => fun(#{alt_server2 := Pid} = _State) ->
+                           ok = ?SEV_AWAIT_READY(Pid, alt_server2, abort)
+                   end},
+
+
+         %% *** Termination ***
+         #{desc => "order alt-server 2 to terminate",
+           cmd  => fun(#{alt_server2 := Pid} = _State) ->
+                           ?SEV_ANNOUNCE_TERMINATE(Pid),
+                           ok
+                   end},
+         #{desc => "await alt-server 2 termination",
+           cmd  => fun(#{alt_server2 := Pid} = State) ->
+                           case ?SEV_AWAIT_TERMINATION(Pid) of
+                               ok ->
+                                   State1 = maps:remove(alt_server2, State),
+                                   {ok, State1};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+
+         #{desc => "order alt-server 1 to terminate",
+           cmd  => fun(#{alt_server1 := Pid} = _State) ->
+                           ?SEV_ANNOUNCE_TERMINATE(Pid),
+                           ok
+                   end},
+         #{desc => "await alt-server 1 termination",
+           cmd  => fun(#{alt_server1 := Pid} = State) ->
+                           case ?SEV_AWAIT_TERMINATION(Pid) of
+                               ok ->
+                                   State1 = maps:remove(alt_server1, State),
+                                   {ok, State1};
+                               {error, _} = ERROR ->
+                                   ERROR
+                           end
+                   end},
+
+         #{desc => "order server to terminate",
+           cmd  => fun(#{server := Server} = _State) ->
+                           ?SEV_ANNOUNCE_TERMINATE(Server),
+                           ok
+                   end},
+         #{desc => "await server termination",
+           cmd  => fun(#{server := Server} = State) ->
+                           ?SEV_AWAIT_TERMINATION(Server),
+                           State1 = maps:remove(server, State),
+                           {ok, State1}
+                   end},
+
+         %% *** We are done ***
+         ?SEV_FINISH_NORMAL
+        ],
+
+    i("start server evaluator"),
+    Server = ?SEV_START("server", ServerSeq, InitState),
+
+    i("start alt-server 1 evaluator"),
+    AltServer1 = ?SEV_START("alt_server1", AltServerSeq, InitState),
+
+    i("start alt-server 2 evaluator"),
+    AltServer2 = ?SEV_START("alt_server2", AltServerSeq, InitState),
+
+    i("start tester evaluator"),
+    TesterInitState = #{server      => Server#ev.pid,
+                        alt_server1 => AltServer1#ev.pid,
+                        alt_server2 => AltServer2#ev.pid},
+    Tester = ?SEV_START("tester", TesterSeq, TesterInitState),
+
+    i("await evaluator(s)"),
+    ok = ?SEV_AWAIT_FINISH([Server, AltServer1, AltServer2, Tester]).