298 lines
8.7 KiB
Erlang
298 lines
8.7 KiB
Erlang
%%%----------------------------------------------------------------------
|
|
%%% File : gen_mod.erl
|
|
%%% Author : Alexey Shchepin <alexey@process-one.net>
|
|
%%% Purpose :
|
|
%%% Created : 24 Jan 2003 by Alexey Shchepin <alexey@process-one.net>
|
|
%%%
|
|
%%%
|
|
%%% ejabberd, Copyright (C) 2002-2012 ProcessOne
|
|
%%%
|
|
%%% This program is free software; you can redistribute it and/or
|
|
%%% modify it under the terms of the GNU General Public License as
|
|
%%% published by the Free Software Foundation; either version 2 of the
|
|
%%% License, or (at your option) any later version.
|
|
%%%
|
|
%%% This program is distributed in the hope that it will be useful,
|
|
%%% but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
%%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
%%% General Public License for more details.
|
|
%%%
|
|
%%% You should have received a copy of the GNU General Public License
|
|
%%% along with this program; if not, write to the Free Software
|
|
%%% Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
|
%%% 02111-1307 USA
|
|
%%%
|
|
%%%----------------------------------------------------------------------
|
|
|
|
-module(gen_mod).
|
|
-author('alexey@process-one.net').
|
|
|
|
-export([start/0,
|
|
start_module/3,
|
|
stop_module/2,
|
|
stop_module_keep_config/2,
|
|
get_opt/2,
|
|
get_opt/3,
|
|
get_opt_host/3,
|
|
get_module_opt/4,
|
|
get_module_opt_host/3,
|
|
loaded_modules/1,
|
|
loaded_modules_with_opts/1,
|
|
get_hosts/2,
|
|
get_module_proc/2,
|
|
get_module_proc_existing/2,
|
|
is_loaded/2]).
|
|
|
|
-export([behaviour_info/1]).
|
|
|
|
-include("ejabberd.hrl").
|
|
|
|
-record(ejabberd_module, {module_host, opts}).
|
|
%% module_host = {Module::atom(), Host::string()}
|
|
|
|
behaviour_info(callbacks) ->
|
|
[{start, 2},
|
|
{stop, 1}];
|
|
behaviour_info(_Other) ->
|
|
undefined.
|
|
|
|
start() ->
|
|
ets:new(ejabberd_modules, [named_table,
|
|
public,
|
|
{keypos, #ejabberd_module.module_host}]),
|
|
ok.
|
|
|
|
|
|
start_module(Host, Module, Opts) ->
|
|
MTokens = string:tokens(atom_to_list(Module), "_"),
|
|
case lists:split(length(MTokens) - 1, MTokens) of
|
|
{ModulePlainList, ["odbc"]} ->
|
|
Module2 = list_to_atom(string:join(ModulePlainList, "_")),
|
|
?WARNING_MSG("The module ~p is obsolete. Replace it with ~p and "
|
|
"add the option {backend, odbc}",
|
|
[Module, Module2]),
|
|
start_module2(Host, Module2, [{backend, odbc} | Opts]);
|
|
_ ->
|
|
start_module2(Host, Module, Opts)
|
|
end.
|
|
|
|
start_module2(Host, Module, Opts) ->
|
|
set_module_opts_mnesia(Host, Module, Opts),
|
|
ets:insert(ejabberd_modules,
|
|
#ejabberd_module{module_host = {Module, Host},
|
|
opts = Opts}),
|
|
try Module:start(Host, Opts)
|
|
catch Class:Reason ->
|
|
del_module_mnesia(Host, Module),
|
|
ets:delete(ejabberd_modules, {Module, Host}),
|
|
ErrorText = io_lib:format("Problem starting the module ~p for host ~p ~n options: ~p~n ~p: ~p~n stacktarce: ~p",
|
|
[Module, Host, Opts, Class, Reason, erlang:get_stacktrace()]),
|
|
?CRITICAL_MSG(ErrorText, []),
|
|
case is_app_running(ejabberd) of
|
|
true ->
|
|
erlang:raise(Class, Reason, erlang:get_stacktrace());
|
|
false ->
|
|
?CRITICAL_MSG("ejabberd initialization was aborted because a module start failed.", []),
|
|
timer:sleep(3000),
|
|
erlang:halt(string:substr(lists:flatten(ErrorText), 1, 199))
|
|
end
|
|
end.
|
|
|
|
is_app_running(AppName) ->
|
|
%% Use a high timeout to prevent a false positive in a high load system
|
|
Timeout = 15000,
|
|
lists:keymember(AppName, 1, application:which_applications(Timeout)).
|
|
|
|
%% @doc Stop the module in a host, and forget its configuration.
|
|
stop_module(Host, Module) ->
|
|
case stop_module_keep_config(Host, Module) of
|
|
error ->
|
|
error;
|
|
ok ->
|
|
del_module_mnesia(Host, Module)
|
|
end.
|
|
|
|
%% @doc Stop the module in a host, but keep its configuration.
|
|
%% As the module configuration is kept in the Mnesia local_config table,
|
|
%% when ejabberd is restarted the module will be started again.
|
|
%% This function is useful when ejabberd is being stopped
|
|
%% and it stops all modules.
|
|
stop_module_keep_config(Host, Module) ->
|
|
case catch Module:stop(Host) of
|
|
{'EXIT', Reason} ->
|
|
?ERROR_MSG("~p", [Reason]),
|
|
error;
|
|
{wait, ProcList} when is_list(ProcList) ->
|
|
lists:foreach(fun wait_for_process/1, ProcList),
|
|
ets:delete(ejabberd_modules, {Module, Host}),
|
|
ok;
|
|
{wait, Process} ->
|
|
wait_for_process(Process),
|
|
ets:delete(ejabberd_modules, {Module, Host}),
|
|
ok;
|
|
_ ->
|
|
ets:delete(ejabberd_modules, {Module, Host}),
|
|
ok
|
|
end.
|
|
|
|
wait_for_process(Process) ->
|
|
MonitorReference = erlang:monitor(process, Process),
|
|
wait_for_stop(Process, MonitorReference).
|
|
|
|
wait_for_stop(Process, MonitorReference) ->
|
|
receive
|
|
{'DOWN', MonitorReference, _Type, _Object, _Info} ->
|
|
ok
|
|
after 5000 ->
|
|
catch exit(whereis(Process), kill),
|
|
wait_for_stop1(MonitorReference)
|
|
end.
|
|
|
|
wait_for_stop1(MonitorReference) ->
|
|
receive
|
|
{'DOWN', MonitorReference, _Type, _Object, _Info} ->
|
|
ok
|
|
after 5000 ->
|
|
ok
|
|
end.
|
|
|
|
get_opt(Opt, Opts) ->
|
|
case lists:keysearch(Opt, 1, Opts) of
|
|
false ->
|
|
% TODO: replace with more appropriate function
|
|
throw({undefined_option, Opt});
|
|
{value, {_, Val}} ->
|
|
Val
|
|
end.
|
|
|
|
get_opt(Opt, Opts, Default) ->
|
|
case lists:keysearch(Opt, 1, Opts) of
|
|
false ->
|
|
Default;
|
|
{value, {_, Val}} ->
|
|
Val
|
|
end.
|
|
|
|
get_module_opt(global, Module, Opt, Default) ->
|
|
Hosts = ?MYHOSTS,
|
|
[Value | Values] = lists:map(
|
|
fun(Host) ->
|
|
get_module_opt(Host, Module, Opt, Default)
|
|
end,
|
|
Hosts),
|
|
Same_all = lists:all(
|
|
fun(Other_value) ->
|
|
Other_value == Value
|
|
end,
|
|
Values),
|
|
case Same_all of
|
|
true -> Value;
|
|
false -> Default
|
|
end;
|
|
|
|
get_module_opt(Host, Module, Opt, Default) ->
|
|
OptsList = ets:lookup(ejabberd_modules, {Module, Host}),
|
|
case OptsList of
|
|
[] ->
|
|
OptsList2 = ets:lookup(ejabberd_modules, {Module, global}),
|
|
case OptsList2 of
|
|
[] ->
|
|
Default;
|
|
[#ejabberd_module{opts = Opts} | _] ->
|
|
get_opt(Opt, Opts, Default)
|
|
end;
|
|
[#ejabberd_module{opts = Opts} | _] ->
|
|
get_opt(Opt, Opts, Default)
|
|
end.
|
|
|
|
get_module_opt_host(Host, Module, Default) ->
|
|
Val = get_module_opt(Host, Module, host, Default),
|
|
re:replace(Val, "@HOST@", Host, [global,{return,list}]).
|
|
|
|
get_opt_host(Host, Opts, Default) ->
|
|
case Host of
|
|
global ->
|
|
Val = get_opt(host, Opts, Default),
|
|
{global, re:replace(Val, ".@HOST@", "", [global,{return,list}])};
|
|
Host ->
|
|
Val = get_opt(host, Opts, Default),
|
|
re:replace(Val, "@HOST@", Host, [global,{return,list}])
|
|
end.
|
|
|
|
loaded_modules(Host) ->
|
|
ets:select(ejabberd_modules,
|
|
[{#ejabberd_module{_ = '_', module_host = {'$1', Host}},
|
|
[],
|
|
['$1']}]).
|
|
|
|
loaded_modules_with_opts(Host) ->
|
|
ets:select(ejabberd_modules,
|
|
[{#ejabberd_module{_ = '_', module_host = {'$1', Host},
|
|
opts = '$2'},
|
|
[],
|
|
[{{'$1', '$2'}}]}]).
|
|
|
|
set_module_opts_mnesia(global, _Module, _Opts) ->
|
|
%% Modules on the global host are usually static, so we shouldn't manipulate them.
|
|
ok;
|
|
set_module_opts_mnesia(Host, Module, Opts) ->
|
|
Modules = case ejabberd_config:get_local_option({modules, Host}) of
|
|
undefined ->
|
|
[];
|
|
Ls ->
|
|
Ls
|
|
end,
|
|
Modules1 = lists:keydelete(Module, 1, Modules),
|
|
Modules2 = [{Module, Opts} | Modules1],
|
|
ejabberd_config:add_local_option({modules, Host}, Modules2).
|
|
|
|
del_module_mnesia(global, _Module) ->
|
|
%% Modules on the global host are usually static, so we shouldn't manipulate them.
|
|
ok;
|
|
del_module_mnesia(Host, Module) ->
|
|
Modules = case ejabberd_config:get_local_option({modules, Host}) of
|
|
undefined ->
|
|
[];
|
|
Ls ->
|
|
Ls
|
|
end,
|
|
Modules1 = lists:keydelete(Module, 1, Modules),
|
|
ejabberd_config:add_local_option({modules, Host}, Modules1).
|
|
|
|
get_hosts(Opts, Prefix) ->
|
|
case catch gen_mod:get_opt(hosts, Opts) of
|
|
{'EXIT', _Error1} ->
|
|
case catch gen_mod:get_opt(host, Opts) of
|
|
{'EXIT', _Error2} ->
|
|
[Prefix ++ Host || Host <- ?MYHOSTS];
|
|
Host ->
|
|
[Host]
|
|
end;
|
|
Hosts ->
|
|
Hosts
|
|
end.
|
|
|
|
get_module_proc_existing(Host, Base) ->
|
|
Proc = get_module_proc(Host, Base),
|
|
%% If the process doesn't exist for Host, it may exist for global
|
|
case {whereis(Proc), Host == global} of
|
|
{undefined, false} -> get_module_proc(global, Base);
|
|
{undefined, true} -> not_existing;
|
|
{_, _} -> Proc
|
|
end.
|
|
|
|
get_module_proc(Host, Base) when is_binary(Host) ->
|
|
get_module_proc(binary_to_list(Host), Base);
|
|
get_module_proc(global, Base) ->
|
|
list_to_atom(atom_to_list(Base) ++ "__global");
|
|
get_module_proc(Host, {frontend, Base}) ->
|
|
get_module_proc("frontend_" ++ Host, Base);
|
|
get_module_proc(Host, Base) ->
|
|
list_to_atom(atom_to_list(Base) ++ "_" ++ Host).
|
|
|
|
%% @spec(Host::string() | global, Module::atom()) -> true | false
|
|
%% @doc Check if the module is loaded in this host (or global), or not.
|
|
is_loaded(Host, Module) ->
|
|
ets:member(ejabberd_modules, {Module, Host})
|
|
orelse ets:member(ejabberd_modules, {Module, global}).
|