Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
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  ex-
       ample  application. Its purpose is to use a Unix	shell script to	inter-
       act 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 node.

       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  Er-
       lang 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 as-
		  sumed	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 de-
		  pendent 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,Re-
		  sult}	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.11		   erl_call(1)


Want to link to this manual page? Use this URL:

home | help