Provided by: erlang-manpages_24.3.4.1+dfsg-1_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 that can be reused in  other  systems.  This  module
       interacts  with  application controller, a process started at every Erlang runtime system.
       This module 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 named Application.app, where Application is the
       application name. For details about the application specification, see app(5).

       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 is to be located in an application callback module, exporting a predefined set of
       functions.

       For details about applications and behaviours, see OTP Design Principles.

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

       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  start/1,2  repeatedly on all dependencies that are not yet
              started for an application. Optional dependencies will also be loaded  and  started
              if they are available.

              Returns {ok, AppNames} for a successful start or for an already started application
              (which is, however, omitted from the AppNames list).

              The function reports {error, {AppName,Reason}} for  errors,  where  Reason  is  any
              possible reason returned by start/1,2 when starting a specific dependency.

              If  an  error occurs, the applications started by the function are stopped to bring
              the set of running applications back to its initial state.

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

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

              Types:

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

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

       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  configuration  parameter  Par  for  Application.  If  the
              application argument is omitted, it defaults to  the  application  of  the  calling
              process.

              Returns undefined if any of the following applies:

                * The specified application is not loaded.

                * The configuration parameter does not exist.

                * The process executing the call does not belong to any application.

       get_env(Application, Par, Def) -> Val

              Types:

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

              Works  like  get_env/2  but returns value Def 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.

              Returns undefined if any of the following applies:

                * The specified application is not loaded.

                * The specification key does not exist.

                * The process executing the call does not belong to any application.

       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  also  loads  the  application  specifications  for  any  included
              applications. Notice that the function does not load the Erlang object code.

              The application can be specified  by  its  name  Application.  In  this  case,  the
              application  controller  searches  the  code path for the application resource file
              Application.app and loads the specification it contains.

              The application specification can also be specified directly as  a  tuple  AppSpec,
              having the format and contents as described in app(5).

              If  Distributed == {Application,[Time,]Nodes}, the application becomes distributed.
              The argument overrides the value for the application in  the  Kernel  configuration
              parameter  distributed.  Application  must  be the application name (same as in the
              first argument).  If  a  node  crashes  and  Time  is  specified,  the  application
              controller waits for Time milliseconds before attempting to restart the application
              on another node. If Time is not specified, it defaults to 0 and the application  is
              restarted immediately.

              Nodes  is a list of node names where the application can 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  is  preferably  to  be started at cp1@cave. If
              cp1@cave is down, the application is to be started at cp2@cave or cp3@cave.

              If  Distributed  ==  default,  the  value  for  the  application  in   the   Kernel
              configuration parameter distributed is used.

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

              Types:

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

              Returns  a list with information about the applications, and included applications,
              which are loaded using load/1,2. Application is the application  name.  Description
              and Vsn are the values of their description and vsn application specification keys,
              respectively.

       set_env(Config) -> ok

       set_env(Config, Opts) -> ok

              Types:

                 Config = [{Application, Env}]
                 Application = atom()
                 Env = [{Par :: atom(), Val :: term()}]
                 Opts = [{timeout, timeout()} | {persistent, boolean()}]

              Sets the configuration Config  for  multiple  applications.  It  is  equivalent  to
              calling  set_env/4  on  each application individually, except it is more efficient.
              The given Config is validated before the configuration is set.

              set_env/2 uses the standard gen_server time-out value (5000 ms). Option timeout can
              be  specified if another time-out value is useful, for example, in situations where
              the application controller is heavily loaded.

              Option persistent can be  set  to  true  to  guarantee  that  parameters  set  with
              set_env/2  are  not overridden by those defined in the application resource file on
              load. This means that persistent values will stick after the application is  loaded
              and also on application reload.

              If  an  application  is  given more than once or if an application has the same key
              given more than once, the behaviour is undefined and  a  warning  message  will  be
              logged. In future releases, an error will be raised.

              set_env/1 is equivalent to set_env(Config, []).

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

       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 be 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
              returns ok but the application is not started until the permission is set to true.

              If  the  permission  of  a  running application is set to false, the application is
              stopped. If the permission later is set to true, it is 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).

              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 returns ok even though the application is not  started.  This
              is  true  when  an  application  cannot  start  because  of  dependencies  to other
              applications that are not yet  started.  When  they  are  started,  Application  is
              started as well.

              By  default,  all  applications  are  loaded with permission true on all nodes. The
              permission can be configured using the Kernel configuration parameter permissions.

       set_env(Application, Par, Val) -> ok

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

              Types:

                 Application = Par = atom()
                 Val = term()
                 Opts = [{timeout, timeout()} | {persistent, boolean()}]

              Sets the value of configuration parameter Par for Application.

              set_env/4 uses the standard gen_server time-out value (5000 ms). Option timeout can
              be  specified if another time-out value is useful, for example, in situations where
              the application controller is heavily loaded.

              If  set_env/4  is  called  before  the  application  is  loaded,  the   application
              environment  values  specified in file Application.app override the ones previously
              set. This is also true for application reloads.

              Option persistent can be  set  to  true  to  guarantee  that  parameters  set  with
              set_env/4  are  not overridden by those defined in the application resource file on
              load. This means that persistent values will stick after the application is  loaded
              and also on application reload.

          Warning:
              Use  this  function  only  if  you  know  what  you are doing, that is, on your own
              applications.  It  is  very  application-dependent  and  configuration   parameter-
              dependent  when and how often the value is read by the application. Careless use of
              this function can 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 = restart_type()
                 Reason = term()

              Starts  Application. If it is not loaded, the application controller first loads it
              using load/1. It ensures that any included applications are loaded,  but  does  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 needed  to  be  started  before  this
              application  are  running.  If an application is missing and the application is not
              marked as optional, {error,{not_started,App}} is returned, where App is the name of
              the  missing  application.  Note this function makes no attempt to start any of the
              applications   listed   in   applications,   not   even    optional    ones.    See
              ensure_all_started/1,2  for  recursively  starting  the current application and its
              dependencies.

              Once validated, the application controller then creates an application  master  for
              the  application.  The  application  master  becomes  the  group  leader of all the
              processes in the application. I/O  is  forwarded  to  the  previous  group  leader,
              though,  this  is  just a way to identify processes that belong to the application.
              Used for example to find itself from any process, or, reciprocally,  to  kill  them
              all when it terminates.

              The  application  master starts the application by calling the application callback
              function Module:start/2 as defined by the application specification key mod.

              Argument Type 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.

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

              Notice  that  an  application  can  always be stopped explicitly by calling stop/1.
              Regardless of the type of the application, no other applications are affected.

              Notice also that the transient type is of little  practical  use,  because  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 started, to determine the start type, which is StartType or
              local.

              For a description of StartType, see Module:start/2.

              local is returned if only parts of the application are 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  shut
              down (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  terminates.  Notice  that  all  processes  with  the
              application  master  as  group  leader,  that  is, processes spawned from a process
              belonging to the application, are also terminated.

              When stopped, the application is still loaded.

              To stop a distributed application, stop/1 must 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  stops  its  execution.  The
              application  is  not moved between nodes, as stop/1 is 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()

              Takes over 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, that is, when Module:start/2 and any  calls
              to Module:start_phase/3 have returned.

              Thus,  two  instances of the application run simultaneously during the takeover, so
              that data can be transferred from the old to the new instance. If this  is  not  an
              acceptable  behavior,  parts  of  the  old  instance  can be shut down when the new
              instance is started. However, the application cannot be stopped entirely, at  least
              the top supervisor must remain alive.

              For a description of Type, see start/1,2.

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

              Types:

                 Application = atom()
                 Reason = term()

              Unloads   the  application  specification  for  Application  from  the  application
              controller. It  also  unloads  the  application  specifications  for  any  included
              applications. Notice that the function does not purge the Erlang object code.

       unset_env(Application, Par) -> ok

       unset_env(Application, Par, Opts) -> ok

              Types:

                 Application = Par = atom()
                 Opts = [{timeout, timeout()} | {persistent, boolean()}]

              Removes the configuration parameter Par and its value for Application.

              unset_env/2  uses  the standard gen_server time-out value (5000 ms). Option timeout
              can be specified if another time-out value is useful, for  example,  in  situations
              where the application controller is heavily loaded.

              unset_env/3 also allows the persistent option to be passed (see set_env/4).

          Warning:
              Use  this  function  only  if  you  know  what  you are doing, that is, on your own
              applications.  It  is  very  application-dependent  and  configuration   parameter-
              dependent  when and how often the value is read by the application. Careless use of
              this function can 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 that are currently running.
              Application is the application name. Description and Vsn are the  values  of  their
              description and vsn application specification keys, respectively.

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

CALLBACK MODULE

       The following functions are to be exported from an application callback module.

EXPORTS

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

              Types:

                 StartType = start_type()
                 StartArgs = term()
                 Pid = pid()
                 State = term()

              This  function is called whenever an application is started using start/1,2, and is
              to 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 is a normal startup.

                * normal also if the application is distributed and started at the  current  node
                  because  of 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 because of a takeover from Node, either because 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  because  of  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  is to 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  the
              application is stopped later, 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()

              Starts  an  application  with included applications, when synchronization is needed
              between processes in the different applications during startup.

              The start phases are 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.

              For a description of StartType, see Module:start/2.

       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 is passed to Module:stop/1.

              The function is optional. If it is not defined, the processes  are  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 is to 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  the
              configuration parameters have changed.

              Changed  is a list of parameter-value tuples including all configuration parameters
              with changed values.

              New  is  a  list  of  parameter-value  tuples  including  all  added  configuration
              parameters.

              Removed is a list of all removed parameters.

SEE ALSO

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