aboutsummaryrefslogtreecommitdiffstats
path: root/lib/kernel/src/application_controller.erl
diff options
context:
space:
mode:
Diffstat (limited to 'lib/kernel/src/application_controller.erl')
-rw-r--r--lib/kernel/src/application_controller.erl1946
1 files changed, 1946 insertions, 0 deletions
diff --git a/lib/kernel/src/application_controller.erl b/lib/kernel/src/application_controller.erl
new file mode 100644
index 0000000000..7c1f059875
--- /dev/null
+++ b/lib/kernel/src/application_controller.erl
@@ -0,0 +1,1946 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 1996-2009. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+-module(application_controller).
+
+%% External exports
+-export([start/1,
+ load_application/1, unload_application/1,
+ start_application/2, start_boot_application/2, stop_application/1,
+ control_application/1,
+ change_application_data/2, prep_config_change/0, config_change/1,
+ which_applications/0, which_applications/1,
+ loaded_applications/0, info/0,
+ get_pid_env/2, get_env/2, get_pid_all_env/1, get_all_env/1,
+ get_pid_key/2, get_key/2, get_pid_all_key/1, get_all_key/1,
+ get_master/1, get_application/1, get_application_module/1,
+ start_type/1, permit_application/2, do_config_diff/2,
+ set_env/3, set_env/4, unset_env/2, unset_env/3]).
+
+%% Internal exports
+-export([handle_call/3, handle_cast/2, handle_info/2, terminate/2,
+ code_change/3, init_starter/4, get_loaded/1]).
+
+%% Test exports, only to be used from the test suites
+-export([test_change_apps/2]).
+
+-import(lists, [zf/2, map/2, foreach/2, foldl/3,
+ keysearch/3, keydelete/3, keyreplace/4]).
+
+-include("application_master.hrl").
+
+-define(AC, ?MODULE). % Name of process
+
+%%%-----------------------------------------------------------------
+%%% The application_controller controls local applications only. A
+%%% local application can be loaded/started/stopped/unloaded and
+%%% changed. The control of distributed applications is taken care of
+%%% by another process (default is dist_ac).
+%%%
+%%% When an application has been started (by a call to application:start)
+%%% it can be running or not running (on this node). For example,
+%%% a distributed application must be started on all nodes, but
+%%% may be running on one node at the time.
+%%%
+%%% The external API to this module is in the module 'application'.
+%%%
+%%% The process that controls distributed applications (called dist
+%%% ac). calls application_controller:control_application(Name) to
+%%% take responsibility for an application. The interface between AC
+%%% and the dist_ac process is message-based:
+%%%
+%%% AC DIST AC
+%%% == =======
+%%% --> {ac_load_application_req, Name}
+%%% <-- {ac_load_application_reply, Name, LoadReply}
+%%% --> {ac_start_application_req, Name} (*)
+%%% <-- {ac_start_application_reply, Name, StartReply}
+%%% --> {ac_application_run, Name, Res}
+%%% --> {ac_application_not_run, Name, Res}
+%%% --> {ac_application_stopped, Name}
+%%% --> {ac_application_unloaded, Name}
+%%% <-- {ac_change_application_req, Name, Req} (**)
+%%%
+%%% Where LoadReply =
+%%% ok - App is loaded
+%%% {error, R} - An error occurred
+%%% And StartReply =
+%%% start_it - DIST AC decided that AC should start the app
+%%% {started, Node} - The app is started distributed at Node
+%%% not_started - The app should not be running at this time
+%%% {takeover, Node}- The app should takeover from Node
+%%% {error, R} - an error occurred
+%%% And Req =
+%%% start_it - DIST AC wants AC to start the app locally
+%%% stop_it - AC should stop the app.
+%%% {takeover, Node, RestartType}
+%%% - AC should start the app as a takeover
+%%% {failover, Node, RestartType}
+%%% - AC should start the app as a failover
+%%% {started, Node} - The app is started at Node
+%%% NOTE: The app must have been started at this node
+%%% before this request is sent!
+%%% And Res =
+%%% ok - Application is started locally
+%%% {error, R} - Start of application failed
+%%%
+%%% (*)
+%%% The call to application:start() doesn't return until the
+%%% ac_start_application_reply has been received by AC. AC
+%%% itself is not blocked however.
+%%% (**)
+%%% DIST AC gets ACK to its ac_change_application_req, but not as a
+%%% separate messgage. Instead the normal messages are used as:
+%%% start_it generates an ac_application_run
+%%% stop_it generates an ac_application_not_run
+%%% takeover generates an ac_application_run
+%%% started doesn't generate anything
+%%%
+%%% There is a distinction between application:stop and stop_it
+%%% from a dist ac process. The first one stops the application,
+%%% and resets the internal structures as they were before start was
+%%% called. stop_it stops the application, but just marks it as
+%%% not being running.
+%%%
+%%% When a dist ac process has taken control of an application, no
+%%% other process can take the control.
+%%%-----------------------------------------------------------------
+
+%%-----------------------------------------------------------------
+%% Naming conventions:
+%% App = appl_descr()
+%% Appl = #appl
+%% AppName = atom()
+%% Application = App | AppName
+%%-----------------------------------------------------------------
+-record(state, {loading = [], starting = [], start_p_false = [], running = [],
+ control = [], started = [], start_req = [], conf_data}).
+%%-----------------------------------------------------------------
+%% loading = [{AppName, From}] - Load not yet finished
+%% starting = [{AppName, RestartType, Type, From}] - Start not
+%% yet finished
+%% start_p_false = [{AppName, RestartType, Type, From}] - Start not
+%% executed because permit == false
+%% running = [{AppName, Pid}] - running locally (Pid == application_master)
+%% [{AppName, {distributed, Node}}] - running on Node
+%% control = [{AppName, Controller}]
+%% started = [{AppName, RestartType}] - Names of all apps that
+%% have been started (but may not run because
+%% permission = false)
+%% conf_data = [{AppName, Env}]
+%% start_req = [{AppName, From}] - list of all start requests
+%% Id = AMPid | undefined | {distributed, Node}
+%% Env = [{Key, Value}]
+%%-----------------------------------------------------------------
+
+-record(appl, {name, appl_data, descr, id, vsn, restart_type, inc_apps, apps}).
+
+%%-----------------------------------------------------------------
+%% Func: start/1
+%% Args: KernelApp = appl_descr()
+%% appl_descr() = [{application, Name, [appl_opt()]}]
+%% appl_opt() = {description, string()} |
+%% {vsn, string()} |
+%% {id, string()}, |
+%% {modules, [Module|{Module,Vsn}]} |
+%% {registered, [atom()]} |
+%% {applications, [atom()]} |
+%% {included_applications, [atom()]} |
+%% {env, [{atom(), term()}]} |
+%% {start_phases, [{atom(), term()}]}|
+%% {maxT, integer()|infinity} |
+%% {maxP, integer()|infinity} |
+%% {mod, {Module, term()}}
+%% Module = atom()
+%% Vsn = term()
+%% Purpose: Starts the application_controller. This process starts all
+%% application masters for the applications.
+%% The kernel application is the only application that is
+%% treated specially. The reason for this is that the kernel
+%% starts user. This process is special because it should
+%% be group_leader for this process.
+%% Pre: All modules are loaded, or will be loaded on demand.
+%% Returns: {ok, Pid} | ReasonStr
+%%-----------------------------------------------------------------
+start(KernelApp) ->
+ %% OTP-5811 Don't start as a gen_server to prevent crash report
+ %% when (if) the process terminates
+ Init = self(),
+ AC = spawn_link(fun() -> init(Init, KernelApp) end),
+ receive
+ {ack, AC, ok} ->
+ {ok, AC};
+ {ack, AC, {error, Reason}} ->
+ to_string(Reason); % init doesn't want error tuple, only a reason
+ {'EXIT', _Pid, Reason} ->
+ to_string(Reason)
+ end.
+
+%%-----------------------------------------------------------------
+%% Func: load_application/1
+%% Args: Application = appl_descr() | atom()
+%% Purpose: Loads an application. Currently just inserts the
+%% application's env.
+%% Returns: ok | {error, Reason}
+%%-----------------------------------------------------------------
+load_application(Application) ->
+ gen_server:call(?AC, {load_application, Application}, infinity).
+
+unload_application(AppName) ->
+ gen_server:call(?AC, {unload_application, AppName}, infinity).
+
+%%-----------------------------------------------------------------
+%% Func: start_application/2
+%% Args: Application = atom()
+%% RestartType = permanent | transient | temporary
+%% Purpose: Starts a new application.
+%% The RestartType specifies what should happen if the
+%% application dies:
+%% If it is permanent, all other applications are terminated,
+%% and the application_controller dies.
+%% If it is transient, and the application dies normally,
+%% this is reported and no other applications are terminated.
+%% If the application dies abnormally, all other applications
+%% are terminated, and the application_controller dies.
+%% If it is temporary and the application dies this is reported
+%% and no other applications are terminated. In this way,
+%% an application can run in test mode, without disturbing
+%% the other applications.
+%% The caller of this function is suspended until the application
+%% is started, either locally or distributed.
+%% Returns: ok | {error, Reason}
+%%-----------------------------------------------------------------
+start_application(AppName, RestartType) ->
+ gen_server:call(?AC, {start_application, AppName, RestartType}, infinity).
+
+%%-----------------------------------------------------------------
+%% Func: start_boot_application/2
+%% The same as start_application/2 expect that this function is
+%% called from the boot script file. It mustnot be used by the operator.
+%% This function will cause a node crash if a permanent application
+%% fails to boot start
+%%-----------------------------------------------------------------
+start_boot_application(Application, RestartType) ->
+ case {application:load(Application), RestartType} of
+ {ok, _} ->
+ AppName = get_appl_name(Application),
+ gen_server:call(?AC, {start_application, AppName, RestartType}, infinity);
+ {{error, {already_loaded, AppName}}, _} ->
+ gen_server:call(?AC, {start_application, AppName, RestartType}, infinity);
+ {{error,{bad_environment_value,Env}}, permanent} ->
+ Txt = io_lib:format("Bad environment variable: ~p Application: ~p",
+ [Env, Application]),
+ exit({error, list_to_atom(lists:flatten(Txt))});
+ {Error, _} ->
+ Error
+ end.
+
+stop_application(AppName) ->
+ gen_server:call(?AC, {stop_application, AppName}, infinity).
+
+%%-----------------------------------------------------------------
+%% Returns: [{Name, Descr, Vsn}]
+%%-----------------------------------------------------------------
+which_applications() ->
+ gen_server:call(?AC, which_applications).
+which_applications(Timeout) ->
+ gen_server:call(?AC, which_applications, Timeout).
+
+loaded_applications() ->
+ ets:filter(ac_tab,
+ fun([{{loaded, AppName}, #appl{descr = Descr, vsn = Vsn}}]) ->
+ {true, {AppName, Descr, Vsn}};
+ (_) ->
+ false
+ end,
+ []).
+
+%% Returns some debug info
+info() ->
+ gen_server:call(?AC, info).
+
+control_application(AppName) ->
+ gen_server:call(?AC, {control_application, AppName}, infinity).
+
+%%-----------------------------------------------------------------
+%% Func: change_application_data/2
+%% Args: Applications = [appl_descr()]
+%% Config = [{AppName, [{Par,Val}]}]
+%% Purpose: Change all applications and their parameters on this node.
+%% This function should be used from a release handler, at
+%% the same time as the .app or start.boot file is
+%% introduced. Note that during some time the ACs may have
+%% different view of e.g. the distributed applications.
+%% This is solved by syncing the release installation.
+%% However, strange things may happen if a node crashes
+%% and two other nodes have different opinons about who's
+%% gonna start the applications. The release handler must
+%% shutdown each involved node in this case.
+%% Note that this function is used to change existing apps,
+%% adding new/deleting old isn't handled by this function.
+%% Changes an application's vsn, descr and env.
+%% Returns: ok | {error, Reason}
+%% If an error occurred, the situation may be inconsistent,
+%% so the release handler must restart the node. E.g. if
+%% some applicatation may have got new config data.
+%%-----------------------------------------------------------------
+change_application_data(Applications, Config) ->
+ gen_server:call(?AC,
+ {change_application_data, Applications, Config},
+ infinity).
+
+prep_config_change() ->
+ gen_server:call(?AC,
+ prep_config_change,
+ infinity).
+
+
+config_change(EnvPrev) ->
+ gen_server:call(?AC,
+ {config_change, EnvPrev},
+ infinity).
+
+
+
+get_pid_env(Master, Key) ->
+ case ets:match(ac_tab, {{application_master, '$1'}, Master}) of
+ [[AppName]] -> get_env(AppName, Key);
+ _ -> undefined
+ end.
+
+get_env(AppName, Key) ->
+ case ets:lookup(ac_tab, {env, AppName, Key}) of
+ [{_, Val}] -> {ok, Val};
+ _ -> undefined
+ end.
+
+get_pid_all_env(Master) ->
+ case ets:match(ac_tab, {{application_master, '$1'}, Master}) of
+ [[AppName]] -> get_all_env(AppName);
+ _ -> []
+ end.
+
+get_all_env(AppName) ->
+ map(fun([Key, Val]) -> {Key, Val} end,
+ ets:match(ac_tab, {{env, AppName, '$1'}, '$2'})).
+
+
+
+
+get_pid_key(Master, Key) ->
+ case ets:match(ac_tab, {{application_master, '$1'}, Master}) of
+ [[AppName]] -> get_key(AppName, Key);
+ _ -> undefined
+ end.
+
+get_key(AppName, Key) ->
+ case ets:lookup(ac_tab, {loaded, AppName}) of
+ [{_, Appl}] ->
+ case Key of
+ description ->
+ {ok, Appl#appl.descr};
+ id ->
+ {ok, Appl#appl.id};
+ vsn ->
+ {ok, Appl#appl.vsn};
+ modules ->
+ {ok, (Appl#appl.appl_data)#appl_data.mods};
+ maxP ->
+ {ok, (Appl#appl.appl_data)#appl_data.maxP};
+ maxT ->
+ {ok, (Appl#appl.appl_data)#appl_data.maxT};
+ registered ->
+ {ok, (Appl#appl.appl_data)#appl_data.regs};
+ included_applications ->
+ {ok, Appl#appl.inc_apps};
+ applications ->
+ {ok, Appl#appl.apps};
+ env ->
+ {ok, get_all_env(AppName)};
+ mod ->
+ {ok, (Appl#appl.appl_data)#appl_data.mod};
+ start_phases ->
+ {ok, (Appl#appl.appl_data)#appl_data.phases};
+ _ -> undefined
+ end;
+ _ ->
+ undefined
+ end.
+
+get_pid_all_key(Master) ->
+ case ets:match(ac_tab, {{application_master, '$1'}, Master}) of
+ [[AppName]] -> get_all_key(AppName);
+ _ -> []
+ end.
+
+get_all_key(AppName) ->
+ case ets:lookup(ac_tab, {loaded, AppName}) of
+ [{_, Appl}] ->
+ {ok, [{description, Appl#appl.descr},
+ {id, Appl#appl.id},
+ {vsn, Appl#appl.vsn},
+ {modules, (Appl#appl.appl_data)#appl_data.mods},
+ {maxP, (Appl#appl.appl_data)#appl_data.maxP},
+ {maxT, (Appl#appl.appl_data)#appl_data.maxT},
+ {registered, (Appl#appl.appl_data)#appl_data.regs},
+ {included_applications, Appl#appl.inc_apps},
+ {applications, Appl#appl.apps},
+ {env, get_all_env(AppName)},
+ {mod, (Appl#appl.appl_data)#appl_data.mod},
+ {start_phases, (Appl#appl.appl_data)#appl_data.phases}
+ ]};
+ _ ->
+ undefined
+ end.
+
+
+start_type(Master) ->
+ case ets:match(ac_tab, {{application_master, '$1'}, Master}) of
+ [[AppName]] ->
+ gen_server:call(?AC, {start_type, AppName}, infinity);
+ _X ->
+ undefined
+ end.
+
+
+
+
+
+
+get_master(AppName) ->
+ case ets:lookup(ac_tab, {application_master, AppName}) of
+ [{_, Pid}] -> Pid;
+ _ -> undefined
+ end.
+
+get_application(Master) ->
+ case ets:match(ac_tab, {{application_master, '$1'}, Master}) of
+ [[AppName]] -> {ok, AppName};
+ _ -> undefined
+ end.
+
+get_application_module(Module) ->
+ ApplDataPattern = #appl_data{mods='$2', _='_'},
+ ApplPattern = #appl{appl_data=ApplDataPattern, _='_'},
+ AppModules = ets:match(ac_tab, {{loaded, '$1'}, ApplPattern}),
+ get_application_module(Module, AppModules).
+
+get_application_module(Module, [[AppName, Modules]|AppModules]) ->
+ case in_modules(Module, Modules) of
+ true ->
+ {ok, AppName};
+ false ->
+ get_application_module(Module, AppModules)
+ end;
+get_application_module(_Module, []) ->
+ undefined.
+
+%% 'modules' key in .app is a list of Module or {Module,Vsn}
+in_modules(Module, [Module|_Modules]) ->
+ true;
+in_modules(Module, [{Module, _Vsn}|_Modules]) ->
+ true;
+in_modules(Module, [_Module|Modules]) ->
+ in_modules(Module, Modules);
+in_modules(_Module, []) ->
+ false.
+
+permit_application(ApplName, Flag) ->
+ gen_server:call(?AC,
+ {permit_application, ApplName, Flag},
+ infinity).
+
+
+set_env(AppName, Key, Val) ->
+ gen_server:call(?AC, {set_env, AppName, Key, Val}).
+set_env(AppName, Key, Val, Timeout) ->
+ gen_server:call(?AC, {set_env, AppName, Key, Val}, Timeout).
+
+unset_env(AppName, Key) ->
+ gen_server:call(?AC, {unset_env, AppName, Key}).
+unset_env(AppName, Key, Timeout) ->
+ gen_server:call(?AC, {unset_env, AppName, Key}, Timeout).
+
+%%%-----------------------------------------------------------------
+%%% call-back functions from gen_server
+%%%-----------------------------------------------------------------
+init(Init, Kernel) ->
+ register(?AC, self()),
+ process_flag(trap_exit, true),
+ put('$ancestors', [Init]), % OTP-5811, for gen_server compatibility
+ put('$initial_call', {application_controller, start, 1}),
+
+ case catch check_conf() of
+ {ok, ConfData} ->
+ %% Actually, we don't need this info in an ets table anymore.
+ %% This table was introduced because starting applications
+ %% should be able to get som info from AC (e.g. loaded_apps).
+ %% The new implementation makes sure the AC process can be
+ %% called during start-up of any app.
+ case check_conf_data(ConfData) of
+ ok ->
+ ets:new(ac_tab, [set, public, named_table]),
+ S = #state{conf_data = ConfData},
+ {ok, KAppl} = make_appl(Kernel),
+ case catch load(S, KAppl) of
+ {'EXIT', LoadError} ->
+ Reason = {'load error', LoadError},
+ Init ! {ack, self(), {error, to_string(Reason)}};
+ {ok, NewS} ->
+ Init ! {ack, self(), ok},
+ gen_server:enter_loop(?MODULE, [], NewS,
+ {local, ?AC})
+ end;
+ {error, ErrorStr} ->
+ Str = lists:flatten(io_lib:format("invalid config data: ~s", [ErrorStr])),
+ Init ! {ack, self(), {error, to_string(Str)}}
+ end;
+ {error, {File, Line, Str}} ->
+ ReasonStr =
+ lists:flatten(io_lib:format("error in config file "
+ "~p (~w): ~s",
+ [File, Line, Str])),
+ Init ! {ack, self(), {error, to_string(ReasonStr)}}
+ end.
+
+
+%% Check the syntax of the .config file [{ApplicationName, [{Parameter, Value}]}].
+check_conf_data([]) ->
+ ok;
+check_conf_data(ConfData) when is_list(ConfData) ->
+ [Application | ConfDataRem] = ConfData,
+ case Application of
+ {kernel, List} when is_list(List) ->
+ case check_para_kernel(List) of
+ ok ->
+ check_conf_data(ConfDataRem);
+ Error1 ->
+ Error1
+ end;
+ {AppName, List} when is_atom(AppName), is_list(List) ->
+ case check_para(List, atom_to_list(AppName)) of
+ ok ->
+ check_conf_data(ConfDataRem);
+ Error2 ->
+ Error2
+ end;
+ {AppName, List} when is_list(List) ->
+ ErrMsg = "application: "
+ ++ lists:flatten(io_lib:format("~p",[AppName]))
+ ++ "; application name must be an atom",
+ {error, ErrMsg};
+ {AppName, _List} ->
+ ErrMsg = "application: "
+ ++ lists:flatten(io_lib:format("~p",[AppName]))
+ ++ "; parameters must be a list",
+ {error, ErrMsg};
+ Else ->
+ ErrMsg = "invalid application name: " ++
+ lists:flatten(io_lib:format(" ~p",[Else])),
+ {error, ErrMsg}
+ end;
+check_conf_data(_ConfData) ->
+ {error, 'configuration must be a list ended by <dot><whitespace>'}.
+
+
+%% Special check of distributed parameter for kernel
+check_para_kernel([]) ->
+ ok;
+check_para_kernel([{distributed, Apps} | ParaList]) when is_list(Apps) ->
+ case check_distributed(Apps) of
+ {error, ErrorMsg} ->
+ {error, ErrorMsg};
+ _ ->
+ check_para_kernel(ParaList)
+ end;
+check_para_kernel([{distributed, _Apps} | _ParaList]) ->
+ {error, "application: kernel; erroneous parameter: distributed"};
+check_para_kernel([{Para, _Val} | ParaList]) when is_atom(Para) ->
+ check_para_kernel(ParaList);
+check_para_kernel([{Para, _Val} | _ParaList]) ->
+ {error, "application: kernel; invalid parameter: " ++
+ lists:flatten(io_lib:format("~p",[Para]))};
+check_para_kernel(Else) ->
+ {error, "application: kernel; invalid parameter list: " ++
+ lists:flatten(io_lib:format("~p",[Else]))}.
+
+
+check_distributed([]) ->
+ ok;
+check_distributed([{App, List} | Apps]) when is_atom(App), is_list(List) ->
+ check_distributed(Apps);
+check_distributed([{App, infinity, List} | Apps]) when is_atom(App), is_list(List) ->
+ check_distributed(Apps);
+check_distributed([{App, Time, List} | Apps]) when is_atom(App), is_integer(Time), is_list(List) ->
+ check_distributed(Apps);
+check_distributed(_Else) ->
+ {error, "application: kernel; erroneous parameter: distributed"}.
+
+
+check_para([], _AppName) ->
+ ok;
+check_para([{Para, _Val} | ParaList], AppName) when is_atom(Para) ->
+ check_para(ParaList, AppName);
+check_para([{Para, _Val} | _ParaList], AppName) ->
+ {error, "application: " ++ AppName ++ "; invalid parameter: " ++
+ lists:flatten(io_lib:format("~p",[Para]))};
+check_para([Else | _ParaList], AppName) ->
+ {error, "application: " ++ AppName ++ "; invalid parameter: " ++
+ lists:flatten(io_lib:format("~p",[Else]))}.
+
+
+handle_call({load_application, Application}, From, S) ->
+ case catch do_load_application(Application, S) of
+ {ok, NewS} ->
+ AppName = get_appl_name(Application),
+ case cntrl(AppName, S, {ac_load_application_req, AppName}) of
+ true ->
+ {noreply, S#state{loading = [{AppName, From} |
+ S#state.loading]}};
+ false ->
+ {reply, ok, NewS}
+ end;
+ {error, Error} ->
+ {reply, {error, Error}, S};
+ {'EXIT',R} ->
+ {reply, {error, R}, S}
+ end;
+
+handle_call({unload_application, AppName}, _From, S) ->
+ case lists:keymember(AppName, 1, S#state.running) of
+ true -> {reply, {error, {running, AppName}}, S};
+ false ->
+ case get_loaded(AppName) of
+ {true, _} ->
+ NewS = unload(AppName, S),
+ cntrl(AppName, S, {ac_application_unloaded, AppName}),
+ {reply, ok, NewS};
+ false ->
+ {reply, {error, {not_loaded, AppName}}, S}
+ end
+ end;
+
+handle_call({start_application, AppName, RestartType}, From, S) ->
+ #state{running = Running, starting = Starting, start_p_false = SPF,
+ started = Started, start_req = Start_req} = S,
+ %% Check if the commandline environment variables are OK.
+ %% Incase of erroneous variables do not start the application,
+ %% if the application is permanent crash the node.
+ %% Check if the application is already starting.
+ case lists:keysearch(AppName, 1, Start_req) of
+ false ->
+ case catch check_start_cond(AppName, RestartType, Started, Running) of
+ {ok, Appl} ->
+ Cntrl = cntrl(AppName, S, {ac_start_application_req, AppName}),
+ Perm = application:get_env(kernel, permissions),
+ case {Cntrl, Perm} of
+ {true, _} ->
+ {noreply, S#state{starting = [{AppName, RestartType, normal, From} |
+ Starting],
+ start_req = [{AppName, From} | Start_req]}};
+ {false, undefined} ->
+ spawn_starter(From, Appl, S, normal),
+ {noreply, S#state{starting = [{AppName, RestartType, normal, From} |
+ Starting],
+ start_req = [{AppName, From} | Start_req]}};
+ {false, {ok, Perms}} ->
+ case lists:member({AppName, false}, Perms) of
+ false ->
+ spawn_starter(From, Appl, S, normal),
+ {noreply, S#state{starting = [{AppName, RestartType, normal, From} |
+ Starting],
+ start_req = [{AppName, From} | Start_req]}};
+ true ->
+ SS = S#state{start_p_false = [{AppName, RestartType, normal, From} |
+ SPF]},
+ {reply, ok, SS}
+ end
+ end;
+ {error, R} ->
+ {reply, {error, R}, S}
+ end;
+ {value, {AppName, _FromX}} ->
+ SS = S#state{start_req = [{AppName, From} | Start_req]},
+ {noreply, SS}
+
+ end;
+
+handle_call({permit_application, AppName, Bool}, From, S) ->
+ Control = S#state.control,
+ Starting = S#state.starting,
+ SPF = S#state.start_p_false,
+ Started = S#state.started,
+ Running = S#state.running,
+ Start_req = S#state.start_req,
+ IsLoaded = get_loaded(AppName),
+ IsStarting = lists:keysearch(AppName, 1, Starting),
+ IsSPF = lists:keysearch(AppName, 1, SPF),
+ IsStarted = lists:keysearch(AppName, 1, Started),
+ IsRunning = lists:keysearch(AppName, 1, Running),
+
+ case lists:keymember(AppName, 1, Control) of
+ %%========================
+ %% distributed application
+ %%========================
+ true ->
+ case {IsLoaded, IsStarting, IsStarted} of
+ %% not loaded
+ {false, _, _} ->
+ {reply, {error, {not_loaded, AppName}}, S};
+ %% only loaded
+ {{true, _Appl}, false, false} ->
+ update_permissions(AppName, Bool),
+ {reply, {distributed_application, only_loaded}, S};
+ _ ->
+ update_permissions(AppName, Bool),
+ {reply, distributed_application, S}
+ end;
+ %%========================
+ %% local application
+ %%========================
+ false ->
+ case {Bool, IsLoaded, IsStarting, IsSPF, IsStarted, IsRunning} of
+ %%------------------------
+ %% permit the applicaition
+ %%------------------------
+ %% already running
+ {true, _, _, _, _, {value, _Tuple}} ->
+ {reply, ok, S};
+ %% not loaded
+ {true, false, _, _, _, _} ->
+ {reply, {error, {not_loaded, AppName}}, S};
+ %% only loaded
+ {true, {true, _Appl}, false, false, false, false} ->
+ update_permissions(AppName, Bool),
+ {reply, ok, S};
+ %% starting
+ {true, {true, _Appl}, {value, _Tuple}, false, false, false} ->
+ update_permissions(AppName, Bool),
+ {reply, ok, S}; %% check the permission after then app is started
+ %% start requested but not started because permit was false
+ {true, {true, Appl}, false, {value, Tuple}, false, false} ->
+ update_permissions(AppName, Bool),
+ {_AppName2, RestartType, normal, _From} = Tuple,
+ spawn_starter(From, Appl, S, normal),
+ SS = S#state{starting = [{AppName, RestartType, normal, From} | Starting],
+ start_p_false = keydelete(AppName, 1, SPF),
+ start_req = [{AppName, From} | Start_req]},
+ {noreply, SS};
+ %% started but not running
+ {true, {true, Appl}, _, _, {value, {AppName, RestartType}}, false} ->
+ update_permissions(AppName, Bool),
+ spawn_starter(From, Appl, S, normal),
+ SS = S#state{starting = [{AppName, RestartType, normal, From} | Starting],
+ started = keydelete(AppName, 1, Started),
+ start_req = [{AppName, From} | Start_req]},
+ {noreply, SS};
+
+ %%==========================
+ %% unpermit the applicaition
+ %%==========================
+ %% running
+ {false, _, _, _, _, {value, {_AppName, Id}}} ->
+ {value, {_AppName2, Type}} = keysearch(AppName, 1, Started),
+ stop_appl(AppName, Id, Type),
+ NRunning = keydelete(AppName, 1, Running),
+ {reply, ok, S#state{running = NRunning}};
+ %% not loaded
+ {false, false, _, _, _, _} ->
+ {reply, {error, {not_loaded, AppName}}, S};
+ %% only loaded
+ {false, {true, _Appl}, false, false, false, false} ->
+ update_permissions(AppName, Bool),
+ {reply, ok, S};
+ %% starting
+ {false, {true, _Appl}, {value, _Tuple}, false, false, false} ->
+ update_permissions(AppName, Bool),
+ {reply, ok, S};
+ %% start requested but not started because permit was false
+ {false, {true, _Appl}, false, {value, _Tuple}, false, false} ->
+ update_permissions(AppName, Bool),
+ SS = S#state{start_p_false = keydelete(AppName, 1, SPF)},
+ {reply, ok, SS};
+ %% started but not running
+ {false, {true, _Appl}, _, _, {value, _Tuple}, false} ->
+ update_permissions(AppName, Bool),
+ {reply, ok, S}
+
+ end
+ end;
+
+handle_call({stop_application, AppName}, _From, S) ->
+ #state{running = Running, started = Started} = S,
+ case keysearch(AppName, 1, Running) of
+ {value, {_AppName, Id}} ->
+ {value, {_AppName2, Type}} = keysearch(AppName, 1, Started),
+ stop_appl(AppName, Id, Type),
+ NRunning = keydelete(AppName, 1, Running),
+ NStarted = keydelete(AppName, 1, Started),
+ cntrl(AppName, S, {ac_application_stopped, AppName}),
+ {reply, ok, S#state{running = NRunning, started = NStarted}};
+ false ->
+ case lists:keymember(AppName, 1, Started) of
+ true ->
+ NStarted = keydelete(AppName, 1, Started),
+ cntrl(AppName, S, {ac_application_stopped, AppName}),
+ {reply, ok, S#state{started = NStarted}};
+ false ->
+ {reply, {error, {not_started, AppName}}, S}
+ end
+ end;
+
+handle_call({change_application_data, Applications, Config}, _From, S) ->
+ OldAppls = ets:filter(ac_tab,
+ fun([{{loaded, _AppName}, Appl}]) ->
+ {true, Appl};
+ (_) ->
+ false
+ end,
+ []),
+ case catch do_change_apps(Applications, Config, OldAppls) of
+ {error, R} ->
+ {reply, {error, R}, S};
+ {'EXIT', R} ->
+ {reply, {error, R}, S};
+ NewAppls ->
+ lists:foreach(fun(Appl) ->
+ ets:insert(ac_tab, {{loaded, Appl#appl.name},
+ Appl})
+ end, NewAppls),
+ {reply, ok, S#state{conf_data = Config}}
+ end;
+
+handle_call(prep_config_change, _From, S) ->
+ RunningApps = S#state.running,
+ EnvBefore = lists:reverse(do_prep_config_change(RunningApps)),
+ {reply, EnvBefore, S};
+
+handle_call({config_change, EnvBefore}, _From, S) ->
+ RunningApps = S#state.running,
+ R = do_config_change(RunningApps, EnvBefore),
+ {reply, R, S};
+
+handle_call(which_applications, _From, S) ->
+ Reply = zf(fun({Name, Id}) ->
+ case Id of
+ {distributed, _Node} ->
+ false;
+ _ ->
+ {true, #appl{descr = Descr, vsn = Vsn}} =
+ get_loaded(Name),
+ {true, {Name, Descr, Vsn}}
+ end
+ end, S#state.running),
+ {reply, Reply, S};
+
+handle_call({set_env, AppName, Key, Val}, _From, S) ->
+ ets:insert(ac_tab, {{env, AppName, Key}, Val}),
+ {reply, ok, S};
+
+handle_call({unset_env, AppName, Key}, _From, S) ->
+ ets:delete(ac_tab, {env, AppName, Key}),
+ {reply, ok, S};
+
+handle_call({control_application, AppName}, {Pid, _Tag}, S) ->
+ Control = S#state.control,
+ case lists:keymember(AppName, 1, Control) of
+ false ->
+ link(Pid),
+ {reply, true, S#state{control = [{AppName, Pid} | Control]}};
+ true ->
+ {reply, false, S}
+ end;
+
+handle_call({start_type, AppName}, _From, S) ->
+ Starting = S#state.starting,
+ StartType = case keysearch(AppName, 1, Starting) of
+ false ->
+ local;
+ {value, {_AppName, _RestartType, Type, _F}} ->
+ Type
+ end,
+ {reply, StartType, S};
+
+handle_call(info, _From, S) ->
+ Reply = [{loaded, loaded_applications()},
+ {loading, S#state.loading},
+ {started, S#state.started},
+ {start_p_false, S#state.start_p_false},
+ {running, S#state.running},
+ {starting, S#state.starting}],
+ {reply, Reply, S}.
+
+handle_cast({application_started, AppName, Res}, S) ->
+ handle_application_started(AppName, Res, S).
+
+handle_application_started(AppName, Res, S) ->
+ #state{starting = Starting, running = Running, started = Started,
+ start_req = Start_req} = S,
+ Start_reqN = reply_to_requester(AppName, Start_req, Res),
+ {value, {_AppName, RestartType, _Type, _From}} = keysearch(AppName, 1, Starting),
+ case Res of
+ {ok, Id} ->
+ case AppName of
+ kernel -> check_user();
+ _ -> ok
+ end,
+ info_started(AppName, nd(Id)),
+ notify_cntrl_started(AppName, Id, S, ok),
+ NRunning = keyreplaceadd(AppName, 1, Running,{AppName,Id}),
+ NStarted = keyreplaceadd(AppName, 1, Started,{AppName,RestartType}),
+ NewS = S#state{starting = keydelete(AppName, 1, Starting),
+ running = NRunning,
+ started = NStarted,
+ start_req = Start_reqN},
+
+ %% The permission may have been changed during start
+ Perm = application:get_env(kernel, permissions),
+ case {Perm, Id} of
+ {undefined, _} ->
+ {noreply, NewS};
+ %% Check only if the application is started on the own node
+ {{ok, Perms}, {distributed, StartNode}} when StartNode =:= node() ->
+ case lists:member({AppName, false}, Perms) of
+ true ->
+ #state{running = StopRunning, started = StopStarted} = NewS,
+ case keysearch(AppName, 1, StopRunning) of
+ {value, {_AppName, Id}} ->
+ {value, {_AppName2, Type}} =
+ keysearch(AppName, 1, StopStarted),
+ stop_appl(AppName, Id, Type),
+ NStopRunning = keydelete(AppName, 1, StopRunning),
+ cntrl(AppName, NewS, {ac_application_stopped, AppName}),
+ {noreply, NewS#state{running = NStopRunning,
+ started = StopStarted}};
+ false ->
+ {noreply, NewS}
+ end;
+ false ->
+ {noreply, NewS}
+ end;
+ _ ->
+ {noreply, NewS}
+ end;
+
+
+
+
+ {error, R} when RestartType =:= temporary ->
+ notify_cntrl_started(AppName, undefined, S, {error, R}),
+ info_exited(AppName, R, RestartType),
+ {noreply, S#state{starting = keydelete(AppName, 1, Starting),
+ start_req = Start_reqN}};
+ {info, R} when RestartType =:= temporary ->
+ notify_cntrl_started(AppName, undefined, S, {error, R}),
+ {noreply, S#state{starting = keydelete(AppName, 1, Starting),
+ start_req = Start_reqN}};
+ {ErrInf, R} when RestartType =:= transient, ErrInf =:= error;
+ RestartType =:= transient, ErrInf =:= info ->
+ notify_cntrl_started(AppName, undefined, S, {error, R}),
+ case ErrInf of
+ error ->
+ info_exited(AppName, R, RestartType);
+ info ->
+ ok
+ end,
+ case R of
+ {{'EXIT',normal},_Call} ->
+ {noreply, S#state{starting = keydelete(AppName, 1, Starting),
+ start_req = Start_reqN}};
+ _ ->
+ Reason = {application_start_failure, AppName, R},
+ {stop, to_string(Reason), S}
+ end;
+ {error, R} -> %% permanent
+ notify_cntrl_started(AppName, undefined, S, {error, R}),
+ info_exited(AppName, R, RestartType),
+ Reason = {application_start_failure, AppName, R},
+ {stop, to_string(Reason), S};
+ {info, R} -> %% permanent
+ notify_cntrl_started(AppName, undefined, S, {error, R}),
+ Reason = {application_start_failure, AppName, R},
+ {stop, to_string(Reason), S}
+ end.
+
+handle_info({ac_load_application_reply, AppName, Res}, S) ->
+ case keysearchdelete(AppName, 1, S#state.loading) of
+ {value, {_AppName, From}, Loading} ->
+ gen_server:reply(From, Res),
+ case Res of
+ ok ->
+ {noreply, S#state{loading = Loading}};
+ {error, _R} ->
+ NewS = unload(AppName, S),
+ {noreply, NewS#state{loading = Loading}}
+ end;
+ false ->
+ {noreply, S}
+ end;
+
+handle_info({ac_start_application_reply, AppName, Res}, S) ->
+ Start_req = S#state.start_req,
+ case keysearch(AppName, 1, Starting = S#state.starting) of
+ {value, {_AppName, RestartType, Type, From}} ->
+ case Res of
+ start_it ->
+ {true, Appl} = get_loaded(AppName),
+ spawn_starter(From, Appl, S, Type),
+ {noreply, S};
+ {started, Node} ->
+ handle_application_started(AppName,
+ {ok, {distributed, Node}},
+ S);
+ not_started ->
+ Started = S#state.started,
+ Start_reqN =
+ reply_to_requester(AppName, Start_req, ok),
+ {noreply,
+ S#state{starting = keydelete(AppName, 1, Starting),
+ started = [{AppName, RestartType} | Started],
+ start_req = Start_reqN}};
+ {takeover, Node} ->
+ {true, Appl} = get_loaded(AppName),
+ spawn_starter(From, Appl, S, {takeover, Node}),
+ NewStarting1 = keydelete(AppName, 1, Starting),
+ NewStarting = [{AppName, RestartType, {takeover, Node}, From} | NewStarting1],
+ {noreply, S#state{starting = NewStarting}};
+ {error, Reason} when RestartType =:= permanent ->
+ Start_reqN =
+ reply_to_requester(AppName, Start_req,
+ {error, Reason}),
+ {stop, to_string(Reason), S#state{start_req = Start_reqN}};
+ {error, Reason} ->
+ Start_reqN =
+ reply_to_requester(AppName, Start_req,
+ {error, Reason}),
+ {noreply, S#state{starting =
+ keydelete(AppName, 1, Starting),
+ start_req = Start_reqN}}
+ end;
+ false ->
+ {noreply, S} % someone called stop before control got that
+ end;
+
+handle_info({ac_change_application_req, AppName, Msg}, S) ->
+ Running = S#state.running,
+ Started = S#state.started,
+ Starting = S#state.starting,
+ case {keysearch(AppName, 1, Running), keysearch(AppName, 1, Started)} of
+ {{value, {AppName, Id}}, {value, {_AppName2, Type}}} ->
+ case Msg of
+ {started, Node} ->
+ stop_appl(AppName, Id, Type),
+ NRunning = [{AppName, {distributed, Node}} |
+ keydelete(AppName, 1, Running)],
+ {noreply, S#state{running = NRunning}};
+ {takeover, _Node, _RT} when is_pid(Id) -> % it is running already
+ notify_cntrl_started(AppName, Id, S, ok),
+ {noreply, S};
+ {takeover, Node, RT} ->
+ NewS = do_start(AppName, RT, {takeover, Node}, undefined, S),
+ {noreply, NewS};
+ {failover, _Node, _RT} when is_pid(Id) -> % it is running already
+ notify_cntrl_started(AppName, Id, S, ok),
+ {noreply, S};
+ {failover, Node, RT} ->
+ case application:get_key(AppName, start_phases) of
+ {ok, undefined} ->
+ %% to be backwards compatible the application
+ %% is not started as failover if start_phases
+ %% is not defined in the .app file
+ NewS = do_start(AppName, RT, normal, undefined, S),
+ {noreply, NewS};
+ {ok, _StartPhases} ->
+ NewS = do_start(AppName, RT, {failover, Node}, undefined, S),
+ {noreply, NewS}
+ end;
+ stop_it ->
+ stop_appl(AppName, Id, Type),
+ cntrl(AppName, S, {ac_application_not_run, AppName}),
+ NRunning = keyreplace(AppName, 1, Running,
+ {AppName, {distributed, []}}),
+ {noreply, S#state{running = NRunning}};
+ %% We should not try to start a running application!
+ start_it when is_pid(Id) ->
+ notify_cntrl_started(AppName, Id, S, ok),
+ {noreply, S};
+ start_it ->
+ NewS = do_start(AppName, undefined, normal, undefined, S),
+ {noreply, NewS};
+ not_running ->
+ NRunning = keydelete(AppName, 1, Running),
+ {noreply, S#state{running = NRunning}};
+ _ ->
+ {noreply, S}
+ end;
+ _ ->
+ IsLoaded = get_loaded(AppName),
+ IsStarting = lists:keysearch(AppName, 1, Starting),
+ IsStarted = lists:keysearch(AppName, 1, Started),
+ IsRunning = lists:keysearch(AppName, 1, Running),
+
+ case Msg of
+ start_it ->
+ case {IsLoaded, IsStarting, IsStarted, IsRunning} of
+ %% already running
+ {_, _, _, {value, _Tuple}} ->
+ {noreply, S};
+ %% not loaded
+ {false, _, _, _} ->
+ {noreply, S};
+ %% only loaded
+ {{true, _Appl}, false, false, false} ->
+ {noreply, S};
+ %% starting
+ {{true, _Appl}, {value, Tuple}, false, false} ->
+ {_AppName, _RStype, _Type, From} = Tuple,
+ NewS = do_start(AppName, undefined, normal, From, S),
+ {noreply, NewS};
+ %% started but not running
+ {{true, _Appl}, _, {value, {AppName, _RestartType}}, false} ->
+ NewS = do_start(AppName, undefined, normal, undefined, S),
+ SS = NewS#state{started = keydelete(AppName, 1, Started)},
+ {noreply, SS}
+ end;
+ {started, Node} ->
+ NRunning = [{AppName, {distributed, Node}} |
+ keydelete(AppName, 1, Running)],
+ {noreply, S#state{running = NRunning}};
+ _ ->
+ {noreply, S} % someone called stop before control got that
+ end
+ end;
+
+%%-----------------------------------------------------------------
+%% An application died. Check its restart_type. Maybe terminate
+%% all other applications.
+%%-----------------------------------------------------------------
+handle_info({'EXIT', Pid, Reason}, S) ->
+ ets:match_delete(ac_tab, {{application_master, '_'}, Pid}),
+ NRunning = keydelete(Pid, 2, S#state.running),
+ NewS = S#state{running = NRunning},
+ case keysearch(Pid, 2, S#state.running) of
+ {value, {AppName, _AmPid}} ->
+ cntrl(AppName, S, {ac_application_stopped, AppName}),
+ case keysearch(AppName, 1, S#state.started) of
+ {value, {_AppName, temporary}} ->
+ info_exited(AppName, Reason, temporary),
+ {noreply, NewS};
+ {value, {_AppName, transient}} when Reason =:= normal ->
+ info_exited(AppName, Reason, transient),
+ {noreply, NewS};
+ {value, {_AppName, Type}} ->
+ info_exited(AppName, Reason, Type),
+ {stop, to_string({application_terminated, AppName, Reason}), NewS}
+ end;
+ false ->
+ {noreply, S#state{control = del_cntrl(S#state.control, Pid)}}
+ end;
+
+handle_info(_, S) ->
+ {noreply, S}.
+
+terminate(Reason, S) ->
+ case application:get_env(kernel, shutdown_func) of
+ {ok, {M, F}} ->
+ catch M:F(Reason);
+ _ ->
+ ok
+ end,
+ foreach(fun({_AppName, Id}) when is_pid(Id) ->
+ exit(Id, shutdown),
+ receive
+ {'EXIT', Id, _} -> ok
+ end;
+ (_) -> ok
+ end,
+ S#state.running),
+ ets:delete(ac_tab).
+
+
+code_change(_OldVsn, State, _Extra) ->
+ {ok, State}.
+
+
+%%%-----------------------------------------------------------------
+%%% Internal functions
+%%%-----------------------------------------------------------------
+cntrl(AppName, #state{control = Control}, Msg) ->
+ case keysearch(AppName, 1, Control) of
+ {value, {_AppName, Pid}} ->
+ Pid ! Msg,
+ true;
+ false ->
+ false
+ end.
+
+notify_cntrl_started(_AppName, {distributed, _Node}, _S, _Res) ->
+ ok;
+notify_cntrl_started(AppName, _Id, S, Res) ->
+ cntrl(AppName, S, {ac_application_run, AppName, Res}).
+
+del_cntrl([{_, Pid}|T], Pid) ->
+ del_cntrl(T, Pid);
+del_cntrl([H|T], Pid) ->
+ [H|del_cntrl(T, Pid)];
+del_cntrl([], _Pid) ->
+ [].
+
+get_loaded(App) ->
+ AppName = get_appl_name(App),
+ case ets:lookup(ac_tab, {loaded, AppName}) of
+ [{_Key, Appl}] -> {true, Appl};
+ _ -> false
+ end.
+
+do_load_application(Application, S) ->
+ case get_loaded(Application) of
+ {true, _} ->
+ throw({error, {already_loaded, Application}});
+ false ->
+ case make_appl(Application) of
+ {ok, Appl} -> load(S, Appl);
+ Error -> Error
+ end
+ end.
+
+%% Recursively load the application and its included apps.
+%load(S, {ApplData, ApplEnv, IncApps, Descr, Vsn, Apps}) ->
+load(S, {ApplData, ApplEnv, IncApps, Descr, Id, Vsn, Apps}) ->
+ Name = ApplData#appl_data.name,
+ ConfEnv = get_env_i(Name, S),
+ NewEnv = merge_app_env(ApplEnv, ConfEnv),
+ CmdLineEnv = get_cmd_env(Name),
+ NewEnv2 = merge_app_env(NewEnv, CmdLineEnv),
+ NewEnv3 = keyreplaceadd(included_applications, 1, NewEnv2,
+ {included_applications, IncApps}),
+ add_env(Name, NewEnv3),
+ Appl = #appl{name = Name, descr = Descr, id = Id, vsn = Vsn,
+ appl_data = ApplData, inc_apps = IncApps, apps = Apps},
+ ets:insert(ac_tab, {{loaded, Name}, Appl}),
+ NewS =
+ foldl(fun(App, S1) ->
+ case get_loaded(App) of
+ {true, _} -> S1;
+ false ->
+ case do_load_application(App, S1) of
+ {ok, S2} -> S2;
+ Error -> throw(Error)
+ end
+ end
+ end, S, IncApps),
+ {ok, NewS}.
+
+unload(AppName, S) ->
+ {ok, IncApps} = get_env(AppName, included_applications),
+ del_env(AppName),
+ ets:delete(ac_tab, {loaded, AppName}),
+ foldl(fun(App, S1) ->
+ case get_loaded(App) of
+ false -> S1;
+ {true, _} -> unload(App, S1)
+ end
+ end, S, IncApps).
+
+check_start_cond(AppName, RestartType, Started, Running) ->
+ validRestartType(RestartType),
+ case get_loaded(AppName) of
+ {true, Appl} ->
+ %% Check Running; not Started. An exited app is not running,
+ %% but started. It must be possible to start an exited app!
+ case lists:keymember(AppName, 1, Running) of
+ true ->
+ {error, {already_started, AppName}};
+ false ->
+ foreach(
+ fun(AppName2) ->
+ case lists:keymember(AppName2, 1, Started) of
+ true -> ok;
+ false ->
+ throw({error, {not_started, AppName2}})
+ end
+ end, Appl#appl.apps),
+ {ok, Appl}
+ end;
+ false ->
+ {error, {not_loaded, AppName}}
+ end.
+
+do_start(AppName, RT, Type, From, S) ->
+ RestartType = case keysearch(AppName, 1, S#state.started) of
+ {value, {_AppName2, OldRT}} ->
+ get_restart_type(RT, OldRT);
+ false ->
+ RT
+ end,
+ %% UW 990913: We check start_req instead of starting, because starting
+ %% has already been checked.
+ case lists:keymember(AppName, 1, S#state.start_req) of
+ false ->
+ {true, Appl} = get_loaded(AppName),
+ Start_req = S#state.start_req,
+ spawn_starter(undefined, Appl, S, Type),
+ Starting = case keysearch(AppName, 1, S#state.starting) of
+ false ->
+ %% UW: don't know if this is necessary
+ [{AppName, RestartType, Type, From} |
+ S#state.starting];
+ _ ->
+ S#state.starting
+ end,
+ S#state{starting = Starting,
+ start_req = [{AppName, From} | Start_req]};
+ true -> % otherwise we're already starting the app...
+ S
+ end.
+
+spawn_starter(From, Appl, S, Type) ->
+ spawn_link(?MODULE, init_starter, [From, Appl, S, Type]).
+
+init_starter(_From, Appl, S, Type) ->
+ process_flag(trap_exit, true),
+ AppName = Appl#appl.name,
+ gen_server:cast(?AC, {application_started, AppName,
+ catch start_appl(Appl, S, Type)}).
+
+reply(undefined, _Reply) ->
+ ok;
+reply(From, Reply) -> gen_server:reply(From, Reply).
+
+start_appl(Appl, S, Type) ->
+ ApplData = Appl#appl.appl_data,
+ case ApplData#appl_data.mod of
+ [] ->
+ {ok, undefined};
+ _ ->
+ %% Name = ApplData#appl_data.name,
+ Running = S#state.running,
+ foreach(
+ fun(AppName) ->
+ case lists:keymember(AppName, 1, Running) of
+ true ->
+ ok;
+ false ->
+ throw({info, {not_running, AppName}})
+ end
+ end, Appl#appl.apps),
+ case application_master:start_link(ApplData, Type) of
+ {ok, Pid} ->
+ {ok, Pid};
+ {error, Reason} ->
+ throw({error, Reason})
+ end
+ end.
+
+
+%%-----------------------------------------------------------------
+%% Stop application locally.
+%%-----------------------------------------------------------------
+stop_appl(AppName, Id, Type) when is_pid(Id) ->
+ unlink(Id),
+ application_master:stop(Id),
+ info_exited(AppName, stopped, Type),
+ ets:delete(ac_tab, {application_master, AppName});
+stop_appl(AppName, undefined, Type) ->
+ %% Code-only application stopped
+ info_exited(AppName, stopped, Type);
+stop_appl(_AppName, _Id, _Type) ->
+ %% Distributed application stopped
+ ok.
+
+keysearchdelete(Key, Pos, List) ->
+ ksd(Key, Pos, List, []).
+
+ksd(Key, Pos, [H | T], Rest) when element(Pos, H) =:= Key ->
+ {value, H, Rest ++ T};
+ksd(Key, Pos, [H | T], Rest) ->
+ ksd(Key, Pos, T, [H | Rest]);
+ksd(_Key, _Pos, [], _Rest) ->
+ false.
+
+keyreplaceadd(Key, Pos, List, New) ->
+ %% Maintains the order!
+ case lists:keymember(Key, Pos, List) of
+ true -> keyreplace(Key, Pos, List, New);
+ false -> [New | List]
+ end.
+
+validRestartType(permanent) -> true;
+validRestartType(temporary) -> true;
+validRestartType(transient) -> true;
+validRestartType(RestartType) ->
+ throw({error, {invalid_restart_type, RestartType}}).
+
+nd({distributed, Node}) -> Node;
+nd(_) -> node().
+
+get_restart_type(undefined, OldRT) ->
+ OldRT;
+get_restart_type(RT, _OldRT) ->
+ RT.
+
+get_appl_name(Name) when is_atom(Name) -> Name;
+get_appl_name({application, Name, _}) when is_atom(Name) -> Name;
+get_appl_name(Appl) -> throw({error, {bad_application, Appl}}).
+
+make_appl(Name) when is_atom(Name) ->
+ FName = atom_to_list(Name) ++ ".app",
+ case code:where_is_file(FName) of
+ non_existing ->
+ {error, {file:format_error(enoent), FName}};
+ FullName ->
+ case prim_consult(FullName) of
+ {ok, [Application]} ->
+ {ok, make_appl_i(Application)};
+ {error, Reason} ->
+ {error, {file:format_error(Reason), FName}}
+ end
+ end;
+make_appl(Application) ->
+ {ok, make_appl_i(Application)}.
+
+prim_consult(FullName) ->
+ case erl_prim_loader:get_file(FullName) of
+ {ok, Bin, _} ->
+ case erl_scan:string(binary_to_list(Bin)) of
+ {ok, Tokens, _EndLine} ->
+ prim_parse(Tokens, []);
+ {error, Reason, _EndLine} ->
+ {error, Reason}
+ end;
+ error ->
+ {error, enoent}
+ end.
+
+prim_parse(Tokens, Acc) ->
+ case lists:splitwith(fun(T) -> element(1,T) =/= dot end, Tokens) of
+ {[], []} ->
+ {ok, lists:reverse(Acc)};
+ {Tokens2, [{dot,_} = Dot | Rest]} ->
+ case erl_parse:parse_term(Tokens2 ++ [Dot]) of
+ {ok, Term} ->
+ prim_parse(Rest, [Term | Acc]);
+ {error, Reason} ->
+ {error, Reason}
+ end;
+ {Tokens2, []} ->
+ case erl_parse:parse_term(Tokens2) of
+ {ok, Term} ->
+ {ok, lists:reverse([Term | Acc])};
+ {error, Reason} ->
+ {error, Reason}
+ end
+ end.
+
+make_appl_i({application, Name, Opts}) when is_atom(Name), is_list(Opts) ->
+ Descr = get_opt(description, Opts, ""),
+ Id = get_opt(id, Opts, ""),
+ Vsn = get_opt(vsn, Opts, ""),
+ Mods = get_opt(modules, Opts, []),
+ Regs = get_opt(registered, Opts, []),
+ Apps = get_opt(applications, Opts, []),
+ Mod =
+ case get_opt(mod, Opts, []) of
+ {M,A} when is_atom(M) -> {M,A};
+ [] -> [];
+ Other -> throw({error, {badstartspec, Other}})
+ end,
+ Phases = get_opt(start_phases, Opts, undefined),
+ Env = get_opt(env, Opts, []),
+ MaxP = get_opt(maxP, Opts, infinity),
+ MaxT = get_opt(maxT, Opts, infinity),
+ IncApps = get_opt(included_applications, Opts, []),
+ {#appl_data{name = Name, regs = Regs, mod = Mod, phases = Phases, mods = Mods,
+ inc_apps = IncApps, maxP = MaxP, maxT = MaxT},
+ Env, IncApps, Descr, Id, Vsn, Apps};
+make_appl_i({application, Name, Opts}) when is_list(Opts) ->
+ throw({error,{invalid_name,Name}});
+make_appl_i({application, _Name, Opts}) ->
+ throw({error,{invalid_options, Opts}});
+make_appl_i(Appl) -> throw({error, {bad_application, Appl}}).
+
+
+%%-----------------------------------------------------------------
+%% Merge current applications with changes.
+%%-----------------------------------------------------------------
+
+%% do_change_apps(Applications, Config, OldAppls) -> NewAppls
+%% Applications = [{application, AppName, [{Key,Value}]}]
+%% Config = [{AppName,[{Par,Value}]} | File]
+%% OldAppls = NewAppls = [#appl{}]
+do_change_apps(Applications, Config, OldAppls) ->
+
+ %% OTP-4867
+ %% Config = contents of sys.config file
+ %% May now contain names of other .config files as well as
+ %% configuration parameters.
+ %% Therefore read and merge contents.
+ {ok, SysConfig, Errors} = check_conf_sys(Config),
+
+ %% Report errors, but do not terminate
+ %% (backwards compatible behaviour)
+ lists:foreach(fun({error, {SysFName, Line, Str}}) ->
+ Str2 = lists:flatten(io_lib:format("~p: ~w: ~s~n",
+ [SysFName, Line, Str])),
+ error_logger:format(Str2, [])
+ end,
+ Errors),
+
+ map(fun(Appl) ->
+ AppName = Appl#appl.name,
+ case is_loaded_app(AppName, Applications) of
+ {true, Application} ->
+ do_change_appl(make_appl(Application),
+ Appl, SysConfig);
+
+ %% ignored removed apps - handled elsewhere
+ false ->
+ Appl
+ end
+ end, OldAppls).
+
+is_loaded_app(AppName, [{application, AppName, App} | _]) ->
+ {true, {application, AppName, App}};
+is_loaded_app(AppName, [_ | T]) -> is_loaded_app(AppName, T);
+is_loaded_app(_AppName, []) -> false.
+
+do_change_appl({ok, {ApplData, Env, IncApps, Descr, Id, Vsn, Apps}},
+ OldAppl, Config) ->
+ AppName = OldAppl#appl.name,
+
+ %% Merge application env with env from sys.config, if any
+ ConfEnv = get_opt(AppName, Config, []),
+ NewEnv1 = merge_app_env(Env, ConfEnv),
+
+ %% Merge application env with command line arguments, if any
+ CmdLineEnv = get_cmd_env(AppName),
+ NewEnv2 = merge_app_env(NewEnv1, CmdLineEnv),
+
+ %% included_apps is made into an env parameter as well
+ NewEnv3 = keyreplaceadd(included_applications, 1, NewEnv2,
+ {included_applications, IncApps}),
+
+ %% Update ets table with new application env
+ del_env(AppName),
+ add_env(AppName, NewEnv3),
+
+ OldAppl#appl{appl_data=ApplData,
+ descr=Descr,
+ id=Id,
+ vsn=Vsn,
+ inc_apps=IncApps,
+ apps=Apps};
+do_change_appl({error, R}, _Appl, _ConfData) ->
+ throw({error, R}).
+
+get_opt(Key, List, Default) ->
+ case keysearch(Key, 1, List) of
+ {value, {_Key, Val}} -> Val;
+ _ -> Default
+ end.
+
+get_cmd_env(Name) ->
+ case init:get_argument(Name) of
+ {ok, Args} ->
+ foldl(fun(List, Res) -> conv(List) ++ Res end, [], Args);
+ _ -> []
+ end.
+
+conv([Key, Val | T]) ->
+ [{make_term(Key), make_term(Val)} | conv(T)];
+conv(_) -> [].
+
+%%% Fix some day: eliminate the duplicated code here
+make_term(Str) ->
+ case erl_scan:string(Str) of
+ {ok, Tokens, _} ->
+ case erl_parse:parse_term(Tokens ++ [{dot, 1}]) of
+ {ok, Term} ->
+ Term;
+ {error, {_,M,Reason}} ->
+ error_logger:format("application_controller: ~s: ~s~n",
+ [M:format_error(Reason), Str]),
+ throw({error, {bad_environment_value, Str}})
+ end;
+ {error, {_,M,Reason}, _} ->
+ error_logger:format("application_controller: ~s: ~s~n",
+ [M:format_error(Reason), Str]),
+ throw({error, {bad_environment_value, Str}})
+ end.
+
+get_env_i(Name, #state{conf_data = ConfData}) when is_list(ConfData) ->
+ case keysearch(Name, 1, ConfData) of
+ {value, {_Name, Env}} -> Env;
+ _ -> []
+ end;
+get_env_i(_Name, _) -> [].
+
+%% Merges envs for all apps. Env2 overrides Env1
+merge_env(Env1, Env2) ->
+ merge_env(Env1, Env2, []).
+
+merge_env([{App, AppEnv1} | T], Env2, Res) ->
+ case get_env_key(App, Env2) of
+ {value, AppEnv2, RestEnv2} ->
+ NewAppEnv = merge_app_env(AppEnv1, AppEnv2),
+ merge_env(T, RestEnv2, [{App, NewAppEnv} | Res]);
+ _ ->
+ merge_env(T, Env2, [{App, AppEnv1} | Res])
+ end;
+merge_env([], Env2, Res) ->
+ Env2 ++ Res.
+
+
+
+
+%% Merges envs for an application. Env2 overrides Env1
+merge_app_env(Env1, Env2) ->
+ merge_app_env(Env1, Env2, []).
+
+merge_app_env([{Key, Val} | T], Env2, Res) ->
+ case get_env_key(Key, Env2) of
+ {value, NewVal, RestEnv} ->
+ merge_app_env(T, RestEnv, [{Key, NewVal}|Res]);
+ _ ->
+ merge_app_env(T, Env2, [{Key, Val} | Res])
+ end;
+merge_app_env([], Env2, Res) ->
+ Env2 ++ Res.
+
+get_env_key(Key, Env) -> get_env_key(Env, Key, []).
+get_env_key([{Key, Val} | T], Key, Res) ->
+ {value, Val, T ++ Res};
+get_env_key([H | T], Key, Res) ->
+ get_env_key(T, Key, [H | Res]);
+get_env_key([], _Key, Res) -> Res.
+
+add_env(Name, Env) ->
+ foreach(fun({Key, Value}) ->
+ ets:insert(ac_tab, {{env, Name, Key}, Value})
+ end,
+ Env).
+
+del_env(Name) ->
+ ets:match_delete(ac_tab, {{env, Name, '_'}, '_'}).
+
+check_user() ->
+ case whereis(user) of
+ User when is_pid(User) -> group_leader(User, self());
+ _ -> ok
+ end.
+
+
+%%-----------------------------------------------------------------
+%% Prepare for a release upgrade by reading all the evironment variables.
+%%-----------------------------------------------------------------
+do_prep_config_change(Apps) ->
+ do_prep_config_change(Apps, []).
+
+do_prep_config_change([], EnvBefore) ->
+ EnvBefore;
+do_prep_config_change([{App, _Id} | Apps], EnvBefore) ->
+ Env = application:get_all_env(App),
+ do_prep_config_change(Apps, [{App, Env} | EnvBefore]).
+
+
+
+%%-----------------------------------------------------------------
+%% Inform all running applications about the changed configuration.
+%%-----------------------------------------------------------------
+do_config_change(Apps, EnvBefore) ->
+ do_config_change(Apps, EnvBefore, []).
+
+do_config_change([], _EnvBefore, []) ->
+ ok;
+do_config_change([], _EnvBefore, Errors) ->
+ {error, Errors};
+do_config_change([{App, _Id} | Apps], EnvBefore, Errors) ->
+ AppEnvNow = lists:sort(application:get_all_env(App)),
+ AppEnvBefore = case lists:keysearch(App, 1, EnvBefore) of
+ false ->
+ [];
+ {value, {App, AppEnvBeforeT}} ->
+ lists:sort(AppEnvBeforeT)
+ end,
+
+ Res =
+ case AppEnvNow of
+ AppEnvBefore ->
+ ok;
+ _ ->
+ case do_config_diff(AppEnvNow, AppEnvBefore) of
+ {[], [], []} ->
+ ok;
+ {Changed, New, Removed} ->
+ case application:get_key(App, mod) of
+ {ok, {Mod, _Para}} ->
+ case catch Mod:config_change(Changed, New,
+ Removed) of
+ ok ->
+ ok;
+ %% It is not considered as an error
+ %% if the cb-function is not defined
+ {'EXIT', {undef, _}} ->
+ ok;
+ {error, Error} ->
+ {error, Error};
+ Else ->
+ {error, Else}
+ end;
+ {ok,[]} ->
+ {error, {module_not_defined, App}};
+ undefined ->
+ {error, {application_not_found, App}}
+ end
+ end
+ end,
+
+ case Res of
+ ok ->
+ do_config_change(Apps, EnvBefore, Errors);
+ {error, NewError} ->
+ do_config_change(Apps, EnvBefore,[NewError | Errors])
+ end.
+
+
+
+
+%%-----------------------------------------------------------------
+%% Check if the configuration is changed in anyway.
+%%-----------------------------------------------------------------
+do_config_diff(AppEnvNow, AppEnvBefore) ->
+ do_config_diff(AppEnvNow, AppEnvBefore, {[], []}).
+
+do_config_diff([], AppEnvBefore, {Changed, New}) ->
+ Removed = lists:foldl(fun({Env, _Value}, Acc) -> [Env | Acc] end, [], AppEnvBefore),
+ {Changed, New, Removed};
+do_config_diff(AppEnvNow, [], {Changed, New}) ->
+ {Changed, AppEnvNow++New, []};
+do_config_diff([{Env, Value} | AppEnvNow], AppEnvBefore, {Changed, New}) ->
+ case lists:keysearch(Env, 1, AppEnvBefore) of
+ {value, {Env, Value}} ->
+ do_config_diff(AppEnvNow, lists:keydelete(Env,1,AppEnvBefore), {Changed, New});
+ {value, {Env, _OtherValue}} ->
+ do_config_diff(AppEnvNow, lists:keydelete(Env,1,AppEnvBefore),
+ {[{Env, Value} | Changed], New});
+ false ->
+ do_config_diff(AppEnvNow, AppEnvBefore, {Changed, [{Env, Value}|New]})
+ end.
+
+
+
+
+
+
+%%-----------------------------------------------------------------
+%% Read the .config files.
+%%-----------------------------------------------------------------
+check_conf() ->
+ case init:get_argument(config) of
+ {ok, Files} ->
+ {ok, lists:foldl(
+ fun([File], Env) ->
+ BFName = filename:basename(File,".config"),
+ FName = filename:join(filename:dirname(File),
+ BFName ++ ".config"),
+ case load_file(FName) of
+ {ok, NewEnv} ->
+ %% OTP-4867
+ %% sys.config may now contain names of
+ %% other .config files as well as
+ %% configuration parameters.
+ %% Therefore read and merge contents.
+ if
+ BFName =:= "sys" ->
+ {ok, SysEnv, Errors} =
+ check_conf_sys(NewEnv),
+
+ %% Report first error, if any, and
+ %% terminate
+ %% (backwards compatible behaviour)
+ case Errors of
+ [] ->
+ merge_env(Env, SysEnv);
+ [{error, {SysFName, Line, Str}}|_] ->
+ throw({error, {SysFName, Line, Str}})
+ end;
+ true ->
+ merge_env(Env, NewEnv)
+ end;
+ {error, {Line, _Mod, Str}} ->
+ throw({error, {FName, Line, Str}})
+ end
+ end, [], Files)};
+ _ -> {ok, []}
+ end.
+
+check_conf_sys(Env) ->
+ check_conf_sys(Env, [], []).
+
+check_conf_sys([File|T], SysEnv, Errors) when is_list(File) ->
+ BFName = filename:basename(File, ".config"),
+ FName = filename:join(filename:dirname(File), BFName ++ ".config"),
+ case load_file(FName) of
+ {ok, NewEnv} ->
+ check_conf_sys(T, merge_env(SysEnv, NewEnv), Errors);
+ {error, {Line, _Mod, Str}} ->
+ check_conf_sys(T, SysEnv, [{error, {FName, Line, Str}}|Errors])
+ end;
+check_conf_sys([Tuple|T], SysEnv, Errors) ->
+ check_conf_sys(T, merge_env(SysEnv, [Tuple]), Errors);
+check_conf_sys([], SysEnv, Errors) ->
+ {ok, SysEnv, lists:reverse(Errors)}.
+
+load_file(File) ->
+ %% We can't use file:consult/1 here. Too bad.
+ case erl_prim_loader:get_file(File) of
+ {ok, Bin, _FileName} ->
+ %% Make sure that there is some whitespace at the end of the string
+ %% (so that reading a file with no NL following the "." will work).
+ Str = binary_to_list(Bin) ++ " ",
+ scan_file(Str);
+ error ->
+ {error, {none, open_file, "configuration file not found"}}
+ end.
+
+scan_file(Str) ->
+ case erl_scan:tokens([], Str, 1) of
+ {done, {ok, Tokens, _}, Left} ->
+ case erl_parse:parse_term(Tokens) of
+ {ok,L}=Res when is_list(L) ->
+ case only_ws(Left) of
+ true ->
+ Res;
+ false ->
+ %% There was trailing garbage found after the list.
+ config_error()
+ end;
+ {ok,_} ->
+ %% Parsing succeeded but the result is not a list.
+ config_error();
+ Error ->
+ Error
+ end;
+ {done, Result, _} ->
+ {error, {none, parse_file, tuple_to_list(Result)}};
+ {more, _} ->
+ {error, {none, load_file, "no ending <dot> found"}}
+ end.
+
+only_ws([C|Cs]) when C =< $\s -> only_ws(Cs);
+only_ws([$%|Cs]) -> only_ws(strip_comment(Cs)); % handle comment
+only_ws([_|_]) -> false;
+only_ws([]) -> true.
+
+strip_comment([$\n|Cs]) -> Cs;
+strip_comment([_|Cs]) -> strip_comment(Cs);
+strip_comment([]) -> [].
+
+config_error() ->
+ {error,
+ {none, load_file,
+ "configuration file must contain ONE list ended by <dot>"}}.
+
+%%-----------------------------------------------------------------
+%% Info messages sent to error_logger
+%%-----------------------------------------------------------------
+info_started(Name, Node) ->
+ Rep = [{application, Name},
+ {started_at, Node}],
+ error_logger:info_report(progress, Rep).
+
+info_exited(Name, Reason, Type) ->
+ Rep = [{application, Name},
+ {exited, Reason},
+ {type, Type}],
+ error_logger:info_report(Rep).
+
+
+%%-----------------------------------------------------------------
+%% Reply to all processes waiting this application to be started.
+%%-----------------------------------------------------------------
+reply_to_requester(AppName, Start_req, Res) ->
+ R = case Res of
+ {ok, _Id} ->
+ ok;
+ {info, Reason} ->
+ {error, Reason};
+ Error ->
+ Error
+ end,
+
+ lists:foldl(fun(Sp, AccIn) ->
+ case Sp of
+ {AppName, From} ->
+ reply(From, R),
+ AccIn;
+ _ ->
+ [Sp | AccIn]
+ end
+ end,
+ [],
+ Start_req).
+
+
+%%-----------------------------------------------------------------
+%% Update the environment variable permission for an application.
+%%-----------------------------------------------------------------
+update_permissions(AppName, Bool) ->
+ case ets:lookup(ac_tab, {env, kernel, permissions}) of
+ [] ->
+ ets:insert(ac_tab, {{env, kernel, permissions},
+ [{AppName, Bool}]});
+ [{_, Perm}] ->
+ Perm2 = lists:keydelete(AppName, 1, Perm),
+ ets:insert(ac_tab, {{env, kernel, permissions},
+ [{AppName, Bool}| Perm2]})
+ end.
+
+%%-----------------------------------------------------------------
+%% These functions are only to be used from testsuites.
+%%-----------------------------------------------------------------
+test_change_apps(Apps, Conf) ->
+ Res = test_make_apps(Apps, []),
+ test_do_change_appl(Apps, Conf, Res).
+
+test_do_change_appl([], _, _) ->
+ ok;
+test_do_change_appl([A|Apps], [], [R|Res]) ->
+ do_change_appl(R, #appl{name = A}, []),
+ test_do_change_appl(Apps, [], Res);
+test_do_change_appl([A|Apps], [C|Conf], [R|Res]) ->
+ do_change_appl(R, #appl{name = A}, C),
+ test_do_change_appl(Apps, Conf, Res).
+
+test_make_apps([], Res) ->
+ lists:reverse(Res);
+test_make_apps([A|Apps], Res) ->
+ test_make_apps(Apps, [make_appl(A) | Res]).
+
+%%-----------------------------------------------------------------
+%% String conversion
+%% Exit reason needs to be a printable string
+%% (and of length <200, but init now does the chopping).
+%%-----------------------------------------------------------------
+to_string(Term) ->
+ case io_lib:printable_list(Term) of
+ true ->
+ Term;
+ false ->
+ lists:flatten(io_lib:write(Term))
+ end.