👤
Home Man
Search
Today's Posts
Register

Linux & Unix Commands - Search Man Pages
Man Page or Keyword Search:
Select Section of Man Page:
Select Man Page Repository:

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

application(3erl)		     Erlang Module Definition			application(3erl)

NAME
       application - Generic OTP application functions

DESCRIPTION
       In OTP, application denotes a component implementing some specific functionality, that can
       be started and stopped as a unit, and which can be re-used in other systems as well.  This
       module  interfaces  the application controller , a process started at every Erlang runtime
       system, and contains functions for controlling  applications  (for  example  starting  and
       stopping  applications), and functions to access information about applications (for exam-
       ple configuration parameters).

       An application is defined by an application specification . The specification is  normally
       located	in an application resource file called Application.app , where Application is the
       name of the application. Refer to app(5) for more information about the application speci-
       fication.

       This  module can also be viewed as a behaviour for an application implemented according to
       the OTP design principles as a supervision tree. The definition of how to start	and  stop
       the  tree  should be located in an application callback module exporting a pre-defined set
       of functions.

       Refer to OTP Design Principles for more information about applications and behaviours.

EXPORTS
       get_all_env() -> Env
       get_all_env(Application) -> Env

	      Types  Application = atom()
		     Env = [{Par,Val}]
		     Par = atom()
		     Val = term()

	      Returns the configuration parameters and their values  for  Application  .  If  the
	      argument is omitted, it defaults to the application of the calling process.

	      If  the  specified  application is not loaded, or if the process executing the call
	      does not belong to any application, the function returns [] .

       get_all_key() -> {ok, Keys} | []
       get_all_key(Application) -> {ok, Keys} | undefined

	      Types  Application = atom()
		     Keys = [{Key,Val}]
		     Key = atom()
		     Val = term()

	      Returns the application specification keys and their values for  Application  .  If
	      the argument is omitted, it defaults to the application of the calling process.

	      If the specified application is not loaded, the function returns undefined . If the
	      process executing the call does not belong to any application, the function returns
	      [] .

       get_application() -> {ok, Application} | undefined
       get_application(Pid | Module) -> {ok, Application} | undefined

	      Types  Pid = pid()
		     Module = atom()
		     Application = atom()

	      Returns  the  name of the application to which the process Pid or the module Module
	      belongs. Providing no argument is the same as calling get_application(self()) .

	      If the specified process does not belong to any application, or  if  the	specified
	      process or module does not exist, the function returns undefined .

       get_env(Par) -> {ok, Val} | undefined
       get_env(Application, Par) -> {ok, Val} | undefined

	      Types  Application = atom()
		     Par = atom()
		     Val = term()

	      Returns  the  value  of  the  configuration  parameter Par for Application . If the
	      application argument is omitted, it defaults to  the  application  of  the  calling
	      process.

	      If the specified application is not loaded, or the configuration parameter does not
	      exist, or if the process executing the call does not belong to any application, the
	      function returns undefined .

       get_key(Key) -> {ok, Val} | undefined
       get_key(Application, Key) -> {ok, Val} | undefined

	      Types  Application = atom()
		     Key = atom()
		     Val = term()

	      Returns the value of the application specification key Key for Application . If the
	      application argument is omitted, it defaults to  the  application  of  the  calling
	      process.

	      If  the  specified  application  is  not	loaded, or the specification key does not
	      exist, or if the process executing the call does not belong to any application, the
	      function returns undefined .

       load(AppDescr) -> ok | {error, Reason}
       load(AppDescr, Distributed) -> ok | {error, Reason}

	      Types  AppDescr = Application | AppSpec
		     Application = atom()
		     AppSpec = {application,Application,AppSpecKeys}
		     AppSpec = [{Key,Val}]
		     Key = atom()
		     Val = term()
		     Distributed = {Application,Nodes} | {Application,Time,Nodes} | default
		     Nodes = [node() | {node(),..,node()}]
		     Time = integer() > 0
		     Reason = term()

	      Loads  the  application  specification for an application into the application con-
	      troller. It will also load the application specifications for any included applica-
	      tions. Note that the function does not load the actual Erlang object code.

	      The application can be given by its name Application . In this case the application
	      controller will search the code path for the  application  resource  file  Applica-
	      tion.app and load the specification it contains.

	      The  application specification can also be given directly as a tuple AppSpec . This
	      tuple should have the format and contents as described in app(5) .

	      If Distributed == {Application,[Time,]Nodes} , the application will be distributed.
	      The  argument  overrides	the value for the application in the Kernel configuration
	      parameter distributed . Application must be the name of the application (same as in
	      the first argument). If a node crashes and Time has been specified, then the appli-
	      cation controller will wait for Time milliseconds before attempting to restart  the
	      application on another node. If Time is not specified, it will default to 0 and the
	      application will be restarted immediately.

	      Nodes is a list of node names where the application may run, in priority from  left
	      to  right.  Node	names  can be grouped using tuples to indicate that they have the
	      same priority. Example:

	      Nodes = [cp1@cave, {cp2@cave, cp3@cave}]

	      This means that the application should preferably  be  started  at  cp1@cave  .  If
	      cp1@cave	is down, the application should be started at either cp2@cave or cp3@cave
	      .

	      If Distributed == default , the value for the application in the Kernel  configura-
	      tion parameter distributed will be used.

       loaded_applications() -> [{Application, Description, Vsn}]

	      Types  Application = atom()
		     Description = string()
		     Vsn = string()

	      Returns a list with information about the applications which have been loaded using
	      load/1,2 ,  also	included  applications.  Application  is  the  application  name.
	      Description  and Vsn are the values of its description and vsn application specifi-
	      cation keys, respectively.

       permit(Application, Bool) -> ok | {error, Reason}

	      Types  Application = atom()
		     Bool = bool()
		     Reason = term()

	      Changes the permission for Application to run at the current node. The  application
	      must have been loaded using load/1,2 for the function to have effect.

	      If the permission of a loaded, but not started, application is set to false , start
	      will return ok but the application will not be started until the permission is  set
	      to true .

	      If  the  permission of a running application is set to false , the application will
	      be stopped. If the permission later is set to true , it will be restarted.

	      If the application is distributed, setting the permission to false means	that  the
	      application will be started at, or moved to, another node according to how its dis-
	      tribution is configured (see load/2 above).

	      The function does not return until the application is started, stopped or  success-
	      fully moved to another node. However, in some cases where permission is set to true
	      the function may return ok even though the application itself has not started. This
	      is  true	when  an  application  cannot  start because it has dependencies to other
	      applications which have not yet been started. When they have been started, Applica-
	      tion will be started as well.

	      By default, all applications are loaded with permission true on all nodes. The per-
	      mission is configurable by using the Kernel configuration parameter permissions .

       set_env(Application, Par, Val) -> ok
       set_env(Application, Par, Val, Timeout) -> ok

	      Types  Application = atom()
		     Par = atom()
		     Val = term()
		     Timeout = int() | infinity

	      Sets the value of the configuration parameter Par for Application .

	      set_env/3 uses the standard gen_server timeout value (5000 ms). A Timeout  argument
	      can  be  provided  if  another  timeout value is useful, for example, in situations
	      where the application controller is heavily loaded.

   Warning:
       Use this function only if you know what you are doing, that is, on your own  applications.
       It  is very application and configuration parameter dependent when and how often the value
       is read by the application, and careless use of this function may put the application in a
       weird, inconsistent, and malfunctioning state.

       start(Application) -> ok | {error, Reason}
       start(Application, Type) -> ok | {error, Reason}

	      Types  Application = atom()
		     Type = permanent | transient | temporary
		     Reason = term()

	      Starts  Application  .  If  it is not loaded, the application controller will first
	      load it using load/1 . It will make sure any included applications are loaded,  but
	      will  not  start them. That is assumed to be taken care of in the code for Applica-
	      tion .

	      The application controller checks the value of the  application  specification  key
	      applications  ,  to ensure that all applications that should be started before this
	      application are running. If not, {error,{not_started,App}} is returned,  where  App
	      is the name of the missing application.

	      The  application controller then creates an application master for the application.
	      The application master is the group leader of all the processes in the application.
	      The  application	master starts the application by calling the application callback
	      function Module:start/2 as defined by the application specification key mod .

	      The Type argument specifies the type of the application. If omitted, it defaults to
	      temporary .

		* If  a  permanent  application terminates, all other applications and the entire
		  Erlang node are also terminated.

		* If a transient application terminates with Reason == normal , this is  reported
		  but no other applications are terminated. If a transient application terminates
		  abnormally, all other applications and the entire Erlang node are  also  termi-
		  nated.

		* If  a  temporary application terminates, this is reported but no other applica-
		  tions are terminated.

	      Note that it is always possible to stop an application explicitly by calling stop/1
	      .  Regardless  of  the  type  of	the  application,  no  other applications will be
	      affected.

	      Note also that the transient type is of little practical use, since when a supervi-
	      sion tree terminates, the reason is set to shutdown , not normal .

       start_type() -> StartType | local | undefined

	      Types  StartType = normal | {takeover,Node} | {failover,Node}
		     Node = node()

	      This  function  is  intended to be called by a process belonging to an application,
	      when the application is being started, to determine the start type which is  either
	      StartType or local .

	      See Module:start/2 for a description of StartType .

	      local  is returned if only parts of the application is being restarted (by a super-
	      visor), or if the function is called outside a startup.

	      If the process executing the call does not belong to any application, the  function
	      returns undefined .

       stop(Application) -> ok | {error, Reason}

	      Types  Application = atom()
		     Reason = term()

	      Stops  Application  .  The  application master calls Module:prep_stop/1 , if such a
	      function is defined, and then tells the top supervisor of the application to  shut-
	      down  (see supervisor(3erl) ). This means that the entire supervision tree, includ-
	      ing included applications, is terminated in reversed start order. After  the  shut-
	      down, the application master calls Module:stop/1 . Module is the callback module as
	      defined by the application specification key mod .

	      Last, the application master itself terminates. Note that all  processes	with  the
	      application master as group leader, i.e. processes spawned from a process belonging
	      to the application, thus are terminated as well.

	      When stopped, the application is still loaded.

	      In order to stop a distributed application, stop/1 has to be called  on  all  nodes
	      where it can execute (that is, on all nodes where it has been started). The call to
	      stop/1 on the node where the application currently executes will	stop  its  execu-
	      tion. The application will not be moved between nodes due to stop/1 being called on
	      the node where the application currently executes before stop/1 is  called  on  the
	      other nodes.

       takeover(Application, Type) -> ok | {error, Reason}

	      Types  Application = atom()
		     Type = permanent | transient | temporary
		     Reason = term()

	      Performs	a takeover of the distributed application Application , which executes at
	      another node Node . At the current node, the application is  restarted  by  calling
	      Module:start({takeover,Node},StartArgs)  .  Module and StartArgs are retrieved from
	      the loaded application specification. The application at	the  other  node  is  not
	      stopped  until  the startup is completed, i.e. when Module:start/2 and any calls to
	      Module:start_phase/3 have returned.

	      Thus two instances of the application will run simultaneously during the	takeover,
	      which  makes it possible to transfer data from the old to the new instance. If this
	      is not acceptable behavior, parts of the old instance may be shut down when the new
	      instance is started. Note that the application may not be stopped entirely however,
	      at least the top supervisor must remain alive.

	      See start/1,2 for a description of Type .

       unload(Application) -> ok | {error, Reason}

	      Types  Application = atom()
		     Reason = term()

	      Unloads the application specification for Application  from  the	application  con-
	      troller. It will also unload the application specifications for any included appli-
	      cations. Note that the function does not purge the actual Erlang object code.

       unset_env(Application, Par) -> ok
       unset_env(Application, Par, Timeout) -> ok

	      Types  Application = atom()
		     Par = atom()
		     Timeout = int() | infinity

	      Removes the configuration parameter Par and its value for Application .

	      unset_env/2 uses the standard gen_server timeout value (5000 ms). A  Timeout  argu-
	      ment can be provided if another timeout value is useful, for example, in situations
	      where the application controller is heavily loaded.

   Warning:
       Use this function only if you know what you are doing, that is, on your own  applications.
       It  is very application and configuration parameter dependent when and how often the value
       is read by the application, and careless use of this function may put the application in a
       weird, inconsistent, and malfunctioning state.

       which_applications() -> [{Application, Description, Vsn}]
       which_applications(Timeout) -> [{Application, Description, Vsn}]

	      Types  Application = atom()
		     Description = string()
		     Vsn = string()
		     Timeout = int() | infinity

	      Returns a list with information about the applications which are currently running.
	      Application is the application name. Description and Vsn	are  the  values  of  its
	      description and vsn application specification keys, respectively.

	      which_applications/0  uses the standard gen_server timeout value (5000 ms). A Time-
	      out argument can be provided if another timeout value is useful,	for  example,  in
	      situations where the application controller is heavily loaded.

CALLBACK MODULE
       The following functions should be exported from an application callback module.

EXPORTS
       Module:start(StartType, StartArgs) -> {ok, Pid} | {ok, Pid, State} | {error, Reason}

	      Types  StartType = normal | {takeover,Node} | {failover,Node}
		     Node = node()
		     StartArgs = term()
		     Pid = pid()
		     State = term()

	      This  function  is  called  whenever  an	application  is  started  using  applica-
	      tion:start/1,2 , and should start the processes of the application. If the applica-
	      tion  is	structured  according to the OTP design principles as a supervision tree,
	      this means starting the top supervisor of the tree.

	      StartType defines the type of start:

		* normal if it's a normal startup.

		* normal also if the application is distributed and started at the  current  node
		  due  to  a  failover	from  another node, and the application specification key
		  start_phases == undefined .

		* {takeover,Node} if the application is distributed and started  at  the  current
		  node	due  to  a takeover from Node , either because application:takeover/2 has
		  been called or because the current node has higher priority than Node .

		* {failover,Node} if the application is distributed and started  at  the  current
		  node	due  to  a  failover  from  Node  , and the application specification key
		  start_phases /= undefined .

	      StartArgs is the StartArgs argument defined by the  application  specification  key
	      mod .

	      The  function  should return {ok,Pid} or {ok,Pid,State} where Pid is the pid of the
	      top supervisor and State is any term. If omitted, State defaults to [] .	If  later
	      the application is stopped, State is passed to Module:prep_stop/1 .

       Module:start_phase(Phase, StartType, PhaseArgs) -> ok | {error, Reason}

	      Types  Phase = atom()
		     StartType = normal | {takeover,Node} | {failover,Node}
		     Node = node()
		     PhaseArgs = term()
		     Pid = pid()
		     State = state()

	      This  function  is  used	to  start an application with included applications, when
	      there is a need for synchronization between processes in the different applications
	      during startup.

	      The  start  phases  is defined by the application specification key start_phases ==
	      [{Phase,PhaseArgs}] . For included applications, the set of phases must be a subset
	      of the set of phases defined for the including application.

	      The  function  is  called for each start phase (as defined for the primary applica-
	      tion) for the primary application and all  included  applications,  for  which  the
	      start phase is defined.

	      See Module:start/2 for a description of StartType .

       Module:prep_stop(State) -> NewState

	      Types  State = NewState = term()

	      This function is called when an application is about to be stopped, before shutting
	      down the processes of the application.

	      State is the state returned from Module:start/2 , or [] if no state  was	returned.
	      NewState is any term and will be passed to Module:stop/1 .

	      The  function  is  optional. If it is not defined, the processes will be terminated
	      and then Module:stop(State) is called.

       Module:stop(State)

	      Types  State = term()

	      This function is called whenever an application has stopped. It is intended  to  be
	      the  opposite of Module:start/2 and should do any necessary cleaning up. The return
	      value is ignored.

	      State is the return value of Module:prep_stop/1 , if such a function exists. Other-
	      wise State is taken from the return value of Module:start/2 .

       Module:config_change(Changed, New, Removed) -> ok

	      Types  Changed = [{Par,Val}]
		     New = [{Par,Val}]
		     Removed = [Par]
		     Par = atom()
		     Val = term()

	      This  function  is  called by an application after a code replacement, if there are
	      any changes to the configuration parameters.

	      Changed is a list of parameter-value tuples with all configuration parameters  with
	      changed  values,	New  is  a  list of parameter-value tuples with all configuration
	      parameters that have been added, and Removed is a list of all parameters that  have
	      been removed.

SEE ALSO
       OTP Design Principles , kernel(7) , app(5)

Ericsson AB				  kernel 2.14.3 			application(3erl)


All times are GMT -4. The time now is 05:57 AM.

Unix & Linux Forums Content Copyrightę1993-2018. All Rights Reserved.
×
UNIX.COM Login
Username:
Password:  
Show Password