application(3erl)
NAME
application - Generic OTP application functions
DESCRIPTION
In OTP, application denotes a component implementing some specific functionality, that can be started and stopped as a unit, and that can be reused in other systems. This module interacts with application controller, a process started at every Erlang runtime system. 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 named Application.app, where Application is the application name. For details about the application specification, see app(5). 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 is to be located in an application callback module, exporting a predefined set of functions. For details about applications and behaviours, see OTP Design Principles.
DATA 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.
EXPORTS
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 start/1,2 repeatedly on all dependencies
that are not yet started for an application.
Returns {ok, AppNames} for a successful start or for an already
started application (which is, however, omitted from the
AppNames list).
The function reports {error, {AppName,Reason}} for errors, where
Reason is any possible reason returned by start/1,2 when
starting a specific dependency.
If an error occurs, the applications started by the function are
stopped to bring the set of running applications back to its
initial state.
ensure_started(Application) -> ok | {error, Reason}
ensure_started(Application, Type) -> ok | {error, Reason}
Types:
Application = atom()
Type = restart_type()
Reason = term()
Equivalent to start/1,2 except it returns ok for already started
applications.
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 configuration parameter Par for
Application. If the application argument is omitted, it defaults
to the application of the calling process.
Returns undefined if any of the following applies:
* The specified application is not loaded.
* The configuration parameter does not exist.
* The process executing the call does not belong to any
application.
get_env(Application, Par, Def) -> Val
Types:
Application = Par = atom()
Def = Val = term()
Works like get_env/2 but returns value Def 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.
Returns undefined if any of the following applies:
* The specified application is not loaded.
* The specification key does not exist.
* The process executing the call does not belong to any
application.
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_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 also loads the application
specifications for any included applications. Notice that the
function does not load the Erlang object code.
The application can be specified by its name Application. In
this case, the application controller searches the code path for
the application resource file Application.app and loads the
specification it contains.
The application specification can also be specified directly as
a tuple AppSpec, having the format and contents as described in
app(5).
If Distributed == {Application,[Time,]Nodes}, the application
becomes distributed. The argument overrides the value for the
application in the Kernel configuration parameter distributed.
Application must be the application name (same as in the first
argument). If a node crashes and Time is specified, the
application controller waits for Time milliseconds before
attempting to restart the application on another node. If Time
is not specified, it defaults to 0 and the application is
restarted immediately.
Nodes is a list of node names where the application can 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 is preferably to be started at
cp1@cave. If cp1@cave is down, the application is to be started
at cp2@cave or cp3@cave.
If Distributed == default, the value for the application in the
Kernel configuration parameter distributed is used.
loaded_applications() -> [{Application, Description, Vsn}]
Types:
Application = atom()
Description = Vsn = string()
Returns a list with information about the applications, and
included applications, which are loaded using load/1,2.
Application is the application name. Description and Vsn are the
values of their 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 be 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 returns ok but the application is not
started until the permission is set to true.
If the permission of a running application is set to false, the
application is stopped. If the permission later is set to true,
it is 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).
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 returns ok
even though the application is not started. This is true when an
application cannot start because of dependencies to other
applications that are not yet started. When they are started,
Application is started as well.
By default, all applications are loaded with permission true on
all nodes. The permission can be configured 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 configuration parameter Par for Application.
set_env/4 uses the standard gen_server time-out value (5000 ms).
Option timeout can be specified if another time-out 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 file Application.app
override the ones previously set. This is also true for
application reloads.
Option persistent can be set to true to guarantee that
parameters set with set_env/4 are not overridden by those
defined in the application resource file on load. This means
that 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-dependent and
configuration parameter-dependent when and how often the value
is read by the application. Careless use of this function can
put the application in a weird, inconsistent, and malfunctioning
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 first loads it using load/1. It ensures that any
included applications are loaded, but does 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
needed to be started before this application are running.
Otherwise, {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.
Argument Type 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.
Notice that an application can always be stopped explicitly by
calling stop/1. Regardless of the type of the application, no
other applications are affected.
Notice also that the transient type is of little practical use,
because when a supervision tree terminates, the reason is set to
shutdown, not normal.
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 started, to determine
the start type, which is StartType or local.
For a description of StartType, see Module:start/2.
local is returned if only parts of the application are 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 shut down (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 terminates. Notice that all
processes with the application master as group leader, that is,
processes spawned from a process belonging to the application,
are also terminated.
When stopped, the application is still loaded.
To stop a distributed application, stop/1 must 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 stops its execution. The
application is not moved between nodes, as stop/1 is 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()
Takes over 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, that is, when Module:start/2 and any calls to
Module:start_phase/3 have returned.
Thus, two instances of the application run simultaneously during
the takeover, so that data can be transferred from the old to
the new instance. If this is not an acceptable behavior, parts
of the old instance can be shut down when the new instance is
started. However, the application cannot be stopped entirely, at
least the top supervisor must remain alive.
For a description of Type, see start/1,2.
unload(Application) -> ok | {error, Reason}
Types:
Application = atom()
Reason = term()
Unloads the application specification for Application from the
application controller. It also unloads the application
specifications for any included applications. Notice that the
function does not purge the 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 time-out value (5000
ms). Option timeout can be specified if another time-out 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).
Warning:
Use this function only if you know what you are doing, that is,
on your own applications. It is very application-dependent and
configuration parameter-dependent when and how often the value
is read by the application. Careless use of this function can
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 that are
currently running. Application is the application name.
Description and Vsn are the values of their description and vsn
application specification keys, respectively.
which_applications/0 uses the standard gen_server time-out value
(5000 ms). A Timeout argument can be specified if another time-
out value is useful, for example, in situations where the
application controller is heavily loaded.
CALLBACK MODULE
The following functions are to 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
start/1,2, and is to 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 is a normal startup.
* normal also if the application is distributed and started at
the current node because of 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 because of a takeover from Node,
either because 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 because of 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 is to 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 the application is stopped
later, State is passed to Module:prep_stop/1.
Module:start_phase(Phase, StartType, PhaseArgs) -> ok | {error, Reason}
Types:
Phase = atom()
StartType = start_type()
PhaseArgs = term()
Pid = pid()
State = state()
Starts an application with included applications, when
synchronization is needed between processes in the different
applications during startup.
The start phases are 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.
For a description of StartType, see Module:start/2.
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 is passed to
Module:stop/1.
The function is optional. If it is not defined, the processes
are 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 is to 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 the configuration parameters have changed.
Changed is a list of parameter-value tuples including all
configuration parameters with changed values.
New is a list of parameter-value tuples including all added
configuration parameters.
Removed is a list of all removed parameters.
SEE ALSO
OTP Design Principles, kernel(7), app(5)
Opportunity
Personal Opportunity - Free software gives you access to billions of dollars of software at no cost. Use this software for your business, personal use or to develop a profitable skill. Access to source code provides access to a level of capabilities/information that companies protect though copyrights. Open source is a core component of the Internet and it is available to you. Leverage the billions of dollars in resources and capabilities to build a career, establish a business or change the world. The potential is endless for those who understand the opportunity.
Business Opportunity - Goldman Sachs, IBM and countless large corporations are leveraging open source to reduce costs, develop products and increase their bottom lines. Learn what these companies know about open source and how open source can give you the advantage.
Free Software
Free Software provides computer programs and capabilities at no cost but more importantly, it provides the freedom to run, edit, contribute to, and share the software. The importance of free software is a matter of access, not price. Software at no cost is a benefit but ownership rights to the software and source code is far more significant.
Free Office Software - The Libre Office suite provides top desktop productivity tools for free. This includes, a word processor, spreadsheet, presentation engine, drawing and flowcharting, database and math applications. Libre Office is available for Linux or Windows.
Free Books
The Free Books Library is a collection of thousands of the most popular public domain books in an online readable format. The collection includes great classical literature and more recent works where the U.S. copyright has expired. These books are yours to read and use without restrictions.
Source Code - Want to change a program or know how it works? Open Source provides the source code for its programs so that anyone can use, modify or learn how to write those programs themselves. Visit the GNU source code repositories to download the source.
Education
Study at Harvard, Stanford or MIT - Open edX provides free online courses from Harvard, MIT, Columbia, UC Berkeley and other top Universities. Hundreds of courses for almost all major subjects and course levels. Open edx also offers some paid courses and selected certifications.
Linux Manual Pages - A man or manual page is a form of software documentation found on Linux/Unix operating systems. Topics covered include computer programs (including library and system calls), formal standards and conventions, and even abstract concepts.
