Go to main content

man pages section 1: User Commands

Exit Print View

Updated: Wednesday, February 10, 2021

erl_call (1)


erl_call - Call/start a distributed Erlang node.


Please see following description for synopsis


erl_call(1)                      User Commands                     erl_call(1)

       erl_call - Call/start a distributed Erlang node.

       erl_call  makes it possible to start and/or communicate with a distrib-
       uted Erlang node. It is built upon  the  Erl_Interface  library  as  an
       example  application.  Its  purpose  is  to  use a Unix shell script to
       interact with a distributed Erlang node. It performs all  communication
       with  the Erlang rex server, using the standard Erlang RPC facility. It
       does not require any special software to be run at  the  Erlang  target

       The main use is to either start a distributed Erlang node or to make an
       ordinary function call. However, it is also possible to pipe an  Erlang
       module  to  erl_call  and  have  it  compiled, or to pipe a sequence of
       Erlang expressions to be evaluated (similar to the Erlang shell).

       Options, which cause stdin to be read, can be used with  advantage,  as
       scripts  from within (Unix) shell scripts. Another nice use of erl_call
       could be from (HTTP) CGI-bin scripts.

       erl_call <options>

              Starts/calls Erlang.

              Each option flag is described below with  its  name,  type,  and

                -a [Mod [Fun [Args]]]]:
                  (Optional.)  Applies  the specified function and returns the
                  result. Mod must be specified. However,  start  and  []  are
                  assumed  for unspecified Fun and Args, respectively. Args is
                  to be in the same format as for erlang:apply/3 in ERTS.

                  Notice that this flag takes exactly one argument, so quoting
                  can  be  necessary  to  group Mod, Fun, and Args in a manner
                  dependent on the behavior of your command shell.

                -c Cookie:
                  (Optional.) Use this option to specify a certain cookie.  If
                  no  cookie  is  specified, the ~/.erlang.cookie file is read
                  and its content is used as cookie. The Erlang node  we  want
                  to communicate with must have the same cookie.

                  (Optional.)  Debug mode. This causes all I/O to be output to
                  the ~/.erl_call.out.Nodename file,  where  Nodename  is  the
                  node name of the Erlang node in question.

                  (Optional.)  Reads  a  sequence of Erlang expressions, sepa-
                  rated by comma (,) and ended with  a  full  stop  (.),  from
                  stdin  until  EOF (Control-D). Evaluates the expressions and
                  returns  the  result  from  the  last  expression.   Returns
                  {ok,Result} on success.

                -h HiddenName:
                  (Optional.)  Specifies  the  name  of  the  hidden node that
                  erl_call represents.

                  (Optional.) Reads an Erlang module from stdin  and  compiles

                -n Node:
                  (One of -n, -name, -sname is required.) Has the same meaning
                  as -name and can still be used  for  backward  compatibility

                -name Node:
                  (One  of -n, -name, -sname is required.) Node is the name of
                  the node to be started or communicated with. It  is  assumed
                  that  Node is started with erl -name, which means that fully
                  qualified long node names are used. If option -s  is  speci-
                  fied, an Erlang node will (if necessary) be started with erl

                  (Optional.) Halts the Erlang node specified with switch  -n.
                  This switch overrides switch -s.

                  (Optional.)  Generates a random name of the hidden node that
                  erl_call represents.

                  (Optional.) Starts a distributed Erlang node  if  necessary.
                  This  means  that in a sequence of calls, where '-s' and '-n
                  Node' are constant, only the first call  starts  the  Erlang
                  node.  This  makes  the rest of the communication very fast.
                  This flag is currently only available on Unix-like platforms
                  (Linux, Mac OS X, Solaris, and so on).

                -sname Node:
                  (One  of -n, -name, -sname is required.) Node is the name of
                  the node to be started or communicated with. It  is  assumed
                  that Node is started with erl -sname, which means that short
                  node names are used. If option -s is  specified,  an  Erlang
                  node is started (if necessary) with erl -sname.

                  (Optional.)  Prints  a  lot  of verbose information. This is
                  only useful for the developer and maintainer of erl_call.

                -x ErlScript:
                  (Optional.) Specifies another name  of  the  Erlang  startup
                  script  to  be  used.  If  not  specified,  the standard erl
                  startup script is used.

       To start an Erlang node and call erlang:time/0:

       erl_call -s -a 'erlang time' -n madonna

       To terminate an Erlang node by calling erlang:halt/0:

       erl_call -s -a 'erlang halt' -n madonna

       To apply with many arguments:

       erl_call -s -a 'lists seq [1,10]' -n madonna

       To evaluate some expressions (the input ends with EOF (Control-D)):

       erl_call -s -e -n madonna

       To compile a module and run it (again, the input ends  with  EOF  (Con-

       (In the example, the output has been formatted afterwards.)

       erl_call -s -m -a procnames -n madonna
       start() ->
               P = processes(),
               F = fun(X) -> {X,process_info(X,registered_name)} end,

Ericsson AB                   erl_interface 3.9.3                  erl_call(1)