# application

### MODULE

application

### MODULE SUMMARY

Generic OTP application functions.

### DESCRIPTION

In OTP, application is an abstract term used to define a system component consisting of resources such as modules and processes. 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 called `Application.app`, where `Application` is the name of the application. Refer to `app(4)` 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.

An application can include other applications. An application which is not included by any other application is called a primary application. An included application should be placed underneath a supervisor in the including application. This means that when running, an included application -- although conceptually a self-contained system component -- is in practice part of a primary application. A process in an included application will consider itself belonging to the primary application. Unless otherwise stated, the functions in this module are not directly applicable to included applications.

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

### Application Handling

An application controller is automatically started at every Erlang node. When starting an application, the application controller starts an application master which monitors that application.

An application is said to be local or distributed. A local application is started at any node and, if the node goes down, the application terminates. A distributed application is started at one of a specified list of nodes and, if the node goes down, the application will be restarted automatically at one of the other nodes in the list (failover). If the first node comes up again, the application will be moved back to it (takeover). See `takeover/2` below for more information about takeovers.

Local applications are controlled by the application controller. Distributed applications are controlled by the distributed application controller (`dist_ac`). The distributed application controller is not started by default; systems that use distributed applications must make sure that Kernel is configured so that `dist_ac` is started and the nodes are synchronized. Refer to `kernel(6)` for more information.

### 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`, which may be an included 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`, which may be an included 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`, which may be an included 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`, which may be an included appliction. 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(ApplDescr) -> ok | {error, Reason}`
`load(ApplDescr, Distributed) -> ok | {error, Reason}`

Types:

`ApplDescr = Application | {application,Application,AppSpec}`
`Application = atom()`
`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 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 can also be given by the tuple `{application,Application,AppSpec}`. In this case the application controller will load the data in `AppSpec` instead.

`AppSpec` should be a list of application specification key-value tuples. Invalid keys are ignored and default values are used for any omitted keys. Refer to `app(4)` for information about valid key-value tuples.

If the `Distributed` argument is present, the application will be distributed. The argument overrides the value for the application in the Kernel configuration parameter `distributed`.

In `Distributed = {Application,[Time,]Nodes}`, `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 Kernel configuration 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 specification 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, local 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 local 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 it is configured.

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`

Types:

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

Sets the value of the configuration parameter `Par` for `Application`, which may be an included application.

| 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 wierd, 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 similar to 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 `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 | local`

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 supervisor), or if the function is called outside a startup.

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

Types:

`Application = atom()`
`Reason = term()`

Test of d-tag

Stops `Application`. All processes in the application tree are terminated, including included applications, and also all processes with the same group leader as the application. The application will still be 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 = 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 controller. It will also unload the application specifications for any included applications. Note that the function does not purge the actual Erlang object code.

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

Types:

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

### CALLBACK MODULE

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

### EXPORTS

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

`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 its 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 provided in the application specification for the 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 called during startup of an application for each phase defined for the application specification key `start_phases = [{Phase,PhaseArgs}]`.

If it is desired that all or a subset of the start phases are called for any included applications as well, use `application_starter` and define the application specification key `mod` as:

    {mod, {application_starter, [Module, StartArgs]}}

Note that `application_starter` is not recursive, but has to be used for every application with included applications, if there are several levels of included applications.

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

### SEE ALSO

kernel(6), app(4)

### AUTHORS

Martin Björklund - support@erlang.ericsson.se
Esko Vierumäki - support@erlang.ericsson.se
Gunilla Hugosson - support@erlang.ericsson.se

kernel 2.7.2
Copyright © 1991-2002 Ericsson Utvecklings AB