啟動並控制連結的 Erlang 節點。

此模組提供啟動連結的 Erlang 節點的函數。產生新節點的節點稱為origin，而新啟動的節點稱為peer節點或對等節點。當對等節點失去與 origin 的控制連線時，會自動終止。此連線可以是 Erlang 分散式連線，或替代連線 - TCP 或標準 I/O。替代連線提供即使 Erlang 分散式不可用時，也能執行遠端程序呼叫的方式，允許測試分散式本身。

對等節點的終端輸入/輸出會透過 origin 轉發。如果請求標準 I/O 替代連線，主控台輸出也會透過 origin 傳遞，允許偵錯節點啟動和啟動腳本的執行（請參閱 -init_debug）。檔案 I/O 不會被重新導向，這與 slave 的行為相反。

對等節點可以在相同或不同的主機上啟動（透過 ssh）或在單獨的容器中啟動（例如 Docker）。當對等節點在與 origin 相同的主機上啟動時，它會繼承 origin 的目前目錄和環境變數。

注意

此模組旨在促進使用 Common Test 的多節點測試。使用 ?CT_PEER() 巨集，根據 Common Test 的慣例啟動連結的對等節點：將當機轉儲寫入特定位置，節點名稱以模組名稱、呼叫函數和 origin OS 程序 ID 為前綴）。如果您需要更多控制，請使用 random_name/1 來建立足夠獨特的節點名稱。

在沒有替代連線的情況下啟動的對等節點的行為與 slave 類似。當請求替代連線時，其行為類似於 test_server:start_node(Name, peer, Args).

範例

以下範例實作了一個測試套件，啟動額外的 Erlang 節點。它採用多種技術來加速測試並可靠地關閉對等節點

• 對等節點啟動時連結到測試執行器程序。如果測試案例失敗，對等節點會自動停止，而不會在背景中留下任何異常節點執行
• 用於啟動對等節點的參數會儲存在控制程序的狀態中，以供手動分析。如果測試案例失敗，當機報告會包含這些參數
• 多個測試案例可以同時執行，從而加速整體測試過程，即使同時執行同一測試套件的多個實例，對等節點名稱也是唯一的

-module(my_SUITE).
-behaviour(ct_suite).
-export([all/0, groups/0]).
-export([basic/1, args/1, named/1, restart_node/1, multi_node/1]).

-include_lib("common_test/include/ct.hrl").

groups() ->
    [{quick, [parallel],
        [basic, args, named, restart_node, multi_node]}].

all() ->
    [{group, quick}].

basic(Config) when is_list(Config) ->
    {ok, Peer, _Node} = ?CT_PEER(),
    peer:stop(Peer).

args(Config) when is_list(Config) ->
    %% specify additional arguments to the new node
    {ok, Peer, _Node} = ?CT_PEER(["-emu_flavor", "smp"]),
    peer:stop(Peer).

named(Config) when is_list(Config) ->
    %% pass test case name down to function starting nodes
    Peer = start_node_impl(named_test),
    peer:stop(Peer).

start_node_impl(ActualTestCase) ->
    {ok, Peer, Node} = ?CT_PEER(#{name => ?CT_PEER_NAME(ActualTestCase)}),
    %% extra setup needed for multiple test cases
    ok = rpc:call(Node, application, set_env, [kernel, key, value]),
    Peer.

restart_node(Config) when is_list(Config) ->
    Name = ?CT_PEER_NAME(),
    {ok, Peer, Node} = ?CT_PEER(#{name => Name}),
    peer:stop(Peer),
    %% restart the node with the same name as before
    {ok, Peer2, Node} = ?CT_PEER(#{name => Name, args => ["+fnl"]}),
    peer:stop(Peer2).

下一個範例示範如何同時啟動多個節點

multi_node(Config) when is_list(Config) ->
    Peers = [?CT_PEER(#{wait_boot => {self(), tag}})
        || _ <- lists:seq(1, 4)],
    %% wait for all nodes to complete boot process, get their names:
    _Nodes = [receive {tag, {started, Node, Peer}} -> Node end
        || {ok, Peer} <- Peers],
    [peer:stop(Peer) || {ok, Peer} <- Peers].

在不同的主機上啟動對等節點。需要設定基於 ssh 金鑰的身份驗證，允許「another_host」連線，而無需密碼提示。

Ssh = os:find_executable("ssh"),
peer:start_link(#{exec => {Ssh, ["another_host", "erl"]},
    connection => standard_io}),

以下 Common Test 案例示範 Docker 整合，啟動兩個主機名稱為「one」和「two」的容器。在此範例中，在容器內執行的 Erlang 節點會形成一個 Erlang 叢集。

docker(Config) when is_list(Config) ->
    Docker = os:find_executable("docker"),
    PrivDir = proplists:get_value(priv_dir, Config),
    build_release(PrivDir),
    build_image(PrivDir),

    %% start two Docker containers
    {ok, Peer, Node} = peer:start_link(#{name => lambda,
        connection => standard_io,
        exec => {Docker, ["run", "-h", "one", "-i", "lambda"]}}),
    {ok, Peer2, Node2} = peer:start_link(#{name => lambda,
        connection => standard_io,
        exec => {Docker, ["run", "-h", "two", "-i", "lambda"]}}),

    %% find IP address of the second node using alternative connection RPC
    {ok, Ips} = peer:call(Peer2, inet, getifaddrs, []),
    {"eth0", Eth0} = lists:keyfind("eth0", 1, Ips),
    {addr, Ip} = lists:keyfind(addr, 1, Eth0),

    %% make first node to discover second one
    ok = peer:call(Peer, inet_db, set_lookup, [[file]]),
    ok = peer:call(Peer, inet_db, add_host, [Ip, ["two"]]),

    %% join a cluster
    true = peer:call(Peer, net_kernel, connect_node, [Node2]),
    %% verify that second peer node has only the first node visible
    [Node] = peer:call(Peer2, erlang, nodes, []),

    %% stop peers, causing containers to also stop
    peer:stop(Peer2),
    peer:stop(Peer).

build_release(Dir) ->
    %% load sasl.app file, otherwise application:get_key will fail
    application:load(sasl),
    %% create *.rel - release file
    RelFile = filename:join(Dir, "lambda.rel"),
    Release = {release, {"lambda", "1.0.0"},
        {erts, erlang:system_info(version)},
        [{App, begin {ok, Vsn} = application:get_key(App, vsn), Vsn end}
            || App <- [kernel, stdlib, sasl]]},
    ok = file:write_file(RelFile, list_to_binary(lists:flatten(
        io_lib:format("~tp.", [Release])))),
    RelFileNoExt = filename:join(Dir, "lambda"),

    %% create boot script
    {ok, systools_make, []} = systools:make_script(RelFileNoExt,
        [silent, {outdir, Dir}]),
    %% package release into *.tar.gz
    ok = systools:make_tar(RelFileNoExt, [{erts, code:root_dir()}]).

build_image(Dir) ->
    %% Create Dockerfile example, working only for Ubuntu 20.04
    %% Expose port 4445, and make Erlang distribution to listen
    %%  on this port, and connect to it without EPMD
    %% Set cookie on both nodes to be the same.
    BuildScript = filename:join(Dir, "Dockerfile"),
    Dockerfile =
      "FROM ubuntu:20.04 as runner\n"
      "EXPOSE 4445\n"
      "WORKDIR /opt/lambda\n"
      "COPY lambda.tar.gz /tmp\n"
      "RUN tar -zxvf /tmp/lambda.tar.gz -C /opt/lambda\n"
      "ENTRYPOINT [\"/opt/lambda/erts-" ++ erlang:system_info(version) ++
      "/bin/dyn_erl\", \"-boot\", \"/opt/lambda/releases/1.0.0/start\","
      " \"-kernel\", \"inet_dist_listen_min\", \"4445\","
      " \"-erl_epmd_port\", \"4445\","
      " \"-setcookie\", \"secret\"]\n",
    ok = file:write_file(BuildScript, Dockerfile),
    os:cmd("docker build -t lambda " ++ Dir).