application - Generic OTP application functions

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

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

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 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(4).

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 = 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, 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

Types

Application = atom()

Par = atom()

Val = term()

Sets the value of the configuration parameter Par for Application.

Warning:

Warning:

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

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 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 appliction) 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.

OTP Design Principles, kernel(6), app(4)

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