![[Erlang Systems]](min_head.gif)
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.
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.
get_all_env() -> Env
get_all_env(Application) -> Env
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
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
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
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
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}
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() > 0Reason = 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}]
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}
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
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}
Application = atom()Type = permanent | transient | temporaryReason = 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.
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.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
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}
Application = atom()Reason = term()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}
Application = atom()Type = permanent | transient | temporaryReason = 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}
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}]
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.
The following functions should be exported from an application
callback module.
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.
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 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}
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
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.
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.
kernel(6), app(4)