Provided by: erlang-manpages_16.b.3-dfsg-1ubuntu2_all bug

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
       example 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
       specification.

       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.

DATA TYPES

       start_type() = normal
                    | {takeover, Node :: node()}
                    | {failover, Node :: node()}

       restart_type() = permanent | transient | temporary

       tuple_of(T)

              A tuple where the elements are of type T.

EXPORTS

       get_all_env() -> Env

       get_all_env(Application) -> Env

              Types:

                 Application = atom()
                 Env = [{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) -> undefined | Keys

              Types:

                 Application = atom()
                 Keys = {ok, [{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() -> undefined | {ok, Application}

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

              Types:

                 PidOrModule = (Pid :: pid()) | (Module :: module())
                 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) -> undefined | {ok, Val}

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

              Types:

                 Application = 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_env(Application, Par, Def) -> Val

              Types:

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

              Works  like  get_env/2  but returns Def value when configuration parameter Par does
              not exist.

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

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

              Types:

                 Application = 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_spec())
                 Application = atom()
                 Distributed = {Application, Nodes}
                             | {Application, Time, Nodes}
                             | default
                 Nodes = [node() | tuple_of(node())]
                 Time = integer() >= 1
                 Reason = term()
                 application_spec() =
                     {application,
                      Application :: atom(),
                      AppSpecKeys :: [application_opt()]}
                 application_opt() = {description, Description :: string()}
                                   | {vsn, Vsn :: string()}
                                   | {id, Id :: string()}
                                   | {modules, [Module :: module()]}
                                   | {registered, Names :: [Name :: atom()]}
                                   | {applications, [Application :: atom()]}
                                   | {included_applications,
                                      [Application :: atom()]}
                                   | {env, [{Par :: atom(), Val :: term()}]}
                                   | {start_phases,
                                      [{Phase :: atom(), PhaseArgs :: term()}] |
                                      undefined}
                                   | {maxT, MaxT :: timeout()}
                                   | {maxP, MaxP :: integer() >= 1 | infinity}
                                   | {mod,
                                      Start ::
                                          {Module :: module(),
                                           StartArgs :: term()}}

              Loads the  application  specification  for  an  application  into  the  application
              controller.  It  will  also  load  the  application specifications for any included
              applications. 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
              Application.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
              application 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
              configuration parameter distributed will be used.

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

              Types:

                 Application = atom()
                 Description = 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
              specification keys, respectively.

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

              Types:

                 Application = atom()
                 Permission = boolean()
                 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
              distribution is configured (see load/2 above).

              The function  does  not  return  until  the  application  is  started,  stopped  or
              successfully  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,
              Application will be started as well.

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

       set_env(Application, Par, Val) -> ok

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

              Types:

                 Application = Par = atom()
                 Val = term()
                 Timeout = timeout()

              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.

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

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

              Types:

                 Application = atom()
                 Type = restart_type()
                 Reason = term()

              Equivalent  to  application:start/1,2  except  it  returns  ok  for already started
              applications.

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

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

              Types:

                 Application = atom()
                 Type = restart_type()
                 Started = [atom()]
                 Reason = term()

              Equivalent to calling application:start/1,2 repeatedly  on  all  dependencies  that
              have  not  yet been started for an application. The function returns {ok, AppNames}
              for a successful start or for an already started  application  (which  are  however
              omitted  from the AppNames list), and reports {error, {AppName,Reason}} for errors,
              where Reason is any possible reason returned by application:start/1,2 when starting
              a  specific  dependency. In case of an error, the applications that were started by
              the function are stopped to bring the set  of  running  applications  back  to  its
              initial state.

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

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

              Types:

                 Application = atom()
                 Type = restart_type()
                 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 Application.

              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
                  terminated.

                * If  a  temporary  application  terminates,  this  is  reported  but  no   other
                  applications 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
              supervision tree terminates, the reason is set to shutdown, not normal.

       start_type() -> StartType | undefined | local

              Types:

                 StartType = start_type()

              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
              supervisor), 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
              shutdown (see supervisor(3erl)). This  means  that  the  entire  supervision  tree,
              including  included  applications, is terminated in reversed start order. After the
              shutdown, 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
              execution. 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 = restart_type()
                 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
              controller. It will also unload the application  specifications  for  any  included
              applications. 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 = Par = atom()
                 Timeout = timeout()

              Removes the configuration parameter Par and its value for Application.

              unset_env/2  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.

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

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

              Types:

                 Timeout = timeout()
                 Application = atom()
                 Description = Vsn = string()

              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
              Timeout  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
              application:start/1,2,  and  should  start the processes of the application. If the
              application 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 = start_type()
                 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
              application)  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.
              Otherwise 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)