-spec pseudo([Master :: node() | (ServerList :: [atom()])]) -> ok.

Calls pseudo(Master, ServerList). If you want to start a node from the command line and set up a number of pseudo servers, an Erlang runtime system can be started as follows:

% erl -name abc -s slave pseudo klacke@super x --

-spec pseudo(Master, ServerList) -> ok when Master :: node(), ServerList :: [atom()].

Starts a number of pseudo servers. A pseudo server is a server with a registered name that does nothing but pass on all message to the real server that executes at a master node. A pseudo server is an intermediary that only has the same registered name as the real server.

For example, if you have started a slave node N and want to execute pxw graphics code on this node, you can start server pxw_server as a pseudo server at the slave node. This is illustrated as follows:

rpc:call(N, slave, pseudo, [node(), [pxw_server]]).

-spec relay(Pid) -> no_return() when Pid :: pid().

Runs a pseudo server. This function never returns any value and the process that executes the function receives messages. All messages received are simply passed on to Pid.

-spec start(Host) -> {ok, Node} | {error, Reason}
         when
             Host :: inet:hostname(),
             Node :: node(),
             Reason :: timeout | no_rsh | {already_running, Node}.

Equivalent to start(Host, Name) where Name is the same as the node that executes this call.

-spec start(Host, Name) -> {ok, Node} | {error, Reason}
         when
             Host :: inet:hostname(),
             Name :: atom() | string(),
             Node :: node(),
             Reason :: timeout | no_rsh | {already_running, Node}.

Equivalent to start(Host, Name, [])

-spec start(Host, Name, Args) -> {ok, Node} | {error, Reason}
         when
             Host :: inet:hostname(),
             Name :: atom() | string(),
             Args :: string(),
             Node :: node(),
             Reason :: timeout | no_rsh | {already_running, Node}.

Starts a slave node on host Host. Host names need not necessarily be specified as fully qualified names; short names can also be used. This is the same condition that applies to names of distributed Erlang nodes.

The name of the started node becomes Name@Host.

The slave node resets its io:user/0 process so that all terminal I/O that is produced at the slave is automatically relayed to the master. Also, the file server is relayed to the master.

Argument Args is used to set erl command-line arguments. It is passed to the new node and can be used for a variety of purposes; see erl(1).

As an example, suppose that you want to start a slave node at host H with node name Name@H and want the slave node to have the following properties:

• Directory Dir is to be added to the code path.
• The Mnesia directory is to be set to M.
• The Unix DISPLAY environment variable is to be set to the display of the master node.

The following code is executed to achieve this:

E = " -env DISPLAY " ++ net_adm:localhost() ++ ":0 ",
Arg = "-mnesia_dir " ++ M ++ " -pa " ++ Dir ++ E,
slave:start(H, Name, Arg).

The function returns {ok, Node}, where Node is the name of the new node, otherwise {error, Reason}, where Reason can be one of:

• timeout - The master node failed to get in contact with the slave node. This can occur in a number of circumstances:

  • Erlang/OTP is not installed on the remote host.
  • The file system on the other host has a different structure to the the master.
  • The Erlang nodes have different cookies.

• no_rsh - No remote shell program was found on the computer. Note that ssh is used by default, but this can be overridden with the -rsh flag.

• {already_running, Node} - A node with name Name@Host already exists.

-spec start_link(Host) -> {ok, Node} | {error, Reason}
              when
                  Host :: inet:hostname(),
                  Node :: node(),
                  Reason :: timeout | no_rsh | {already_running, Node}.

Equivalent to start_link/3

-spec start_link(Host, Name) -> {ok, Node} | {error, Reason}
              when
                  Host :: inet:hostname(),
                  Name :: atom() | string(),
                  Node :: node(),
                  Reason :: timeout | no_rsh | {already_running, Node}.

Equivalent to start_link/3

-spec start_link(Host, Name, Args) -> {ok, Node} | {error, Reason}
              when
                  Host :: inet:hostname(),
                  Name :: atom() | string(),
                  Args :: string(),
                  Node :: node(),
                  Reason :: timeout | no_rsh | {already_running, Node}.

Starts a slave node in the same way as start/1,2,3, except that the slave node is linked to the currently executing process. If that process terminates, the slave node also terminates.

For a description of arguments and return values, see start/1,2,3.

-spec stop(Node) -> ok when Node :: node().

Stops (kills) a node.