table of contents
other versions
- jessie 1:17.3-dfsg-4+deb8u2
- jessie-backports 1:19.2.1+dfsg-2+deb9u1~bpo8+1
- stretch 1:19.2.1+dfsg-2+deb9u2
- testing 1:21.2.5+dfsg-1
- unstable 1:21.2.6+dfsg-1
- experimental 1:22.0~rc1+dfsg-1
application(3erl) | Erlang Module Definition | application(3erl) |
NAME¶
application - Generic OTP application functionsDESCRIPTION¶
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(5) 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.DATA TYPES¶
start_type() = normal| {takeover, Node :: node()}| {failover, Node :: node()}restart_type() = permanent | transient | temporarytuple_of(T)
A tuple where the elements are of type T.
EXPORTS¶
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 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_env(Application, Par, Def) -> Val
Types:
Application = Par = atom()
Def = Val = term()
Works like get_env/2 but returns Def value 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.
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_spec())
Application = atom()
Distributed = {Application, Nodes}
| {Application, Time, Nodes}
| default
Nodes = [node() | tuple_of(node())]
Time = integer() >= 1
Reason = term()
| {Application, Time, Nodes}
| default
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 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(5).
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 = 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, 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 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
set_env(Application, Par, Val, Opts) -> ok
Types:
Application = Par = atom()
Val = term()
Opts = [{timeout, timeout()} | {persistent, boolean()}]
Sets the value of the configuration parameter Par for Application.
set_env/4 uses the standard gen_server timeout value (5000 ms).
The timeout option can be provided if another timeout 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 the Application.app file will override
the ones previously set. This is also true for application reloads.
The persistent option can be set to true when there is a need to
guarantee parameters set with set_env/4 will not be overridden by the
ones defined in the application resource file on load. This means 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 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}
ensure_started(Application, Type) -> ok | {error, Reason}
Types:
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}
ensure_all_started(Application, Type) -> {ok, Started} | {error, Reason}
Types:
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}
start(Application, Type) -> ok | {error, Reason}
Types:
Application = atom()
Type = restart_type()
Reason = term()
Starts Application. 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 Application.
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 Type argument specifies the type of the application. If omitted, it
defaults to temporary.
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.
- *
- 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.
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 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.
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 shutdown (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 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}
Types:
Application = atom()
Type = restart_type()
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.
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 timeout value (5000 ms).
The timeout option can be provided if another timeout 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 above).
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}]
which_applications(Timeout) -> [{Application, Description, Vsn}]
Types:
Timeout = timeout()
Application = atom()
Description = 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
specification keys, respectively.
which_applications/0 uses the standard gen_server timeout value
(5000 ms). A Timeout 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.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
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:
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}
- *
- 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 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.
Types:
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
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()
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.
SEE ALSO¶
OTP Design Principles, kernel(7), app(5)kernel 3.0.3 | Ericsson AB |