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.
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
.
Functions
get_all_env() -> Env
Env = [{Par :: atom(), Val :: term()}]
get_all_env(Application) -> Env
Application = atom()
Env = [{Par :: atom(), Val :: term()}]
Returns the configuration parameters and their values for
. 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}
Keys = [{Key :: atom(), Val :: term()}, ...]
get_all_key(Application) -> undefined | Keys
Application = atom()
Keys = {ok, [{Key :: atom(), Val :: term()}, ...]}
Returns the application specification keys and their values
for
. 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}
Application = atom()
get_application(PidOrModule) -> undefined | {ok, Application}
PidOrModule = (Pid :: pid()) | (Module :: module())
Application = atom()
Returns the name of the application to which the process
or the 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}
Par = atom()
Val = term()
get_env(Application, Par) -> undefined | {ok, Val}
Application = Par = atom()
Val = term()
Returns the value of the configuration parameter
for
. 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
Application = Par = atom()
Def = Val = term()
Works like get_env/2 but returns
value when configuration parameter
does not exist.
get_key(Key) -> undefined | {ok, Val}
Key = atom()
Val = term()
get_key(Application, Key) -> undefined | {ok, Val}
Application = Key = atom()
Val = term()
Returns the value of the application specification key
for
. 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}
AppDescr = Application | (AppSpec :: application_spec())
Application = atom()
Reason = term()
load(AppDescr, Distributed) -> ok | {error, Reason}
AppDescr = Application | (AppSpec :: application_spec())
Application = atom()
Distributed =
{Application, Nodes} | {Application, Time, Nodes} | defaultNodes = [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
.
In this case the application controller will search the code
path for the application resource file
and load the specification it contains.
The application specification can also be given directly as a
tuple
. This tuple should have the format and
contents as described in app(4)
.
If
,
the application will be distributed. The argument overrides
the value for the application in the Kernel configuration
parameter distributed
.
must be
the name of the application (same as in the first argument).
If a node crashes and
has been specified, then
the application controller will wait for
milliseconds before attempting to restart the application on
another node. If
is not specified, it will
default to 0 and the application will be restarted
immediately.
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}]
Application = atom()
Description = Vsn = string()
Returns a list with information about the applications which
have been loaded using load/1,2
, also included
applications.
is the application name.
and
are the values of its
description
and vsn
application specification
keys, respectively.
permit(Application, Permission) -> ok | {error, Reason}
Application = atom()
Permission = boolean()
Reason = term()
Changes the permission for
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
Application = Par = atom()
Val = term()
set_env(Application, Par, Val, Timeout) -> ok
Application = Par = atom()
Val = term()
Timeout = timeout()
Sets the value of the configuration parameter
for
.
set_env/3
uses the standard gen_server
timeout
value (5000 ms). A
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}
Application = atom()
Reason = term()
ensure_started(Application, Type) -> ok | {error, Reason}
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}
Application = atom()
Started = [atom()]
Reason = term()
ensure_all_started(Application, Type) ->
{ok, Started} | {error, Reason}
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}
Application = atom()
Reason = term()
start(Application, Type) -> ok | {error, Reason}
Application = atom()
Type = restart_type()
Reason = term()
Starts
. 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
.
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
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
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
or
local
.
See Module:start/2
for a description of
.
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}
Application = atom()
Reason = term()
Stops
. 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(3)
). 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}
Application = atom()
Type = restart_type()
Reason = term()
Performs a takeover of the distributed 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}
Application = atom()
Reason = term()
Unloads the application specification for
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
Application = Par = atom()
unset_env(Application, Par, Timeout) -> ok
Application = Par = atom()
Timeout = timeout()
Removes the configuration parameter
and its value
for
.
unset_env/2
uses the standard gen_server
timeout value (5000 ms). A
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}]
Application = atom()
Description = Vsn = string()
which_applications(Timeout) -> [{Application, Description, Vsn}]
Timeout = timeout()
Application = atom()
Description = Vsn = string()
Returns a list with information about the applications which
are currently running.
is the application
name.
and
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
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.
Functions
Module:start(StartType, StartArgs) -> {ok, Pid} | {ok, Pid, State} | {error, Reason}
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 keystart_phases == undefined
.{takeover,Node}
if the application is distributed and started at the current node due to a takeover fromNode
, either becauseapplication:takeover/2
has been called or because the current node has higher priority thanNode
.{failover,Node}
if the application is distributed and started at the current node due to a failover fromNode
, and the application specification keystart_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}
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
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)
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
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.