toolbar(3erl) [linux man page]

toolbar(3erl)						     Erlang Module Definition						     toolbar(3erl)

NAME

       toolbar - GUI for Starting Tools and User Contributions

DESCRIPTION

       Toolbar makes it easier to use the different Erlang tools - and the user contributions - which are provided. It has a graphical user inter-
       face with an icon for each tool. Clicking the icon activates the corresponding tool.

       All tools to be included on Toolbar must have a configuration file containing information about the tool, for example  its  start  function
       and help information location. Configuration files must have the .tool suffix.

       When  started,  Toolbar automatically checks for *.tool files in the current path and adds the corresponding tools. For each ebin directory
       found in the path, it will also look in a priv directory next to it. This is a feature of the Erlang file structure.

EXPORTS

       start() -> ok | already_started

	      Creates a window containing tool icons.

       version() -> string()

	      Returns the current version number of Toolbar.

       update() -> ok | {error,not_started}

	      Makes a search for new tool files in the current path and adds the corresponding tools to Toolbar window.

       quit() -> ok | {error,not_started}

       create_tool_file() -> ok | {error,not_started}

	      Starts the GUI used for creating and editing tool files.

       add_gs_contribs() -> ok | {error,not_started}

	      Adds the path to the directory where the GS contributions are situated and add the tools found there, if any.

Ericsson AB							   toolbar 1.4.1						     toolbar(3erl)

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_time-
		     out, 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_time-
		     out, 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,	StartupTimeout}  | {startup_functions, StartupFunctions} | {monitor_master, Monitor} | {kill_if_fail, Kil-
		     lIfFail} | {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_time-
		     out, 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 StartupFunctions . 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 connected 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_connected, 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_connected, 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)