X-Git-Url: https://git.enpas.org/?a=blobdiff_plain;f=core%2Fmodulemanager.lua;h=535c227b13e908d25ad9346c78c7f63c9ac0c85a;hb=b85f75e110d99b890fc22186cb2ad4d0c8f1d0a5;hp=3ad02b30e047f8529751d249d997b32029a020f6;hpb=46457e4e4266ade57b0d8e2744e5b190e636e0a8;p=prosody.git

diff --git a/core/modulemanager.lua b/core/modulemanager.lua
index 3ad02b30..535c227b 100644
--- a/core/modulemanager.lua
+++ b/core/modulemanager.lua
@@ -6,211 +6,202 @@
 -- COPYING file in the source package for more information.
 --
 
-local plugin_dir = CFG_PLUGINDIR or "./plugins/";
-
 local logger = require "util.logger";
 local log = logger.init("modulemanager");
-local eventmanager = require "core.eventmanager";
 local config = require "core.configmanager";
-local multitable_new = require "util.multitable".new;
-local register_actions = require "core.actions".register;
-local st = require "util.stanza";
 local pluginloader = require "util.pluginloader";
+local set = require "util.set";
+
+local new_multitable = require "util.multitable".new;
 
 local hosts = hosts;
 local prosody = prosody;
 
-local loadfile, pcall = loadfile, pcall;
-local setmetatable, setfenv, getfenv = setmetatable, setfenv, getfenv;
-local pairs, ipairs = pairs, ipairs;
-local t_insert, t_concat = table.insert, table.concat;
-local type = type;
-local next = next;
-local rawget = rawget;
-local error = error;
-local tostring = tostring;
+local pcall, xpcall = pcall, xpcall;
+local setmetatable, rawget = setmetatable, rawget;
+local ipairs, pairs, type, tostring, t_insert = ipairs, pairs, type, tostring, table.insert;
+
+local debug_traceback = debug.traceback;
+local unpack, select = unpack, select;
+pcall = function(f, ...)
+	local n = select("#", ...);
+	local params = {...};
+	return xpcall(function() return f(unpack(params, 1, n)) end, function(e) return tostring(e).."\n"..debug_traceback(); end);
+end
 
-local autoload_modules = {"presence", "message", "iq"};
+local autoload_modules = {"presence", "message", "iq", "offline", "c2s", "s2s"};
+local component_inheritable_modules = {"tls", "dialback", "iq", "s2s"};
 
 -- We need this to let modules access the real global namespace
 local _G = _G;
 
 module "modulemanager"
 
-api = {};
-local api = api; -- Module API container
+local api = _G.require "core.moduleapi"; -- Module API container
 
+-- [host] = { [module] = module_env }
 local modulemap = { ["*"] = {} };
 
-local stanza_handlers = multitable_new();
-local handler_info = {};
-
-local modulehelpers = setmetatable({}, { __index = _G });
-
-local handler_table = multitable_new();
-local hooked = multitable_new();
-local hooks = multitable_new();
-local event_hooks = multitable_new();
-
-local NULL = {};
-
 -- Load modules when a host is activated
 function load_modules_for_host(host)
-	local disabled_set = {};
-	local modules_disabled = config.get(host, "core", "modules_disabled");
-	if modules_disabled then
-		for _, module in ipairs(modules_disabled) do
-			disabled_set[module] = true;
-		end
+	local component = config.get(host, "component_module");
+	
+	local global_modules_enabled = config.get("*", "modules_enabled");
+	local global_modules_disabled = config.get("*", "modules_disabled");
+	local host_modules_enabled = config.get(host, "modules_enabled");
+	local host_modules_disabled = config.get(host, "modules_disabled");
+	
+	if host_modules_enabled == global_modules_enabled then host_modules_enabled = nil; end
+	if host_modules_disabled == global_modules_disabled then host_modules_disabled = nil; end
+	
+	local global_modules = set.new(autoload_modules) + set.new(global_modules_enabled) - set.new(global_modules_disabled);
+	if component then
+		global_modules = set.intersection(set.new(component_inheritable_modules), global_modules);
 	end
-
-	-- Load auto-loaded modules for this host
-	if hosts[host].type == "local" then
-		for _, module in ipairs(autoload_modules) do
-			if not disabled_set[module] then
-				load(host, module);
-			end
-		end
+	local modules = (global_modules + set.new(host_modules_enabled)) - set.new(host_modules_disabled);
+	
+	-- COMPAT w/ pre 0.8
+	if modules:contains("console") then
+		log("error", "The mod_console plugin has been renamed to mod_admin_telnet. Please update your config.");
+		modules:remove("console");
+		modules:add("admin_telnet");
 	end
+	
+	if component then
+		load(host, component);
+	end
+	for module in modules do
+		load(host, module);
+	end
+end
+prosody.events.add_handler("host-activated", load_modules_for_host);
+prosody.events.add_handler("host-deactivated", function (host)
+	modulemap[host] = nil;
+end);
 
-	-- Load modules from global section
-	if config.get(host, "core", "load_global_modules") ~= false then
-		local modules_enabled = config.get("*", "core", "modules_enabled");
-		if modules_enabled then
-			for _, module in ipairs(modules_enabled) do
-				if not disabled_set[module] and not is_loaded(host, module) then
-					load(host, module);
-				end
-			end
+--- Private helpers ---
+
+local function do_unload_module(host, name)
+	local mod = get_module(host, name);
+	if not mod then return nil, "module-not-loaded"; end
+	
+	if module_has_method(mod, "unload") then
+		local ok, err = call_module_method(mod, "unload");
+		if (not ok) and err then
+			log("warn", "Non-fatal error unloading module '%s' on '%s': %s", name, host, err);
 		end
 	end
 	
-	-- Load modules from just this host
-	local modules_enabled = config.get(host, "core", "modules_enabled");
-	if modules_enabled and modules_enabled ~= config.get("*", "core", "modules_enabled") then
-		for _, module in pairs(modules_enabled) do
-			if not is_loaded(host, module) then
-				load(host, module);
+	for object, event, handler in mod.module.event_handlers:iter(nil, nil, nil) do
+		object.remove_handler(event, handler);
+	end
+	
+	if mod.module.items then -- remove items
+		local events = (host == "*" and prosody.events) or hosts[host].events;
+		for key,t in pairs(mod.module.items) do
+			for i = #t,1,-1 do
+				local value = t[i];
+				t[i] = nil;
+				events.fire_event("item-removed/"..key, {source = mod.module, item = value});
 			end
 		end
 	end
+	mod.module.loaded = false;
+	modulemap[host][name] = nil;
+	return true;
 end
-eventmanager.add_event_hook("host-activated", load_modules_for_host);
-eventmanager.add_event_hook("component-activated", load_modules_for_host);
---
 
-function load(host, module_name, config)
+local function do_load_module(host, module_name, state)
 	if not (host and module_name) then
 		return nil, "insufficient-parameters";
+	elseif not hosts[host] and host ~= "*"then
+		return nil, "unknown-host";
 	end
 	
 	if not modulemap[host] then
-		modulemap[host] = {};
+		modulemap[host] = hosts[host].modules;
 	end
 	
 	if modulemap[host][module_name] then
 		log("warn", "%s is already loaded for %s, so not loading again", module_name, host);
 		return nil, "module-already-loaded";
 	elseif modulemap["*"][module_name] then
+		local mod = modulemap["*"][module_name];
+		if module_has_method(mod, "add_host") then
+			local _log = logger.init(host..":"..module_name);
+			local host_module_api = setmetatable({
+				host = host, event_handlers = new_multitable(), items = {};
+				_log = _log, log = function (self, ...) return _log(...); end;
+			},{
+				__index = modulemap["*"][module_name].module;
+			});
+			local host_module = setmetatable({ module = host_module_api }, { __index = mod });
+			host_module_api.environment = host_module;
+			modulemap[host][module_name] = host_module;
+			local ok, result, module_err = call_module_method(mod, "add_host", host_module_api);
+			if not ok or result == false then
+				modulemap[host][module_name] = nil;
+				return nil, ok and module_err or result;
+			end
+			return host_module;
+		end
 		return nil, "global-module-already-loaded";
 	end
 	
 
-	local mod, err = pluginloader.load_code(module_name);
-	if not mod then
-		log("error", "Unable to load module '%s': %s", module_name or "nil", err or "nil");
-		return nil, err;
-	end
 
 	local _log = logger.init(host..":"..module_name);
-	local api_instance = setmetatable({ name = module_name, host = host, config = config,  _log = _log, log = function (self, ...) return _log(...); end }, { __index = api });
+	local api_instance = setmetatable({ name = module_name, host = host,
+		_log = _log, log = function (self, ...) return _log(...); end, event_handlers = new_multitable(),
+		reloading = not not state, saved_state = state~=true and state or nil }
+		, { __index = api });
 
 	local pluginenv = setmetatable({ module = api_instance }, { __index = _G });
+	api_instance.environment = pluginenv;
 	
-	setfenv(mod, pluginenv);
-	if not hosts[host] then
-		local create_component = _G.require "core.componentmanager".create_component;
-		hosts[host] = create_component(host);
-		hosts[host].connected = false;
-		log("debug", "Created new component: %s", host);
+	local mod, err = pluginloader.load_code(module_name, nil, pluginenv);
+	if not mod then
+		log("error", "Unable to load module '%s': %s", module_name or "nil", err or "nil");
+		return nil, err;
 	end
-	hosts[host].modules = modulemap[host];
+
+	api_instance.path = err;
+
 	modulemap[host][module_name] = pluginenv;
-	
-	local success, err = pcall(mod);
-	if success then
+	local ok, err = pcall(mod);
+	if ok then
+		-- Call module's "load"
 		if module_has_method(pluginenv, "load") then
-			success, err = call_module_method(pluginenv, "load");
-			if not success then
+			ok, err = call_module_method(pluginenv, "load");
+			if not ok then
 				log("warn", "Error loading module '%s' on '%s': %s", module_name, host, err or "nil");
 			end
 		end
+		api_instance.reloading, api_instance.saved_state = nil, nil;
 
-		-- Use modified host, if the module set one
-		if api_instance.host == "*" and host ~= "*" then
+		if api_instance.host == "*" then
+			if not api_instance.global then -- COMPAT w/pre-0.9
+				if host ~= "*" then
+					log("warn", "mod_%s: Setting module.host = '*' deprecated, call module:set_global() instead", module_name);
+				end
+				api_instance:set_global();
+			end
 			modulemap[host][module_name] = nil;
-			modulemap["*"][module_name] = pluginenv;
-			api_instance:set_global();
-		end
-	else
-		log("error", "Error initializing module '%s' on '%s': %s", module_name, host, err or "nil");
-	end
-	if success then
-		return true;
-	else -- load failed, unloading
-		unload(api_instance.host, module_name);
-		return nil, err;
-	end
-end
-
-function get_module(host, name)
-	return modulemap[host] and modulemap[host][name];
-end
-
-function is_loaded(host, name)
-	return modulemap[host] and modulemap[host][name] and true;
-end
-
-function unload(host, name, ...)
-	local mod = get_module(host, name); 
-	if not mod then return nil, "module-not-loaded"; end
-	
-	if module_has_method(mod, "unload") then
-		local ok, err = call_module_method(mod, "unload");
-		if (not ok) and err then
-			log("warn", "Non-fatal error unloading module '%s' on '%s': %s", name, host, err);
-		end
-	end
-	local params = handler_table:get(host, name); -- , {module.host, origin_type, tag, xmlns}
-	for _, param in pairs(params or NULL) do
-		local handlers = stanza_handlers:get(param[1], param[2], param[3], param[4]);
-		if handlers then
-			handler_info[handlers[1]] = nil;
-			stanza_handlers:remove(param[1], param[2], param[3], param[4]);
-		end
-	end
-	event_hooks:remove(host, name);
-	-- unhook event handlers hooked by module:hook
-	for event, handlers in pairs(hooks:get(host, name) or NULL) do
-		for handler in pairs(handlers or NULL) do
-			(hosts[host] or prosody).events.remove_handler(event, handler);
-		end
-	end
-	hooks:remove(host, name);
-	if mod.module.items then -- remove items
-		for key,t in pairs(mod.module.items) do
-			for i = #t,1,-1 do
-				local value = t[i];
-				t[i] = nil;
-				hosts[host].events.fire_event("item-removed/"..key, {source = self, item = value});
+			modulemap[api_instance.host][module_name] = pluginenv;
+			if host ~= api_instance.host and module_has_method(pluginenv, "add_host") then
+				-- Now load the module again onto the host it was originally being loaded on
+				ok, err = do_load_module(host, module_name);
 			end
 		end
 	end
-	modulemap[host][name] = nil;
-	return true;
+	if not ok then
+		modulemap[api_instance.host][module_name] = nil;
+		log("error", "Error initializing module '%s' on '%s': %s", module_name, host, err or "nil");
+	end
+	return ok and pluginenv, err;
 end
 
-function reload(host, name, ...)
+local function do_reload_module(host, name)
 	local mod = get_module(host, name);
 	if not mod then return nil, "module-not-loaded"; end
 
@@ -221,14 +212,13 @@ function reload(host, name, ...)
 	end
 
 	local saved;
-
 	if module_has_method(mod, "save") then
 		local ok, ret, err = call_module_method(mod, "save");
 		if ok then
 			saved = ret;
 		else
-			log("warn", "Error saving module '%s:%s' state: %s", host, module, ret);
-			if not config.get(host, "core", "force_module_reload") then
+			log("warn", "Error saving module '%s:%s' state: %s", host, name, ret);
+			if not config.get(host, "force_module_reload") then
 				log("warn", "Aborting reload due to error, set force_module_reload to ignore this");
 				return nil, "save-state-failed";
 			else
@@ -237,8 +227,9 @@ function reload(host, name, ...)
 		end
 	end
 
-	unload(host, name, ...);
-	local ok, err = load(host, name, ...);
+	mod.module.reloading = true;
+	do_unload_module(host, name);
+	local ok, err = do_load_module(host, name, saved or true);
 	if ok then
 		mod = get_module(host, name);
 		if module_has_method(mod, "restore") then
@@ -247,221 +238,82 @@ function reload(host, name, ...)
 				log("warn", "Error restoring module '%s' from '%s': %s", name, host, err);
 			end
 		end
-		return true;
-	end
-	return ok, err;
-end
-
-function handle_stanza(host, origin, stanza)
-	local name, xmlns, origin_type = stanza.name, stanza.attr.xmlns or "jabber:client", origin.type;
-	if name == "iq" and xmlns == "jabber:client" then
-		if stanza.attr.type == "get" or stanza.attr.type == "set" then
-			xmlns = stanza.tags[1].attr.xmlns or "jabber:client";
-			log("debug", "Stanza of type %s from %s has xmlns: %s", name, origin_type, xmlns);
-		else
-			log("debug", "Discarding %s from %s of type: %s", name, origin_type, stanza.attr.type);
-			return true;
-		end
-	end
-	local handlers = stanza_handlers:get(host, origin_type, name, xmlns);
-	if not handlers then handlers = stanza_handlers:get("*", origin_type, name, xmlns); end
-	if handlers then
-		log("debug", "Passing stanza to mod_%s", handler_info[handlers[1]].name);
-		(handlers[1])(origin, stanza);
-		return true;
-	else
-		if stanza.attr.xmlns == nil then
-			log("debug", "Unhandled %s stanza: %s; xmlns=%s", origin.type, stanza.name, xmlns); -- we didn't handle it
-			if stanza.attr.type ~= "error" and stanza.attr.type ~= "result" then
-				origin.send(st.error_reply(stanza, "cancel", "service-unavailable"));
-			end
-		elseif not((name == "features" or name == "error") and xmlns == "http://etherx.jabber.org/streams") then -- FIXME remove check once we handle S2S features
-			log("warn", "Unhandled %s stream element: %s; xmlns=%s: %s", origin.type, stanza.name, xmlns, tostring(stanza)); -- we didn't handle it
-			origin:close("unsupported-stanza-type");
-		end
-	end
-end
-
-function module_has_method(module, method)
-	return type(module.module[method]) == "function";
-end
-
-function call_module_method(module, method, ...)
-	if module_has_method(module, method) then	
-		local f = module.module[method];
-		return pcall(f, ...);
-	else
-		return false, "no-such-method";
-	end
-end
-
------ API functions exposed to modules -----------
--- Must all be in api.* 
-
--- Returns the name of the current module
-function api:get_name()
-	return self.name;
-end
-
--- Returns the host that the current module is serving
-function api:get_host()
-	return self.host;
-end
-
-function api:get_host_type()
-	return hosts[self.host].type;
-end
-
-function api:set_global()
-	self.host = "*";
-	-- Update the logger
-	local _log = logger.init("mod_"..self.name);
-	self.log = function (self, ...) return _log(...); end;
-	self._log = _log;
-end
-
-local function _add_handler(module, origin_type, tag, xmlns, handler)
-	local handlers = stanza_handlers:get(module.host, origin_type, tag, xmlns);
-	local msg = (tag == "iq") and "namespace" or "payload namespace";
-	if not handlers then
-		stanza_handlers:add(module.host, origin_type, tag, xmlns, handler);
-		handler_info[handler] = module;
-		handler_table:add(module.host, module.name, {module.host, origin_type, tag, xmlns});
-		--module:log("debug", "I now handle tag '%s' [%s] with %s '%s'", tag, origin_type, msg, xmlns);
-	else
-		module:log("warn", "I wanted to handle tag '%s' [%s] with %s '%s' but mod_%s already handles that", tag, origin_type, msg, xmlns, handler_info[handlers[1]].module.name);
-	end
-end
-
-function api:add_handler(origin_type, tag, xmlns, handler)
-	if not (origin_type and tag and xmlns and handler) then return false; end
-	if type(origin_type) == "table" then
-		for _, origin_type in ipairs(origin_type) do
-			_add_handler(self, origin_type, tag, xmlns, handler);
-		end
-	else
-		_add_handler(self, origin_type, tag, xmlns, handler);
 	end
-end
-function api:add_iq_handler(origin_type, xmlns, handler)
-	self:add_handler(origin_type, "iq", xmlns, handler);
+	return ok and mod, err;
 end
 
-function api:add_feature(xmlns)
-	self:add_item("feature", xmlns);
-end
-function api:add_identity(category, type, name)
-	self:add_item("identity", {category = category, type = type, name = name});
-end
+--- Public API ---
 
-local event_hook = function(host, mod_name, event_name, ...)
-	if type((...)) == "table" and (...).host and (...).host ~= host then return; end
-	for handler in pairs(event_hooks:get(host, mod_name, event_name) or NULL) do
-		handler(...);
-	end
-end;
-function api:add_event_hook(name, handler)
-	if not hooked:get(self.host, self.name, name) then
-		eventmanager.add_event_hook(name, function(...) event_hook(self.host, self.name, name, ...); end);
-		hooked:set(self.host, self.name, name, true);
+-- Load a module and fire module-loaded event
+function load(host, name)
+	local mod, err = do_load_module(host, name);
+	if mod then
+		(hosts[mod.module.host] or prosody).events.fire_event("module-loaded", { module = name, host = mod.module.host });
 	end
-	event_hooks:set(self.host, self.name, name, handler, true);
+	return mod, err;
 end
 
-function api:fire_event(...)
-	return (hosts[self.host] or prosody).events.fire_event(...);
-end
-
-function api:hook(event, handler, priority)
-	hooks:set(self.host, self.name, event, handler, true);
-	(hosts[self.host] or prosody).events.add_handler(event, handler, priority);
-end
-
-function api:hook_stanza(xmlns, name, handler, priority)
-	if not handler and type(name) == "function" then
-		-- If only 2 options then they specified no xmlns
-		xmlns, name, handler, priority = nil, xmlns, name, handler;
-	elseif not (handler and name) then
-		self:log("warn", "Error: Insufficient parameters to module:hook_stanza()");
-		return;
-	end
-	return api.hook(self, "stanza/"..(xmlns and (xmlns..":") or "")..name, function (data) return handler(data.origin, data.stanza, data); end, priority);
-end
-
-function api:require(lib)
-	local f, n = pluginloader.load_code(self.name, lib..".lib.lua");
-	if not f then
-		f, n = pluginloader.load_code(lib, lib..".lib.lua");
+-- Unload a module and fire module-unloaded
+function unload(host, name)
+	local ok, err = do_unload_module(host, name);
+	if ok then
+		(hosts[host] or prosody).events.fire_event("module-unloaded", { module = name, host = host });
 	end
-	if not f then error("Failed to load plugin library '"..lib.."', error: "..n); end -- FIXME better error message
-	setfenv(f, setmetatable({ module = self }, { __index = _G }));
-	return f();
+	return ok, err;
 end
 
-function api:get_option(name, default_value)
-	local value = config.get(self.host, self.name, name);
-	if value == nil then
-		value = config.get(self.host, "core", name);
-		if value == nil then
-			value = default_value;
-		end
+function reload(host, name)
+	local mod, err = do_reload_module(host, name);
+	if mod then
+		modulemap[host][name].module.reloading = true;
+		(hosts[host] or prosody).events.fire_event("module-reloaded", { module = name, host = host });
+		mod.module.reloading = nil;
+	elseif not is_loaded(host, name) then
+		(hosts[host] or prosody).events.fire_event("module-unloaded", { module = name, host = host });
 	end
-	return value;
+	return mod, err;
 end
 
-local t_remove = _G.table.remove;
-local module_items = multitable_new();
-function api:add_item(key, value)
-	self.items = self.items or {};
-	self.items[key] = self.items[key] or {};
-	t_insert(self.items[key], value);
-	self:fire_event("item-added/"..key, {source = self, item = value});
-end
-function api:remove_item(key, value)
-	local t = self.items and self.items[key] or NULL;
-	for i = #t,1,-1 do
-		if t[i] == value then
-			t_remove(self.items[key], i);
-			self:fire_event("item-removed/"..key, {source = self, item = value});
-			return value;
-		end
-	end
+function get_module(host, name)
+	return modulemap[host] and modulemap[host][name];
 end
 
-function api:get_host_items(key)
+function get_items(key, host)
 	local result = {};
-	for mod_name, module in pairs(modulemap[self.host]) do
-		module = module.module;
-		if module.items then
-			for _, item in ipairs(module.items[key] or NULL) do
-				t_insert(result, item);
-			end
-		end
-	end
-	for mod_name, module in pairs(modulemap["*"]) do
-		module = module.module;
-		if module.items then
-			for _, item in ipairs(module.items[key] or NULL) do
-				t_insert(result, item);
+	local modules = modulemap[host];
+	if not key or not host or not modules then return nil; end
+
+	for _, module in pairs(modules) do
+		local mod = module.module;
+		if mod.items and mod.items[key] then
+			for _, value in ipairs(mod.items[key]) do
+				t_insert(result, value);
 			end
 		end
 	end
+
 	return result;
 end
 
---------------------------------------------------------------------
-
-local actions = {};
+function get_modules(host)
+	return modulemap[host];
+end
 
-function actions.load(params)
-	--return true, "Module loaded ("..params.module.." on "..params.host..")";
-	return load(params.host, params.module);
+function is_loaded(host, name)
+	return modulemap[host] and modulemap[host][name] and true;
 end
 
-function actions.unload(params)
-	return unload(params.host, params.module);
+function module_has_method(module, method)
+	return type(rawget(module.module, method)) == "function";
 end
 
-register_actions("/modules", actions);
+function call_module_method(module, method, ...)
+	local f = rawget(module.module, method);
+	if type(f) == "function" then
+		return pcall(f, ...);
+	else
+		return false, "no-such-method";
+	end
+end
 
 return _M;