Unix/Linux Go Back    


Linux 2.6 - man page for ct_slave (linux section 3erl)

Linux & Unix Commands - Search Man Pages
Man Page or Keyword Search:   man
Select Man Page Set:       apropos Keyword Search (sections above)


ct_slave(3erl)			     Erlang Module Definition			   ct_slave(3erl)

NAME
       ct_slave - Common Test Framework functions for starting and stopping nodes for Large Scale
       Testing.

DESCRIPTION
       Common Test Framework functions for starting and stopping nodes for Large Scale Testing.

       This module exports functions which are used by the Common Test Master to start	and  stop
       "slave"	nodes.	It  is the default callback module for the {init, node_start} term of the
       Test Specification.

EXPORTS
       start(Node) -> Result

	      Types  Node = atom()
		     Result = {ok, NodeName}  |  {error,  already_started,  NodeName}  |  {error,
		     started_not_connected, NodeName} | {error, boot_timeout, NodeName} | {error,
		     init_timeout, NodeName}  |  {error,  startup_timeout,  NodeName}  |  {error,
		     not_alive, NodeName}
		     NodeName = atom()

	      Starts an Erlang node with name Node on the local host.

	      See also: start/3 .

       start(Host, Node) -> Result

	      Types  Node = atom()
		     Host = atom()
		     Result  =	{ok,  NodeName}  |  {error,  already_started, NodeName} | {error,
		     started_not_connected, NodeName} | {error, boot_timeout, NodeName} | {error,
		     init_timeout,  NodeName}  |  {error,  startup_timeout,  NodeName}	| {error,
		     not_alive, NodeName}
		     NodeName = atom()

	      Starts an Erlang node with name Node on host Host with the default options.

	      See also: start/3 .

       start(Host, Node, Options::Opts) -> Result

	      Types  Node = atom()
		     Host = atom()
		     Opts = [OptTuples]
		     OptTuples = {username, Username} |  {password,  Password}	|  {boot_timeout,
		     BootTimeout}  | {init_timeout, InitTimeout} | {startup_timeout, StartupTime-
		     out} | {startup_functions, StartupFunctions} | {monitor_master,  Monitor}	|
		     {kill_if_fail, KillIfFail} | {erl_flags, ErlangFlags}
		     Username = string()
		     Password = string()
		     BootTimeout = integer()
		     InitTimeout = integer()
		     StartupTimeout = integer()
		     StartupFunctions = [StartupFunctionSpec]
		     StartupFunctionSpec = {Module, Function, Arguments}
		     Module = atom()
		     Function = atom()
		     Arguments = [term]
		     Monitor = bool()
		     KillIfFail = bool()
		     ErlangFlags = string()
		     Result  =	{ok,  NodeName}  |  {error,  already_started, NodeName} | {error,
		     started_not_connected, NodeName} | {error, boot_timeout, NodeName} | {error,
		     init_timeout,  NodeName}  |  {error,  startup_timeout,  NodeName}	| {error,
		     not_alive, NodeName}
		     NodeName = atom()

	      Starts an Erlang node with name Node on host Host as specified by  the  combination
	      of options in Opts .

	      Options  Username  and  Password will be used to log in onto the remote host Host .
	      Username, if omitted, defaults to the current user name, and password is	empty  by
	      default.

	      A  list of functions specified in the Startup option will be executed after startup
	      of the node. Note that all used modules should be present in the code path  on  the
	      Host .

	      The timeouts are applied as follows:

		* BootTimeout - time to start the Erlang node, in seconds. Defaults to 3 seconds.
		  If node  does  not  become  pingable	within	this  time,  the  result  {error,
		  boot_timeout, NodeName} is returned;

		* InitTimeout  -  time	to wait for the node until it calls the internal callback
		  function informing master about successfull startup. Defaults to one second. In
		  case	of  timed  out	message  the  result  {error,  init_timeout, NodeName} is
		  returned;

		* StartupTimeout - time to wait intil the node finishes to run	the  StartupFunc-
		  tions  .  Defaults  to  one  second. If this timeout occurs, the result {error,
		  startup_timeout, NodeName} is returned.

	      Option monitor_master specifies, if the slave node should be  stopped  in  case  of
	      master node stop. Defaults to false.

	      Option  kill_if_fail  specifies,	if  the  slave node should be killed in case of a
	      timeout during initialization or startup. Defaults to true. Note that node also may
	      be  still  alive	it  the  boot timeout occurred, but it will not be killed in this
	      case.

	      Option erlang_flags specifies, which flags will be added to the parameters  of  the
	      erl executable.

	      Special return values are:

		* {error, already_started, NodeName} - if the node with the given name is already
		  started on a given host;

		* {error, started_not_connected, NodeName} - if node is  started,  but	not  con-
		  nected to the master node.

		* {error, not_alive, NodeName} - if node on which the ct_slave:start/3 is called,
		  is not alive. Note that NodeName is the name of current node in this case.

       stop(Node) -> Result

	      Types  Node = atom()
		     Result = {ok, NodeName} | {error, not_started, NodeName} | {error,  not_con-
		     nected, NodeName} | {error, stop_timeout, NodeName}
		     NodeName = atom()

	      Stops the running Erlang node with name Node on the localhost.

       stop(Host, Node) -> Result

	      Types  Host = atom()
		     Node = atom()
		     Result  = {ok, NodeName} | {error, not_started, NodeName} | {error, not_con-
		     nected, NodeName} | {error, stop_timeout, NodeName}
		     NodeName = atom()

	      Stops the running Erlang node with name Node on host Host .

AUTHORS
       <>

					common_test 1.5.3			   ct_slave(3erl)
Unix & Linux Commands & Man Pages : ©2000 - 2018 Unix and Linux Forums


All times are GMT -4. The time now is 08:58 PM.