File 1901-Drop-support-for-rpc-communication-with-no... of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 1901-Drop-support-for-rpc-communication-with-nodes-lackin.patch of Package erlang (Revision bf3a5557316b9c4af47c55d0b2592dd6)

Currently displaying revision bf3a5557316b9c4af47c55d0b2592dd6 , Show latest

From cd0f320e37ef679d0ca45e27cccd6ef978f1d9ab Mon Sep 17 00:00:00 2001
From: Rickard Green <rickard@erlang.org>
Date: Thu, 7 Oct 2021 13:04:11 +0200
Subject: [PATCH 01/10] Drop support for 'rpc' communication with nodes lacking
 'erpc'

The 'rpc' module now requires that nodes that it communicates with
implements the 'erpc' protocol. That is, 'rpc' will fail to
communicate with nodes of OTP releases prior to OTP 23.
---
 lib/kernel/src/rpc.erl        | 441 +---------------------------------
 lib/kernel/test/rpc_SUITE.erl | 106 ++++----
 2 files changed, 67 insertions(+), 480 deletions(-)

diff --git a/lib/kernel/src/rpc.erl b/lib/kernel/src/rpc.erl
index 6613028a0b..9ca0283f68 100644
--- a/lib/kernel/src/rpc.erl
+++ b/lib/kernel/src/rpc.erl
@@ -20,11 +20,7 @@
 -module(rpc).
 
 %%
-%% Implementations inside '-ifdef(SERVER_SIDE_ERPC_IS_MANDATORY).'
-%% below require 'erpc' support to be mandatory on server side.
-%% 'erpc' was introduced in OTP 23, so it should be possible to
-%% enable this as of OTP 25:
-%%   -define(SERVER_SIDE_ERPC_IS_MANDATORY, yes).
+%% As of OTP 25 the rpc module require server side support for erpc.
 %%
 
 %% General rpc, broadcast,multicall, promise and parallel evaluator
@@ -355,32 +351,6 @@ nodes_observer_loop(Tab) ->
     end,
     nodes_observer_loop(Tab).
 
--ifdef(SERVER_SIDE_ERPC_IS_MANDATORY).
-
-%% Currently node_has_feature() is only needed if
-%% it is unknown if 'erpc' is supported by server
-%% side or not...
-
--else. %% ! define SERVER_SIDE_ERPC_IS_MANDATORY
-
--dialyzer([{nowarn_function, node_has_feature/2}, no_match]).
-
--spec node_has_feature(Node :: atom(), Feature :: term()) -> boolean().
-
-node_has_feature(N, erpc) when N == node() ->
-    true;
-node_has_feature(N, erpc) ->
-    try
-        Tab = persistent_term:get(?TAB_NAME),
-        ets:lookup_element(Tab, N, 2)
-    catch
-        _:_ -> false
-    end;
-node_has_feature(_N, _Feature) ->
-    false.
-
--endif.
-
 %% THE rpc client interface
 
 %% Call
@@ -417,34 +387,9 @@ call(N,M,F,A) ->
       Reason :: term(),
       Timeout :: ?TIMEOUT_TYPE.
 
--ifdef(SERVER_SIDE_ERPC_IS_MANDATORY).
-
 call(N,M,F,A,T) ->
     ?RPCIFY(erpc:call(N, M, F, A, T)).
 
--else. %% ! defined SERVER_SIDE_ERPC_IS_MANDATORY
-
-call(N,M,F,A,T) ->
-    DL = try
-             deadline(T)
-         catch
-             error:_ ->
-                 error(badarg)
-         end,
-    case ?RPCIFY(erpc:call(N, M, F, A, T)) of
-        {badrpc, notsup} ->
-            case time_left(DL) of
-                0 ->
-                    {badrpc, timeout};
-                Timeout ->
-                    do_srv_call(N, {call,M,F,A,group_leader()}, Timeout)
-            end;
-        Res ->
-            Res
-    end.
-
--endif. %% ! defined SERVER_SIDE_ERPC_IS_MANDATORY
-
 -spec block_call(Node, Module, Function, Args) -> Res | {badrpc, Reason} when
       Node :: node(),
       Module :: module(),
@@ -573,8 +518,6 @@ server_call(Node, Name, ReplyWrapper, Msg)
       Function :: atom(),
       Args :: [term()].
 
--ifdef(SERVER_SIDE_ERPC_IS_MANDATORY).
-
 cast(Node, Mod, Fun, Args) ->
     try
         ok = erpc:cast(Node, Mod, Fun, Args)
@@ -584,32 +527,6 @@ cast(Node, Mod, Fun, Args) ->
     end,
     true.
 
--else.
-
-cast(Node, Mod, Fun, Args) when is_atom(Node),
-                                is_atom(Mod),
-                                is_atom(Fun),
-                                is_list(Args) ->
-    _ = case node_has_feature(Node, erpc) of
-            false ->
-                gen_server:cast({?NAME,Node},
-                                {cast,Mod,Fun,Args,group_leader()});
-            true ->
-                try
-                    ok = erpc:cast(Node, Mod, Fun, Args)
-                catch
-                    error:{erpc, badarg} ->
-                        error(badarg)
-                end
-        end,
-    true;
-cast(_, _, _, _) ->
-    error(badarg).
-
-
--endif.
-
-
 %% Asynchronous broadcast, returns nothing, it's just send 'n' pray
 -spec abcast(Name, Msg) -> abcast when
       Name :: atom(),
@@ -741,21 +658,14 @@ multicall(M, F, A, Timeout) ->
       ResL :: [Res :: term() | {'badrpc', Reason :: term()}],
       BadNodes :: [node()].
 
--ifdef(SERVER_SIDE_ERPC_IS_MANDATORY).
-
-%%
-%% Use this more efficient implementation of multicall()
-%% when 'erpc' support can be made mandatory for server
-%% side.
-%%
 multicall(Nodes, M, F, A, Timeout) ->
     %%
     %% We want to use erpc:multicall() and then convert the result
     %% instead of using erpc:send_request()/erpc:receive_response()
-    %% directly. This since it is expected that erpc:multicall()
-    %% will be able to utilize a future message queue optimization
-    %% that erpc:send_request()/erpc:receive_response() most likely
-    %% wont be able to (only the future will tell...).
+    %% directly. This since erpc:multicall() is able to utilize the
+    %% selective receive optimization when all clauses match on the
+    %% same reference. erpc:send_request()/erpc:receive_response()
+    %% is not able to utilize such optimizations.
     %%
     ERpcRes = try
                   erpc:multicall(Nodes, M, F, A, Timeout)
@@ -778,256 +688,6 @@ rpcmulticallify([N|Ns], [{error, {erpc, Reason}}|Rlts], Ok, Err)
 rpcmulticallify([_N|Ns], [{Class, Reason}|Rlts], Ok, Err) ->
     rpcmulticallify(Ns, Rlts, [rpcify_exception(Class, Reason)|Ok], Err).
 
--else. %% ! defined SERVER_SIDE_ERPC_IS_MANDATORY
-
-%%
-%% Currently used implementation for multicall(). When
-%% 'erpc' support can be required for server side,
-%% replace with the implementation above...
-%% 
-
-multicall(Nodes, M, F, A, Timeout) ->
-    try
-        true = is_atom(M),
-        true = is_atom(F),
-        true = is_list(A),
-        Deadline = deadline(Timeout),
-        Res = make_ref(),
-        MFA = {M, F, A},
-        {NRs, ReqMap0} = mc_requests(Res, Nodes, M, F, A, [], #{}),
-        ReqMap1 = mc_spawn_replies(Res, maps:size(ReqMap0), ReqMap0,
-                                   MFA, Deadline),
-        mc_results(Res, NRs, [], [], ReqMap1, MFA, Deadline)
-    catch
-        error:NotIError when NotIError /= internal_error ->
-            error(badarg)
-    end.
-
-mc_requests(_Res, [], _M, _F, _A, NRs, ReqMap) ->
-    {NRs, ReqMap};
-mc_requests(Res, [N|Ns], M, F, A, NRs, ReqMap) ->
-    ReqId = try
-                spawn_request(N, erpc, execute_call,
-                              [Res, M, F, A],
-                              [{reply_tag, {spawn_reply, Res, N}},
-                               monitor])
-            catch
-                _:_ ->
-                    mc_fail_requests(Res, NRs)
-            end,
-    NR = {N, ReqId},
-    mc_requests(Res, Ns, M, F, A, [NR|NRs], ReqMap#{ReqId => spawn_request});
-mc_requests(Res, _Error, _M, _F, _A, NRs, _ReqMap) ->
-    mc_fail_requests(Res, NRs).
-
-%% Abandon any requests sent then fail...
-mc_fail_requests(_Res, []) ->
-    error(badarg);
-mc_fail_requests(Res, [{Node, ReqId} | NRs]) ->
-    case spawn_request_abandon(ReqId) of
-        true ->
-            ok;
-        false ->
-            receive
-                {{spawn_reply, Res, Node}, ReqId, error, _} ->
-                    ok;
-                {{spawn_reply, Res, Node}, ReqId, ok, Pid} ->
-                    case erlang:demonitor(ReqId, [info]) of
-                        true ->
-                            ok;
-                        false ->
-                            receive
-                                {'DOWN', ReqId, process, Pid, _} ->
-                                    ok
-                            after
-                                0 ->
-                                    error(internal_error)
-                            end
-                    end
-            after
-                0 ->
-                    error(internal_error)
-            end
-    end,
-    mc_fail_requests(Res, NRs).
-
-mc_spawn_replies(_Res, 0, ReqMap, _MFA, _Deadline) ->
-    ReqMap;
-mc_spawn_replies(Res, Outstanding, ReqMap, MFA, Deadline) ->
-    Timeout = time_left(Deadline),
-    receive
-        {{spawn_reply, Res, _}, _, _, _} = Reply ->
-            NewReqMap = mc_handle_spawn_reply(Reply, ReqMap, MFA, Deadline),
-            mc_spawn_replies(Res, Outstanding-1, NewReqMap, MFA, Deadline)
-    after
-        Timeout ->
-            ReqMap
-    end.
-
-mc_handle_spawn_reply({{spawn_reply, _Res, _Node}, ReqId, ok, Pid},
-                      ReqMap, _MFA, _Deadline) ->
-    ReqMap#{ReqId => {spawn, Pid}};
-mc_handle_spawn_reply({{spawn_reply, _Res, Node}, ReqId, error, notsup},
-                      ReqMap, MFA, infinity) ->
-    {M, F, A} = MFA,
-    SrvReqId = gen_server:send_request({?NAME, Node},
-                                       {call, M,F,A,
-                                        group_leader()}),
-    ReqMap#{ReqId => {server, SrvReqId}};
-mc_handle_spawn_reply({{spawn_reply, Res, Node}, ReqId, error, notsup},
-                      ReqMap, MFA, Deadline) ->
-    {M, F, A} = MFA,
-    try
-        {Pid, Mon} = spawn_monitor(fun () ->
-                                           process_flag(trap_exit, true),
-                                           Request = {call, M,F,A,
-                                                      group_leader()},
-                                           Timeout = time_left(Deadline),
-                                           Result = gen_server:call({?NAME,
-                                                                     Node},
-                                                                    Request,
-                                                                    Timeout),
-                                           exit({Res, Result})
-                                   end),
-        ReqMap#{ReqId => {spawn_server, Mon, Pid}}
-    catch
-        error:system_limit ->
-            ReqMap#{ReqId => {error, {badrpc, {'EXIT', system_limit}}}}
-    end;
-mc_handle_spawn_reply({{spawn_reply, _Res, _Node}, ReqId, error, noconnection},
-                      ReqMap, _MFA, _Deadline) ->
-    ReqMap#{ReqId => {error, badnode}};
-mc_handle_spawn_reply({{spawn_reply, _Res, _Node}, ReqId, error, Reason},
-                      ReqMap, _MFA, _Deadline) ->
-    ReqMap#{ReqId => {error, {badrpc, {'EXIT', Reason}}}}.
-
-mc_results(_Res, [], OkAcc, ErrAcc, _ReqMap, _MFA, _Deadline) ->
-    {OkAcc, ErrAcc};
-mc_results(Res, [{N,ReqId}|NRs] = OrigNRs, OkAcc, ErrAcc,
-           ReqMap, MFA, Deadline) ->
-    case maps:get(ReqId, ReqMap) of
-        {error, badnode} ->
-            mc_results(Res, NRs, OkAcc, [N|ErrAcc], ReqMap, MFA, Deadline);
-        {error, BadRpc} ->
-            mc_results(Res, NRs, [BadRpc|OkAcc], ErrAcc, ReqMap,
-                       MFA, Deadline);
-        spawn_request ->
-            %% We timed out waiting for spawn replies...
-            case spawn_request_abandon(ReqId) of
-                true ->
-                    %% Timed out request...
-                    mc_results(Res, NRs, OkAcc, [N|ErrAcc], ReqMap,
-                               MFA, Deadline);
-                false ->
-                    %% Reply has been delivered now; handle it...
-                    receive
-                        {{spawn_reply, Res, _}, ReqId, _, _} = Reply ->
-                            NewReqMap = mc_handle_spawn_reply(Reply, ReqMap,
-                                                              MFA, Deadline),
-                            mc_results(Res, OrigNRs, OkAcc, ErrAcc,
-                                       NewReqMap, MFA, Deadline)
-                    after 0 ->
-                            error(internal_error)
-                    end
-            end;
-        {spawn, Pid} ->
-            Timeout = time_left(Deadline),
-            receive
-                {'DOWN', ReqId, process, Pid, Reason} ->
-                    case ?RPCIFY(erpc:call_result(down, ReqId, Res, Reason)) of
-                        {badrpc, nodedown} ->
-                            mc_results(Res, NRs, OkAcc, [N|ErrAcc],
-                                       ReqMap, MFA, Deadline);
-                        CallRes ->
-                            mc_results(Res, NRs, [CallRes|OkAcc],
-                                       ErrAcc, ReqMap, MFA, Deadline)
-                    end
-            after
-                Timeout ->
-                    case erlang:demonitor(ReqId, [info]) of
-                        true ->
-                            mc_results(Res, NRs, OkAcc, [N|ErrAcc],
-                                       ReqMap, MFA, Deadline);
-                        false ->
-                            receive
-                                {'DOWN', ReqId, process, Pid, Reason} ->
-                                    case ?RPCIFY(erpc:call_result(down,
-                                                                  ReqId,
-                                                                  Res,
-                                                                  Reason)) of
-                                        {badrpc, nodedown} ->
-                                            mc_results(Res, NRs, OkAcc,
-                                                       [N|ErrAcc], ReqMap,
-                                                       MFA, Deadline);
-                                        CallRes ->
-                                            mc_results(Res, NRs,
-                                                       [CallRes|OkAcc],
-                                                       ErrAcc, ReqMap,
-                                                       MFA, Deadline)
-                                    end
-                            after 0 ->
-                                    error(internal_error)
-                            end
-                    end
-            end;
-        {spawn_server, Mon, Pid} ->
-            %% Old node with timeout on the call...
-            Result = receive
-                         {'DOWN', Mon, process, Pid, {Res, CallRes}} ->
-                             rpc_check(CallRes);
-                         {'DOWN', Mon, process, Pid, Reason} ->
-                             rpc_check_t({'EXIT',Reason})
-                     end,
-            case Result of
-                {badrpc, BadRpcReason} when BadRpcReason == timeout;
-                                            BadRpcReason == nodedown ->
-                    mc_results(Res, NRs, OkAcc, [N|ErrAcc],
-                               ReqMap, MFA, Deadline);
-                _ ->
-                    mc_results(Res, NRs, [Result|OkAcc], ErrAcc, ReqMap,
-                               MFA, Deadline)
-            end;
-        {server, SrvReqId} ->
-            %% Old node without timeout on the call...
-            case gen_server:wait_response(SrvReqId, infinity) of
-                {reply, Reply} ->
-                    Result = rpc_check(Reply),
-                    mc_results(Res, NRs, [Result|OkAcc], ErrAcc,
-                               ReqMap, MFA, Deadline);
-                {error, {noconnection, _}} ->
-                    mc_results(Res, NRs, OkAcc, [N|ErrAcc],
-                               ReqMap, MFA, Deadline);
-                {error, {Reason, _}} ->
-                    BadRpc = {badrpc, {'EXIT', Reason}},
-                    mc_results(Res, NRs, [BadRpc|OkAcc], ErrAcc,
-                               ReqMap, MFA, Deadline)
-            end
-    end.
-
-deadline(infinity) ->
-    infinity;
-deadline(?MAX_INT_TIMEOUT) ->
-    erlang:convert_time_unit(erlang:monotonic_time(millisecond)
-                             + ?MAX_INT_TIMEOUT,
-                             millisecond,
-                             native);
-deadline(T) when ?IS_VALID_TMO_INT(T) ->
-    Now = erlang:monotonic_time(),
-    NativeTmo = erlang:convert_time_unit(T, millisecond, native),
-    Now + NativeTmo.
-
-time_left(infinity) ->
-    infinity;
-time_left(Deadline) ->
-    case Deadline - erlang:monotonic_time() of
-        TimeLeft when TimeLeft =< 0 ->
-            0;
-        TimeLeft ->
-            erlang:convert_time_unit(TimeLeft-1, native, millisecond) + 1
-    end.
-
--endif. %% ! defined SERVER_SIDE_ERPC_IS_MANDATORY
-
 %% Send Msg to Name on all nodes, and collect the answers.
 %% Return {Replies, Badnodes} where Badnodes is a list of the nodes
 %% that failed during the timespan of the call.
@@ -1085,14 +745,6 @@ rec_nodes(Name, [{N,R} | Tail], Badnodes, Replies) ->
 %% rpc's towards the same node. I.e. it returns immediately and 
 %% it returns a Key that can be used in a subsequent yield(Key).
 
--ifdef(SERVER_SIDE_ERPC_IS_MANDATORY).
-
-%%
-%% Use this more efficient implementation of async_call()
-%% when 'erpc' support can be made mandatory for server
-%% side.
-%%
-
 -opaque key() :: erpc:request_id().
 
 -spec async_call(Node, Module, Function, Args) -> Key when
@@ -1124,17 +776,16 @@ yield(Key) ->
       Val :: (Res :: term()) | {badrpc, Reason :: term()}.
 
 nb_yield(Key, Tmo) ->
-    case ?RPCIFY(erpc:wait_response(Key, Tmo)) of
+    try erpc:wait_response(Key, Tmo) of
         no_response ->
             timeout;
         {response, {'EXIT', _} = BadRpc} ->
-            %% RPCIFY() cannot handle this case...
             {value, {badrpc, BadRpc}};
         {response, R} ->
-            {value, R};
-        BadRpc ->
-            %% An exception converted by RPCIFY()...
-            {value, BadRpc}
+            {value, R}
+    catch
+        Class:Reason ->
+            {value, rpcify_exception(Class, Reason)}
     end.
 
 -spec nb_yield(Key) -> {value, Val} | timeout when
@@ -1144,78 +795,6 @@ nb_yield(Key, Tmo) ->
 nb_yield(Key) ->
     nb_yield(Key, 0).
 
--else. %% ! defined SERVER_SIDE_ERPC_IS_MANDATORY
-
-%%
-%% Currently used implementation for async_call(). When
-%% 'erpc' support can be required for server side,
-%% replace with the implementation above...
-%% 
-
--opaque key() :: {pid(), reference()}.
-
--spec async_call(Node, Module, Function, Args) -> Key when
-      Node :: node(),
-      Module :: module(),
-      Function :: atom(),
-      Args :: [term()],
-      Key :: key().
-
-async_call(Node, Mod, Fun, Args) ->
-    try
-        true = is_atom(Node),
-        true = is_atom(Mod),
-        true = is_atom(Fun),
-        true = is_integer(length(Args))
-    catch
-        _:_ ->
-            error(badarg)
-    end,
-    Caller = self(),
-    spawn_monitor(fun() ->
-                          process_flag(trap_exit, true),
-                          R = call(Node, Mod, Fun, Args),
-                          exit({async_call_result, Caller, R})
-                  end).
-
--spec yield(Key) -> Res | {badrpc, Reason} when
-      Key :: key(),
-      Res :: term(),
-      Reason :: term().
-
-yield({Pid, Ref} = Key) when is_pid(Pid),
-                             is_reference(Ref) ->
-    {value,R} = nb_yield(Key, infinity),
-    R.
-
--spec nb_yield(Key) -> {value, Val} | timeout when
-      Key :: key(),
-      Val :: (Res :: term()) | {badrpc, Reason :: term()}.
-
-nb_yield({Pid, Ref} = Key) when is_pid(Pid),
-                                is_reference(Ref) ->
-    nb_yield(Key, 0).
-
--spec nb_yield(Key, Timeout) -> {value, Val} | timeout when
-      Key :: key(),
-      Timeout :: ?TIMEOUT_TYPE,
-      Val :: (Res :: term()) | {badrpc, Reason :: term()}.
-
-nb_yield({Proxy, Mon}, Tmo) when is_pid(Proxy),
-                                 is_reference(Mon),
-                                 ?IS_VALID_TMO(Tmo) ->
-    Me = self(),
-    receive
-        {'DOWN', Mon, process, Proxy, {async_call_result, Me, R}} ->
-            {value,R};
-        {'DOWN', Mon, process, Proxy, Reason} ->
-            {value, {badrpc, {'EXIT', Reason}}}
-    after Tmo ->
-            timeout
-    end.
-
--endif. %% ! defined SERVER_SIDE_ERPC_IS_MANDATORY
-
 %% A parallel network evaluator
 %% ArgL === [{M,F,Args},........]
 %% Returns a lists of the evaluations in the same order as 
diff --git a/lib/kernel/test/rpc_SUITE.erl b/lib/kernel/test/rpc_SUITE.erl
index 0012216638..efc0d75de5 100644
--- a/lib/kernel/test/rpc_SUITE.erl
+++ b/lib/kernel/test/rpc_SUITE.erl
@@ -592,19 +592,20 @@ async_call(Config) when is_list(Config) ->
     ok.
 
 call_against_old_node(Config) ->
-    case start_22_node(Config) of
-        {ok, Node22} ->
-            Node22 = rpc:call(Node22, erlang, node, []),
-            stop_node(Node22),
+    case start_old_node(Config) of
+        {ok, NodeOld} ->
+            NodeOld = rpc:call(NodeOld, erlang, node, []),
+            stop_node(NodeOld),
             ok;
         _ ->
-	    {skipped, "No OTP 22 available"}
+            OldRel = old_release(),
+	    {skipped, "No OTP "++OldRel++" available"}
     end.
 
 multicall_mix(Config) ->
     {ok, Node1} = start_node(Config),
     {ok, Node2} = start_node(Config),
-    {Node3, OldNodeTest} = case start_22_node(Config) of
+    {Node3, OldNodeTest} = case start_old_node(Config) of
                                {ok, N3} ->
                                    {N3, true};
                                _ ->
@@ -710,9 +711,10 @@ multicall_mix(Config) ->
 
     [] = flush([]),
 
+    OldRel = old_release(),
     case OldNodeTest of
-        true -> {comment, "Test with OTP 22 node as well"};
-        false -> {comment, "Test without OTP 22"}
+        true -> {comment, "Test with OTP "++OldRel++" node as well"};
+        false -> {comment, "Test without OTP "++OldRel}
     end.
 
 call_func1(X) ->
@@ -768,51 +770,53 @@ timeout_limit(Config) when is_list(Config) ->
     
 
 call_old_against_new(Config) ->
-    case test_server:is_release_available("22_latest") of
+    OldRel = old_release(),
+    case test_server:is_release_available(OldRel++"_latest") of
         false ->
-            {skipped, "No OTP 22 available"};
+            {skipped, "No OTP "++OldRel++" available"};
         true ->
-            test_on_22_node(Config, call_old_against_new_test, 1, 1)
+            test_on_old_node(Config, call_old_against_new_test, 1, 1)
     end.
 
-call_old_against_new_test([Node22], [NodeCurr]) ->
-    %% Excecuted on an OTP 22 node
+call_old_against_new_test([NodeOld], [NodeCurr]) ->
+    %% Excecuted on an OTP old node
 
-    Node22 = rpc:call(Node22, erlang, node, []),
+    NodeOld = rpc:call(NodeOld, erlang, node, []),
     NodeCurr = rpc:call(NodeCurr, erlang, node, []),
 
-    {badrpc, {'EXIT', bang}} = rpc:call(Node22, erlang, exit, [bang]),
+    {badrpc, {'EXIT', bang}} = rpc:call(NodeOld, erlang, exit, [bang]),
     {badrpc, {'EXIT', bang}} = rpc:call(NodeCurr, erlang, exit, [bang]),
 
-    {badrpc, {'EXIT', {blong, _}}} = rpc:call(Node22, erlang, error, [blong]),
+    {badrpc, {'EXIT', {blong, _}}} = rpc:call(NodeOld, erlang, error, [blong]),
     {badrpc, {'EXIT', {blong, _}}} = rpc:call(NodeCurr, erlang, error, [blong]),
 
-    bling = rpc:call(Node22, erlang, throw, [bling]),
+    bling = rpc:call(NodeOld, erlang, throw, [bling]),
     bling = rpc:call(NodeCurr, erlang, throw, [bling]),
 
-    {badrpc, timeout} = rpc:call(Node22, timer, sleep, [1000], 100),
+    {badrpc, timeout} = rpc:call(NodeOld, timer, sleep, [1000], 100),
     {badrpc, timeout} = rpc:call(NodeCurr, timer, sleep, [1000], 100),
 
-    {badrpc, nodedown} = rpc:call(Node22, erlang, halt, []),
+    {badrpc, nodedown} = rpc:call(NodeOld, erlang, halt, []),
     {badrpc, nodedown} = rpc:call(NodeCurr, erlang, halt, []),
 
-    {badrpc, nodedown} = rpc:call(Node22, erlang, node, []),
+    {badrpc, nodedown} = rpc:call(NodeOld, erlang, node, []),
     {badrpc, nodedown} = rpc:call(NodeCurr, erlang, node, []),
 
     ok.
     
 multicall_old_against_new(Config) ->
-    case test_server:is_release_available("22_latest") of
+    OldRel = old_release(),
+    case test_server:is_release_available(OldRel++"_latest") of
         false ->
-            {skipped, "No OTP 22 available"};
+            {skipped, "No OTP "++OldRel++" available"};
         true ->
-            test_on_22_node(Config, multicall_old_against_new_test, 2, 2)
+            test_on_old_node(Config, multicall_old_against_new_test, 2, 2)
     end.
 
-multicall_old_against_new_test([Node22A, Node22B], [NodeCurrA, NodeCurrB]) ->
-    %% Excecuted on an OTP 22 node
+multicall_old_against_new_test([NodeOldA, NodeOldB], [NodeCurrA, NodeCurrB]) ->
+    %% Excecuted on an OTP old node
 
-    AllNodes = [NodeCurrA, Node22A, NodeCurrB, Node22B],
+    AllNodes = [NodeCurrA, NodeOldA, NodeCurrB, NodeOldB],
     NoNodes = length(AllNodes),
 
     {AllNodes, []} = rpc:multicall(AllNodes, erlang, node, []),
@@ -839,32 +843,33 @@ multicall_old_against_new_test([Node22A, Node22B], [NodeCurrA, NodeCurrB]) ->
     ok.
 
 cast_old_against_new(Config) ->
-    case test_server:is_release_available("22_latest") of
+    OldRel = old_release(),
+    case test_server:is_release_available(OldRel++"_latest") of
         false ->
-            {skipped, "No OTP 22 available"};
+            {skipped, "No OTP "++OldRel++" available"};
         true ->
-            test_on_22_node(Config, cast_old_against_new_test, 1, 1)
+            test_on_old_node(Config, cast_old_against_new_test, 1, 1)
     end.
 
-cast_old_against_new_test([Node22], [NodeCurr]) ->
-    %% Excecuted on an OTP 22 node
+cast_old_against_new_test([NodeOld], [NodeCurr]) ->
+    %% Excecuted on an OTP old node
 
     Me = self(),
     Ref = make_ref(),
-    true = rpc:cast(Node22, erlang, send, [Me, {Ref, 1}]),
+    true = rpc:cast(NodeOld, erlang, send, [Me, {Ref, 1}]),
     receive {Ref, 1} -> ok end,
     true = rpc:cast(NodeCurr, erlang, send, [Me, {Ref, 2}]),
     receive {Ref, 2} -> ok end,
 
-    true = rpc:cast(Node22, erlang, halt, []),
+    true = rpc:cast(NodeOld, erlang, halt, []),
     true = rpc:cast(NodeCurr, erlang, halt, []),
 
-    monitor_node(Node22, true),
-    receive {nodedown, Node22} -> ok end,
+    monitor_node(NodeOld, true),
+    receive {nodedown, NodeOld} -> ok end,
     monitor_node(NodeCurr, true),
     receive {nodedown, NodeCurr} -> ok end,
 
-    true = rpc:cast(Node22, erlang, send, [Me, {Ref, 3}]),
+    true = rpc:cast(NodeOld, erlang, send, [Me, {Ref, 3}]),
     true = rpc:cast(NodeCurr, erlang, send, [Me, {Ref, 4}]),
 
     receive Msg -> error({unexcpected_message, Msg})
@@ -883,8 +888,11 @@ start_node(Config) ->
     Pa = filename:dirname(code:which(?MODULE)),
     test_server:start_node(Name, slave, [{args,  "-pa " ++ Pa}]).
 
-start_22_node(Config) ->
-    Rel = "22_latest",
+old_release() ->
+    integer_to_list(list_to_integer(erlang:system_info(otp_release))-2).
+
+start_old_node(Config) ->
+    Rel = old_release() ++ "_latest",
     case test_server:is_release_available(Rel) of
 	false ->
             notsup;
@@ -925,33 +933,33 @@ f2() ->
     timer:sleep(500),
     halt().
 
-test_on_22_node(Config, Test, No22, NoCurr) ->
-    Nodes22 = lists:map(fun (_) ->
-                                {ok, N} = start_22_node(Config),
+test_on_old_node(Config, Test, NoOld, NoCurr) ->
+    NodesOld = lists:map(fun (_) ->
+                                {ok, N} = start_old_node(Config),
                                 N
                         end,
-                        lists:seq(1, No22+1)),
+                        lists:seq(1, NoOld+1)),
     NodesCurr = lists:map(fun (_) ->
                                   {ok, N} = start_node(Config),
                                   N
                           end,
                           lists:seq(1, NoCurr)),
 
-    %% Recompile rpc_SUITE on OTP 22 node and load it on all OTP 22 nodes...
+    %% Recompile rpc_SUITE on old node and load it on all old nodes...
     SrcFile = filename:rootname(code:which(?MODULE)) ++ ".erl",
-    {ok, ?MODULE, BeamCode} = rpc:call(hd(Nodes22), compile, file, [SrcFile, [binary]]),
-    LoadResult = lists:duplicate(length(Nodes22), {module, ?MODULE}),
-    {LoadResult, []} = rpc:multicall(Nodes22, code, load_binary, [?MODULE, SrcFile, BeamCode]),
+    {ok, ?MODULE, BeamCode} = rpc:call(hd(NodesOld), compile, file, [SrcFile, [binary]]),
+    LoadResult = lists:duplicate(length(NodesOld), {module, ?MODULE}),
+    {LoadResult, []} = rpc:multicall(NodesOld, code, load_binary, [?MODULE, SrcFile, BeamCode]),
     try
-        %% Excecute test on first OTP 22 node...
-        Pid = spawn_link(hd(Nodes22), ?MODULE, Test, [tl(Nodes22), NodesCurr]),
+        %% Excecute test on first old node...
+        Pid = spawn_link(hd(NodesOld), ?MODULE, Test, [tl(NodesOld), NodesCurr]),
         Mon = erlang:monitor(process, Pid),
         receive
             {'DOWN', Mon, process, Pid, Reason} when Reason == normal; Reason == noproc ->
                 ok
         end
     after
-        lists:foreach(fun (N) -> stop_node(N) end, Nodes22),
+        lists:foreach(fun (N) -> stop_node(N) end, NodesOld),
         lists:foreach(fun (N) -> stop_node(N) end, NodesCurr)
     end,
     ok.
-- 
2.31.1

Places

File 1901-Drop-support-for-rpc-communication-with-nodes-lackin.patch of Package erlang (Revision bf3a5557316b9c4af47c55d0b2592dd6)

Places