Specs

ensure_all_started(Application) -> {ok, Started} | {error, Reason}
                      when Application :: atom(), Started :: [atom()], Reason :: term().

Equivalent to calling start/1,2 repeatedly on all dependencies that are not yet started for an application. Optional dependencies will also be loaded and started if they are available.

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.

Specs

ensure_all_started(Application, Type) -> {ok, Started} | {error, Reason}
                      when
                          Application :: atom(),
                          Type :: restart_type(),
                          Started :: [atom()],
                          Reason :: term().

Specs

ensure_started(Application) -> ok | {error, Reason} when Application :: atom(), Reason :: term().

Equivalent to start/1,2 except it returns ok for already started applications.

Specs

ensure_started(Application, Type) -> ok | {error, Reason}
                  when Application :: atom(), Type :: restart_type(), Reason :: term().

Specs

get_all_env() -> Env when 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 [].

Specs

get_all_env(Application) -> Env
               when Application :: atom(), Env :: [{Par :: atom(), Val :: term()}].

Specs

get_all_key() -> [] | {ok, Keys} when Keys :: [{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 [].

Specs

get_all_key(Application) -> undefined | Keys
               when Application :: atom(), Keys :: {ok, [{Key :: atom(), Val :: term()}, ...]}.

Specs

get_application() -> undefined | {ok, Application} when 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.

Specs

get_application(PidOrModule) -> undefined | {ok, Application}
                   when
                       PidOrModule :: (Pid :: pid()) | (Module :: module()), Application :: atom().

Specs

get_env(Par) -> undefined | {ok, Val} when 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.

Specs

get_env(Application, Par) -> undefined | {ok, Val}
           when Application :: atom(), Par :: atom(), Val :: term().

Specs

get_env(Application, Par, Def) -> Val
           when Application :: atom(), Par :: atom(), Def :: term(), Val :: term().

Works like get_env/2 but returns value Def when configuration parameter Par does not exist.

Specs

get_key(Key) -> undefined | {ok, Val} when 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.

Specs

get_key(Application, Key) -> undefined | {ok, Val}
           when Application :: atom(), Key :: atom(), Val :: term().

Specs

load(AppDescr) -> ok | {error, Reason}
        when
            AppDescr :: Application | (AppSpec :: application_spec()),
            Application :: atom(),
            Reason :: 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(4).

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.

Specs

load(AppDescr, Distributed) -> ok | {error, Reason}
        when
            AppDescr :: Application | (AppSpec :: application_spec()),
            Application :: atom(),
            Distributed :: {Application, Nodes} | {Application, Time, Nodes} | default,
            Nodes :: [node() | tuple_of(node())],
            Time :: pos_integer(),
            Reason :: term().

Specs

loaded_applications() -> [{Application, Description, Vsn}]
                       when Application :: atom(), Description :: string(), 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.

Specs

permit(Application, Permission) -> ok | {error, Reason}
          when 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.

Specs

set_env(Config) -> ok
           when
               Config :: [{Application, Env}],
               Application :: atom(),
               Env :: [{Par :: atom(), Val :: term()}].

Sets the configuration Config for multiple applications. It is equivalent to calling set_env/4 on each application individually, except it is more efficient. The given Config is validated before the configuration is set.

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

Option persistent can be set to true to guarantee that parameters set with set_env/2 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.

If an application is given more than once or if an application has the same key given more than once, the behaviour is undefined and a warning message will be logged. In future releases, an error will be raised.

set_env/1 is equivalent to set_env(Config, []).

Specs

set_env(Config, Opts) -> ok
           when
               Config :: [{Application, Env}],
               Application :: atom(),
               Env :: [{Par :: atom(), Val :: term()}],
               Opts :: [{timeout, timeout()} | {persistent, boolean()}].

Specs

set_env(Application, Par, Val) -> ok when Application :: atom(), Par :: atom(), Val :: term().

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.

Specs

set_env(Application, Par, Val, Opts) -> ok
           when
               Application :: atom(),
               Par :: atom(),
               Val :: term(),
               Opts :: [{timeout, timeout()} | {persistent, boolean()}].

Specs

start(Application) -> ok | {error, Reason} when Application :: atom(), 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. If an application is missing and the application is not marked as optional, {error,{not_started,App}} is returned, where App is the name of the missing application. Note this function makes no attempt to start any of the applications listed in applications, not even optional ones. See ensure_all_started/1,2 for recursively starting the current application and its dependencies.

Once validated, the application controller then creates an application master for the application. The application master becomes the group leader of all the processes in the application. I/O is forwarded to the previous group leader, though, this is just a way to identify processes that belong to the application. Used for example to find itself from any process, or, reciprocally, to kill them all when it terminates.

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

Specs

start(Application, Type) -> ok | {error, Reason}
         when Application :: atom(), Type :: restart_type(), Reason :: term().

Specs

start_type() -> StartType | undefined | local when 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.

Specs

stop(Application) -> ok | {error, Reason} when 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(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 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.

Specs

takeover(Application, Type) -> ok | {error, Reason}
            when 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.

Specs

unload(Application) -> ok | {error, Reason} when 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.

Specs

unset_env(Application, Par) -> ok when Application :: atom(), Par :: atom().

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

Specs

unset_env(Application, Par, Opts) -> ok
             when
                 Application :: atom(),
                 Par :: atom(),
                 Opts :: [{timeout, timeout()} | {persistent, boolean()}].

Specs

which_applications() -> [{Application, Description, Vsn}]
                      when Application :: atom(), Description :: string(), 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.

Specs

which_applications(Timeout) -> [{Application, Description, Vsn}]
                      when
                          Timeout :: timeout(),
                          Application :: atom(),
                          Description :: string(),
                          Vsn :: string().