# HG changeset patch # User Goffi # Date 1685703561 -7200 # Node ID 7c5654c54fed116e35568db5d79123c99aeb19c6 # Parent 040095a5dc7f5788c45e343c46fa856063264330 refactoring: rename `core.sat_main` to `core.main` diff -r 040095a5dc7f -r 7c5654c54fed libervia/backend/core/main.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libervia/backend/core/main.py Fri Jun 02 12:59:21 2023 +0200 @@ -0,0 +1,1666 @@ +#!/usr/bin/env python3 + +# Libervia: an XMPP client +# Copyright (C) 2009-2021 Jérôme Poisson (goffi@goffi.org) + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU Affero General Public License as published by +# the Free Software Foundation, either version 3 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 Affero General Public License for more details. + +# You should have received a copy of the GNU Affero General Public License +# along with this program. If not, see . + +import sys +import os.path +import uuid +import hashlib +import copy +from pathlib import Path +from typing import Optional, List, Tuple, Dict + +from wokkel.data_form import Option +from libervia import backend +from libervia.backend.core.i18n import _, D_, language_switch +from libervia.backend.core import patches +patches.apply() +from twisted.application import service +from twisted.internet import defer +from twisted.words.protocols.jabber import jid +from twisted.internet import reactor +from wokkel.xmppim import RosterItem +from libervia.backend.core import xmpp +from libervia.backend.core import exceptions +from libervia.backend.core.core_types import SatXMPPEntity +from libervia.backend.core.log import getLogger + +from libervia.backend.core.constants import Const as C +from libervia.backend.memory import memory +from libervia.backend.memory import cache +from libervia.backend.memory import encryption +from libervia.backend.tools import async_trigger as trigger +from libervia.backend.tools import utils +from libervia.backend.tools import image +from libervia.backend.tools.common import dynamic_import +from libervia.backend.tools.common import regex +from libervia.backend.tools.common import data_format +from libervia.backend.stdui import ui_contact_list, ui_profile_manager +import libervia.backend.plugins + + +log = getLogger(__name__) + +class LiberviaBackend(service.Service): + + def _init(self): + # we don't use __init__ to avoid doule initialisation with twistd + # this _init is called in startService + log.info(f"{C.APP_NAME} {self.full_version}") + self._cb_map = {} # map from callback_id to callbacks + # dynamic menus. key: callback_id, value: menu data (dictionnary) + self._menus = {} + self._menus_paths = {} # path to id. key: (menu_type, lower case tuple of path), + # value: menu id + self.initialised = defer.Deferred() + self.profiles = {} + self.plugins = {} + # map for short name to whole namespace, + # extended by plugins with register_namespace + self.ns_map = { + "x-data": xmpp.NS_X_DATA, + "disco#info": xmpp.NS_DISCO_INFO, + } + + self.memory = memory.Memory(self) + + # trigger are used to change Libervia behaviour + self.trigger = ( + trigger.TriggerManager() + ) + + bridge_name = ( + os.getenv("LIBERVIA_BRIDGE_NAME") + or self.memory.config_get("", "bridge", "dbus") + ) + + bridge_module = dynamic_import.bridge(bridge_name) + if bridge_module is None: + log.error(f"Can't find bridge module of name {bridge_name}") + sys.exit(1) + log.info(f"using {bridge_name} bridge") + try: + self.bridge = bridge_module.bridge() + except exceptions.BridgeInitError: + log.exception("bridge can't be initialised, can't start Libervia Backend") + sys.exit(1) + + defer.ensureDeferred(self._post_init()) + + @property + def version(self): + """Return the short version of Libervia""" + return C.APP_VERSION + + @property + def full_version(self): + """Return the full version of Libervia + + In developement mode, release name and extra data are returned too + """ + version = self.version + if version[-1] == "D": + # we are in debug version, we add extra data + try: + return self._version_cache + except AttributeError: + self._version_cache = "{} « {} » ({})".format( + version, C.APP_RELEASE_NAME, utils.get_repository_data(backend) + ) + return self._version_cache + else: + return version + + @property + def bridge_name(self): + return os.path.splitext(os.path.basename(self.bridge.__file__))[0] + + async def _post_init(self): + try: + bridge_pi = self.bridge.post_init + except AttributeError: + pass + else: + try: + await bridge_pi() + except Exception: + log.exception("Could not initialize bridge") + # because init is not complete at this stage, we use callLater + reactor.callLater(0, self.stop) + return + + self.bridge.register_method("ready_get", lambda: self.initialised) + self.bridge.register_method("version_get", lambda: self.full_version) + self.bridge.register_method("features_get", self.features_get) + self.bridge.register_method("profile_name_get", self.memory.get_profile_name) + self.bridge.register_method("profiles_list_get", self.memory.get_profiles_list) + self.bridge.register_method("entity_data_get", self.memory._get_entity_data) + self.bridge.register_method("entities_data_get", self.memory._get_entities_data) + self.bridge.register_method("profile_create", self.memory.create_profile) + self.bridge.register_method("profile_delete_async", self.memory.profile_delete_async) + self.bridge.register_method("profile_start_session", self.memory.start_session) + self.bridge.register_method( + "profile_is_session_started", self.memory._is_session_started + ) + self.bridge.register_method("profile_set_default", self.memory.profile_set_default) + self.bridge.register_method("connect", self._connect) + self.bridge.register_method("disconnect", self.disconnect) + self.bridge.register_method("contact_get", self._contact_get) + self.bridge.register_method("contacts_get", self.contacts_get) + self.bridge.register_method("contacts_get_from_group", self.contacts_get_from_group) + self.bridge.register_method("main_resource_get", self.memory._get_main_resource) + self.bridge.register_method( + "presence_statuses_get", self.memory._get_presence_statuses + ) + self.bridge.register_method("sub_waiting_get", self.memory.sub_waiting_get) + self.bridge.register_method("message_send", self._message_send) + self.bridge.register_method("message_encryption_start", + self._message_encryption_start) + self.bridge.register_method("message_encryption_stop", + self._message_encryption_stop) + self.bridge.register_method("message_encryption_get", + self._message_encryption_get) + self.bridge.register_method("encryption_namespace_get", + self._encryption_namespace_get) + self.bridge.register_method("encryption_plugins_get", self._encryption_plugins_get) + self.bridge.register_method("encryption_trust_ui_get", self._encryption_trust_ui_get) + self.bridge.register_method("config_get", self._get_config) + self.bridge.register_method("param_set", self.param_set) + self.bridge.register_method("param_get_a", self.memory.get_string_param_a) + self.bridge.register_method("private_data_get", self.memory._private_data_get) + self.bridge.register_method("private_data_set", self.memory._private_data_set) + self.bridge.register_method("private_data_delete", self.memory._private_data_delete) + self.bridge.register_method("param_get_a_async", self.memory.async_get_string_param_a) + self.bridge.register_method( + "params_values_from_category_get_async", + self.memory._get_params_values_from_category, + ) + self.bridge.register_method("param_ui_get", self.memory._get_params_ui) + self.bridge.register_method( + "params_categories_get", self.memory.params_categories_get + ) + self.bridge.register_method("params_register_app", self.memory.params_register_app) + self.bridge.register_method("history_get", self.memory._history_get) + self.bridge.register_method("presence_set", self._set_presence) + self.bridge.register_method("subscription", self.subscription) + self.bridge.register_method("contact_add", self._add_contact) + self.bridge.register_method("contact_update", self._update_contact) + self.bridge.register_method("contact_del", self._del_contact) + self.bridge.register_method("roster_resync", self._roster_resync) + self.bridge.register_method("is_connected", self.is_connected) + self.bridge.register_method("action_launch", self._action_launch) + self.bridge.register_method("actions_get", self.actions_get) + self.bridge.register_method("progress_get", self._progress_get) + self.bridge.register_method("progress_get_all", self._progress_get_all) + self.bridge.register_method("menus_get", self.get_menus) + self.bridge.register_method("menu_help_get", self.get_menu_help) + self.bridge.register_method("menu_launch", self._launch_menu) + self.bridge.register_method("disco_infos", self.memory.disco._disco_infos) + self.bridge.register_method("disco_items", self.memory.disco._disco_items) + self.bridge.register_method("disco_find_by_features", self._find_by_features) + self.bridge.register_method("params_template_save", self.memory.save_xml) + self.bridge.register_method("params_template_load", self.memory.load_xml) + self.bridge.register_method("session_infos_get", self.get_session_infos) + self.bridge.register_method("devices_infos_get", self._get_devices_infos) + self.bridge.register_method("namespaces_get", self.get_namespaces) + self.bridge.register_method("image_check", self._image_check) + self.bridge.register_method("image_resize", self._image_resize) + self.bridge.register_method("image_generate_preview", self._image_generate_preview) + self.bridge.register_method("image_convert", self._image_convert) + + + await self.memory.initialise() + self.common_cache = cache.Cache(self, None) + log.info(_("Memory initialised")) + try: + self._import_plugins() + ui_contact_list.ContactList(self) + ui_profile_manager.ProfileManager(self) + except Exception as e: + log.error(f"Could not initialize backend: {e}") + sys.exit(1) + self._add_base_menus() + + self.initialised.callback(None) + log.info(_("Backend is ready")) + + # profile autoconnection must be done after self.initialised is called because + # start_session waits for it. + autoconnect_dict = await self.memory.storage.get_ind_param_values( + category='Connection', name='autoconnect_backend', + ) + profiles_autoconnect = [p for p, v in autoconnect_dict.items() if C.bool(v)] + if not self.trigger.point("profilesAutoconnect", profiles_autoconnect): + return + if profiles_autoconnect: + log.info(D_( + "Following profiles will be connected automatically: {profiles}" + ).format(profiles= ', '.join(profiles_autoconnect))) + connect_d_list = [] + for profile in profiles_autoconnect: + connect_d_list.append(defer.ensureDeferred(self.connect(profile))) + + if connect_d_list: + results = await defer.DeferredList(connect_d_list) + for idx, (success, result) in enumerate(results): + if not success: + profile = profiles_autoconnect[0] + log.warning( + _("Can't autoconnect profile {profile}: {reason}").format( + profile = profile, + reason = result) + ) + + def _add_base_menus(self): + """Add base menus""" + encryption.EncryptionHandler._import_menus(self) + + def _unimport_plugin(self, plugin_path): + """remove a plugin from sys.modules if it is there""" + try: + del sys.modules[plugin_path] + except KeyError: + pass + + def _import_plugins(self): + """import all plugins found in plugins directory""" + # FIXME: module imported but cancelled should be deleted + # TODO: make this more generic and reusable in tools.common + # FIXME: should use imp + # TODO: do not import all plugins if no needed: component plugins are not needed + # if we just use a client, and plugin blacklisting should be possible in + # libervia.conf + plugins_path = Path(libervia.backend.plugins.__file__).parent + plugins_to_import = {} # plugins we still have to import + for plug_path in plugins_path.glob("plugin_*"): + if plug_path.is_dir(): + init_path = plug_path / f"__init__.{C.PLUGIN_EXT}" + if not init_path.exists(): + log.warning( + f"{plug_path} doesn't appear to be a package, can't load it") + continue + plug_name = plug_path.name + elif plug_path.is_file(): + if plug_path.suffix != f".{C.PLUGIN_EXT}": + continue + plug_name = plug_path.stem + else: + log.warning( + f"{plug_path} is not a file or a dir, ignoring it") + continue + if not plug_name.isidentifier(): + log.warning( + f"{plug_name!r} is not a valid name for a plugin, ignoring it") + continue + plugin_path = f"libervia.backend.plugins.{plug_name}" + try: + __import__(plugin_path) + except exceptions.MissingModule as e: + self._unimport_plugin(plugin_path) + log.warning( + "Can't import plugin [{path}] because of an unavailale third party " + "module:\n{msg}".format( + path=plugin_path, msg=e + ) + ) + continue + except exceptions.CancelError as e: + log.info( + "Plugin [{path}] cancelled its own import: {msg}".format( + path=plugin_path, msg=e + ) + ) + self._unimport_plugin(plugin_path) + continue + except Exception: + import traceback + + log.error( + _("Can't import plugin [{path}]:\n{error}").format( + path=plugin_path, error=traceback.format_exc() + ) + ) + self._unimport_plugin(plugin_path) + continue + mod = sys.modules[plugin_path] + plugin_info = mod.PLUGIN_INFO + import_name = plugin_info["import_name"] + + plugin_modes = plugin_info["modes"] = set( + plugin_info.setdefault("modes", C.PLUG_MODE_DEFAULT) + ) + if not plugin_modes.intersection(C.PLUG_MODE_BOTH): + log.error( + f"Can't import plugin at {plugin_path}, invalid {C.PI_MODES!r} " + f"value: {plugin_modes!r}" + ) + continue + + # if the plugin is an entry point, it must work in component mode + if plugin_info["type"] == C.PLUG_TYPE_ENTRY_POINT: + # if plugin is an entrypoint, we cache it + if C.PLUG_MODE_COMPONENT not in plugin_modes: + log.error( + _( + "{type} type must be used with {mode} mode, ignoring plugin" + ).format(type=C.PLUG_TYPE_ENTRY_POINT, mode=C.PLUG_MODE_COMPONENT) + ) + self._unimport_plugin(plugin_path) + continue + + if import_name in plugins_to_import: + log.error( + _( + "Name conflict for import name [{import_name}], can't import " + "plugin [{name}]" + ).format(**plugin_info) + ) + continue + plugins_to_import[import_name] = (plugin_path, mod, plugin_info) + while True: + try: + self._import_plugins_from_dict(plugins_to_import) + except ImportError: + pass + if not plugins_to_import: + break + + def _import_plugins_from_dict( + self, plugins_to_import, import_name=None, optional=False + ): + """Recursively import and their dependencies in the right order + + @param plugins_to_import(dict): key=import_name and values=(plugin_path, module, + plugin_info) + @param import_name(unicode, None): name of the plugin to import as found in + PLUGIN_INFO['import_name'] + @param optional(bool): if False and plugin is not found, an ImportError exception + is raised + """ + if import_name in self.plugins: + log.debug("Plugin {} already imported, passing".format(import_name)) + return + if not import_name: + import_name, (plugin_path, mod, plugin_info) = plugins_to_import.popitem() + else: + if not import_name in plugins_to_import: + if optional: + log.warning( + _("Recommended plugin not found: {}").format(import_name) + ) + return + msg = "Dependency not found: {}".format(import_name) + log.error(msg) + raise ImportError(msg) + plugin_path, mod, plugin_info = plugins_to_import.pop(import_name) + dependencies = plugin_info.setdefault("dependencies", []) + recommendations = plugin_info.setdefault("recommendations", []) + for to_import in dependencies + recommendations: + if to_import not in self.plugins: + log.debug( + "Recursively import dependency of [%s]: [%s]" + % (import_name, to_import) + ) + try: + self._import_plugins_from_dict( + plugins_to_import, to_import, to_import not in dependencies + ) + except ImportError as e: + log.warning( + _("Can't import plugin {name}: {error}").format( + name=plugin_info["name"], error=e + ) + ) + if optional: + return + raise e + log.info("importing plugin: {}".format(plugin_info["name"])) + # we instanciate the plugin here + try: + self.plugins[import_name] = getattr(mod, plugin_info["main"])(self) + except Exception as e: + log.exception( + f"Can't load plugin \"{plugin_info['name']}\", ignoring it: {e}" + ) + if optional: + return + raise ImportError("Error during initiation") + if C.bool(plugin_info.get(C.PI_HANDLER, C.BOOL_FALSE)): + self.plugins[import_name].is_handler = True + else: + self.plugins[import_name].is_handler = False + # we keep metadata as a Class attribute + self.plugins[import_name]._info = plugin_info + # TODO: test xmppclient presence and register handler parent + + def plugins_unload(self): + """Call unload method on every loaded plugin, if exists + + @return (D): A deferred which return None when all method have been called + """ + # TODO: in the futur, it should be possible to hot unload a plugin + # pluging depending on the unloaded one should be unloaded too + # for now, just a basic call on plugin.unload is done + defers_list = [] + for plugin in self.plugins.values(): + try: + unload = plugin.unload + except AttributeError: + continue + else: + defers_list.append(utils.as_deferred(unload)) + return defers_list + + def _connect(self, profile_key, password="", options=None): + profile = self.memory.get_profile_name(profile_key) + return defer.ensureDeferred(self.connect(profile, password, options)) + + async def connect( + self, profile, password="", options=None, max_retries=C.XMPP_MAX_RETRIES): + """Connect a profile (i.e. connect client.component to XMPP server) + + Retrieve the individual parameters, authenticate the profile + and initiate the connection to the associated XMPP server. + @param profile: %(doc_profile)s + @param password (string): the Libervia profile password + @param options (dict): connection options. Key can be: + - + @param max_retries (int): max number of connection retries + @return (D(bool)): + - True if the XMPP connection was already established + - False if the XMPP connection has been initiated (it may still fail) + @raise exceptions.PasswordError: Profile password is wrong + """ + if options is None: + options = {} + + await self.memory.start_session(password, profile) + + if self.is_connected(profile): + log.info(_("already connected !")) + return True + + if self.memory.is_component(profile): + await xmpp.SatXMPPComponent.start_connection(self, profile, max_retries) + else: + await xmpp.SatXMPPClient.start_connection(self, profile, max_retries) + + return False + + def disconnect(self, profile_key): + """disconnect from jabber server""" + # FIXME: client should not be deleted if only disconnected + # it shoud be deleted only when session is finished + if not self.is_connected(profile_key): + # is_connected is checked here and not on client + # because client is deleted when session is ended + log.info(_("not connected !")) + return defer.succeed(None) + client = self.get_client(profile_key) + return client.entity_disconnect() + + def features_get(self, profile_key=C.PROF_KEY_NONE): + """Get available features + + Return list of activated plugins and plugin specific data + @param profile_key: %(doc_profile_key)s + C.PROF_KEY_NONE can be used to have general plugins data (i.e. not profile + dependent) + @return (dict)[Deferred]: features data where: + - key is plugin import name, present only for activated plugins + - value is a an other dict, when meaning is specific to each plugin. + this dict is return by plugin's getFeature method. + If this method doesn't exists, an empty dict is returned. + """ + try: + # FIXME: there is no method yet to check profile session + # as soon as one is implemented, it should be used here + self.get_client(profile_key) + except KeyError: + log.warning("Requesting features for a profile outside a session") + profile_key = C.PROF_KEY_NONE + except exceptions.ProfileNotSetError: + pass + + features = [] + for import_name, plugin in self.plugins.items(): + try: + features_d = utils.as_deferred(plugin.features_get, profile_key) + except AttributeError: + features_d = defer.succeed({}) + features.append(features_d) + + d_list = defer.DeferredList(features) + + def build_features(result, import_names): + assert len(result) == len(import_names) + ret = {} + for name, (success, data) in zip(import_names, result): + if success: + ret[name] = data + else: + log.warning( + "Error while getting features for {name}: {failure}".format( + name=name, failure=data + ) + ) + ret[name] = {} + return ret + + d_list.addCallback(build_features, list(self.plugins.keys())) + return d_list + + def _contact_get(self, entity_jid_s, profile_key): + client = self.get_client(profile_key) + entity_jid = jid.JID(entity_jid_s) + return defer.ensureDeferred(self.get_contact(client, entity_jid)) + + async def get_contact(self, client, entity_jid): + # we want to be sure that roster has been received + await client.roster.got_roster + item = client.roster.get_item(entity_jid) + if item is None: + raise exceptions.NotFound(f"{entity_jid} is not in roster!") + return (client.roster.get_attributes(item), list(item.groups)) + + def contacts_get(self, profile_key): + client = self.get_client(profile_key) + + def got_roster(__): + ret = [] + for item in client.roster.get_items(): # we get all items for client's roster + # and convert them to expected format + attr = client.roster.get_attributes(item) + # we use full() and not userhost() because jid with resources are allowed + # in roster, even if it's not common. + ret.append([item.entity.full(), attr, list(item.groups)]) + return ret + + return client.roster.got_roster.addCallback(got_roster) + + def contacts_get_from_group(self, group, profile_key): + client = self.get_client(profile_key) + return [jid_.full() for jid_ in client.roster.get_jids_from_group(group)] + + def purge_entity(self, profile): + """Remove reference to a profile client/component and purge cache + + the garbage collector can then free the memory + """ + try: + del self.profiles[profile] + except KeyError: + log.error(_("Trying to remove reference to a client not referenced")) + else: + self.memory.purge_profile_session(profile) + + def startService(self): + self._init() + log.info("Salut à toi ô mon frère !") + + def stopService(self): + log.info("Salut aussi à Rantanplan") + return self.plugins_unload() + + def run(self): + log.debug(_("running app")) + reactor.run() + + def stop(self): + log.debug(_("stopping app")) + reactor.stop() + + ## Misc methods ## + + def get_jid_n_stream(self, profile_key): + """Convenient method to get jid and stream from profile key + @return: tuple (jid, xmlstream) from profile, can be None""" + # TODO: deprecate this method (get_client is enough) + profile = self.memory.get_profile_name(profile_key) + if not profile or not self.profiles[profile].is_connected(): + return (None, None) + return (self.profiles[profile].jid, self.profiles[profile].xmlstream) + + def get_client(self, profile_key: str) -> xmpp.SatXMPPClient: + """Convenient method to get client from profile key + + @return: the client + @raise exceptions.ProfileKeyUnknown: the profile or profile key doesn't exist + @raise exceptions.NotFound: client is not available + This happen if profile has not been used yet + """ + profile = self.memory.get_profile_name(profile_key) + if not profile: + raise exceptions.ProfileKeyUnknown + try: + return self.profiles[profile] + except KeyError: + raise exceptions.NotFound(profile_key) + + def get_clients(self, profile_key): + """Convenient method to get list of clients from profile key + + Manage list through profile_key like C.PROF_KEY_ALL + @param profile_key: %(doc_profile_key)s + @return: list of clients + """ + if not profile_key: + raise exceptions.DataError(_("profile_key must not be empty")) + try: + profile = self.memory.get_profile_name(profile_key, True) + except exceptions.ProfileUnknownError: + return [] + if profile == C.PROF_KEY_ALL: + return list(self.profiles.values()) + elif profile[0] == "@": #  only profile keys can start with "@" + raise exceptions.ProfileKeyUnknown + return [self.profiles[profile]] + + def _get_config(self, section, name): + """Get the main configuration option + + @param section: section of the config file (None or '' for DEFAULT) + @param name: name of the option + @return: unicode representation of the option + """ + return str(self.memory.config_get(section, name, "")) + + def log_errback(self, failure_, msg=_("Unexpected error: {failure_}")): + """Generic errback logging + + @param msg(unicode): error message ("failure_" key will be use for format) + can be used as last errback to show unexpected error + """ + log.error(msg.format(failure_=failure_)) + return failure_ + + #  namespaces + + def register_namespace(self, short_name, namespace): + """associate a namespace to a short name""" + if short_name in self.ns_map: + raise exceptions.ConflictError("this short name is already used") + log.debug(f"registering namespace {short_name} => {namespace}") + self.ns_map[short_name] = namespace + + def get_namespaces(self): + return self.ns_map + + def get_namespace(self, short_name): + try: + return self.ns_map[short_name] + except KeyError: + raise exceptions.NotFound("namespace {short_name} is not registered" + .format(short_name=short_name)) + + def get_session_infos(self, profile_key): + """compile interesting data on current profile session""" + client = self.get_client(profile_key) + data = { + "jid": client.jid.full(), + "started": str(int(client.started)) + } + return defer.succeed(data) + + def _get_devices_infos(self, bare_jid, profile_key): + client = self.get_client(profile_key) + if not bare_jid: + bare_jid = None + d = defer.ensureDeferred(self.get_devices_infos(client, bare_jid)) + d.addCallback(lambda data: data_format.serialise(data)) + return d + + async def get_devices_infos(self, client, bare_jid=None): + """compile data on an entity devices + + @param bare_jid(jid.JID, None): bare jid of entity to check + None to use client own jid + @return (list[dict]): list of data, one item per resource. + Following keys can be set: + - resource(str): resource name + """ + own_jid = client.jid.userhostJID() + if bare_jid is None: + bare_jid = own_jid + else: + bare_jid = jid.JID(bare_jid) + resources = self.memory.get_all_resources(client, bare_jid) + if bare_jid == own_jid: + # our own jid is not stored in memory's cache + resources.add(client.jid.resource) + ret_data = [] + for resource in resources: + res_jid = copy.copy(bare_jid) + res_jid.resource = resource + cache_data = self.memory.entity_data_get(client, res_jid) + res_data = { + "resource": resource, + } + try: + presence = cache_data['presence'] + except KeyError: + pass + else: + res_data['presence'] = { + "show": presence.show, + "priority": presence.priority, + "statuses": presence.statuses, + } + + disco = await self.get_disco_infos(client, res_jid) + + for (category, type_), name in disco.identities.items(): + identities = res_data.setdefault('identities', []) + identities.append({ + "name": name, + "category": category, + "type": type_, + }) + + ret_data.append(res_data) + + return ret_data + + # images + + def _image_check(self, path): + report = image.check(self, path) + return data_format.serialise(report) + + def _image_resize(self, path, width, height): + d = image.resize(path, (width, height)) + d.addCallback(lambda new_image_path: str(new_image_path)) + return d + + def _image_generate_preview(self, path, profile_key): + client = self.get_client(profile_key) + d = defer.ensureDeferred(self.image_generate_preview(client, Path(path))) + d.addCallback(lambda preview_path: str(preview_path)) + return d + + async def image_generate_preview(self, client, path): + """Helper method to generate in cache a preview of an image + + @param path(Path): path to the image + @return (Path): path to the generated preview + """ + report = image.check(self, path, max_size=(300, 300)) + + if not report['too_large']: + # in the unlikely case that image is already smaller than a preview + preview_path = path + else: + # we use hash as id, to re-use potentially existing preview + path_hash = hashlib.sha256(str(path).encode()).hexdigest() + uid = f"{path.stem}_{path_hash}_preview" + filename = f"{uid}{path.suffix.lower()}" + metadata = client.cache.get_metadata(uid=uid) + if metadata is not None: + preview_path = metadata['path'] + else: + with client.cache.cache_data( + source='HOST_PREVIEW', + uid=uid, + filename=filename) as cache_f: + + preview_path = await image.resize( + path, + new_size=report['recommended_size'], + dest=cache_f + ) + + return preview_path + + def _image_convert(self, source, dest, extra, profile_key): + client = self.get_client(profile_key) if profile_key else None + source = Path(source) + dest = None if not dest else Path(dest) + extra = data_format.deserialise(extra) + d = defer.ensureDeferred(self.image_convert(client, source, dest, extra)) + d.addCallback(lambda dest_path: str(dest_path)) + return d + + async def image_convert(self, client, source, dest=None, extra=None): + """Helper method to convert an image from one format to an other + + @param client(SatClient, None): client to use for caching + this parameter is only used if dest is None + if client is None, common cache will be used insted of profile cache + @param source(Path): path to the image to convert + @param dest(None, Path, file): where to save the converted file + - None: use a cache file (uid generated from hash of source) + file will be converted to PNG + - Path: path to the file to create/overwrite + - file: a file object which must be opened for writing in binary mode + @param extra(dict, None): conversion options + see [image.convert] for details + @return (Path): path to the converted image + @raise ValueError: an issue happened with source of dest + """ + if not source.is_file: + raise ValueError(f"Source file {source} doesn't exist!") + if dest is None: + # we use hash as id, to re-use potentially existing conversion + path_hash = hashlib.sha256(str(source).encode()).hexdigest() + uid = f"{source.stem}_{path_hash}_convert_png" + filename = f"{uid}.png" + if client is None: + cache = self.common_cache + else: + cache = client.cache + metadata = cache.get_metadata(uid=uid) + if metadata is not None: + # there is already a conversion for this image in cache + return metadata['path'] + else: + with cache.cache_data( + source='HOST_IMAGE_CONVERT', + uid=uid, + filename=filename) as cache_f: + + converted_path = await image.convert( + source, + dest=cache_f, + extra=extra + ) + return converted_path + else: + return await image.convert(source, dest, extra) + + + # local dirs + + def get_local_path( + self, + client: Optional[SatXMPPEntity], + dir_name: str, + *extra_path: str, + component: bool = False, + ) -> Path: + """Retrieve path for local data + + if path doesn't exist, it will be created + @param client: client instance + if not none, client.profile will be used as last path element + @param dir_name: name of the main path directory + @param *extra_path: extra path element(s) to use + @param component: if True, path will be prefixed with C.COMPONENTS_DIR + @return: path + """ + local_dir = self.memory.config_get("", "local_dir") + if not local_dir: + raise exceptions.InternalError("local_dir must be set") + path_elts = [] + if component: + path_elts.append(C.COMPONENTS_DIR) + path_elts.append(regex.path_escape(dir_name)) + if extra_path: + path_elts.extend([regex.path_escape(p) for p in extra_path]) + if client is not None: + path_elts.append(regex.path_escape(client.profile)) + local_path = Path(*path_elts) + local_path.mkdir(0o700, parents=True, exist_ok=True) + return local_path + + ## Client management ## + + def param_set(self, name, value, category, security_limit, profile_key): + """set wanted paramater and notice observers""" + self.memory.param_set(name, value, category, security_limit, profile_key) + + def is_connected(self, profile_key): + """Return connection status of profile + + @param profile_key: key_word or profile name to determine profile name + @return: True if connected + """ + profile = self.memory.get_profile_name(profile_key) + if not profile: + log.error(_("asking connection status for a non-existant profile")) + raise exceptions.ProfileUnknownError(profile_key) + if profile not in self.profiles: + return False + return self.profiles[profile].is_connected() + + ## Encryption ## + + def register_encryption_plugin(self, *args, **kwargs): + return encryption.EncryptionHandler.register_plugin(*args, **kwargs) + + def _message_encryption_start(self, to_jid_s, namespace, replace=False, + profile_key=C.PROF_KEY_NONE): + client = self.get_client(profile_key) + to_jid = jid.JID(to_jid_s) + return defer.ensureDeferred( + client.encryption.start(to_jid, namespace or None, replace)) + + def _message_encryption_stop(self, to_jid_s, profile_key=C.PROF_KEY_NONE): + client = self.get_client(profile_key) + to_jid = jid.JID(to_jid_s) + return defer.ensureDeferred( + client.encryption.stop(to_jid)) + + def _message_encryption_get(self, to_jid_s, profile_key=C.PROF_KEY_NONE): + client = self.get_client(profile_key) + to_jid = jid.JID(to_jid_s) + session_data = client.encryption.getSession(to_jid) + return client.encryption.get_bridge_data(session_data) + + def _encryption_namespace_get(self, name): + return encryption.EncryptionHandler.get_ns_from_name(name) + + def _encryption_plugins_get(self): + plugins = encryption.EncryptionHandler.getPlugins() + ret = [] + for p in plugins: + ret.append({ + "name": p.name, + "namespace": p.namespace, + "priority": p.priority, + "directed": p.directed, + }) + return data_format.serialise(ret) + + def _encryption_trust_ui_get(self, to_jid_s, namespace, profile_key): + client = self.get_client(profile_key) + to_jid = jid.JID(to_jid_s) + d = defer.ensureDeferred( + client.encryption.get_trust_ui(to_jid, namespace=namespace or None)) + d.addCallback(lambda xmlui: xmlui.toXml()) + return d + + ## XMPP methods ## + + def _message_send( + self, to_jid_s, message, subject=None, mess_type="auto", extra_s="", + profile_key=C.PROF_KEY_NONE): + client = self.get_client(profile_key) + to_jid = jid.JID(to_jid_s) + return client.sendMessage( + to_jid, + message, + subject, + mess_type, + data_format.deserialise(extra_s) + ) + + def _set_presence(self, to="", show="", statuses=None, profile_key=C.PROF_KEY_NONE): + return self.presence_set(jid.JID(to) if to else None, show, statuses, profile_key) + + def presence_set(self, to_jid=None, show="", statuses=None, + profile_key=C.PROF_KEY_NONE): + """Send our presence information""" + if statuses is None: + statuses = {} + profile = self.memory.get_profile_name(profile_key) + assert profile + priority = int( + self.memory.param_get_a("Priority", "Connection", profile_key=profile) + ) + self.profiles[profile].presence.available(to_jid, show, statuses, priority) + # XXX: FIXME: temporary fix to work around openfire 3.7.0 bug (presence is not + # broadcasted to generating resource) + if "" in statuses: + statuses[C.PRESENCE_STATUSES_DEFAULT] = statuses.pop("") + self.bridge.presence_update( + self.profiles[profile].jid.full(), show, int(priority), statuses, profile + ) + + def subscription(self, subs_type, raw_jid, profile_key): + """Called to manage subscription + @param subs_type: subsciption type (cf RFC 3921) + @param raw_jid: unicode entity's jid + @param profile_key: profile""" + profile = self.memory.get_profile_name(profile_key) + assert profile + to_jid = jid.JID(raw_jid) + log.debug( + _("subsciption request [%(subs_type)s] for %(jid)s") + % {"subs_type": subs_type, "jid": to_jid.full()} + ) + if subs_type == "subscribe": + self.profiles[profile].presence.subscribe(to_jid) + elif subs_type == "subscribed": + self.profiles[profile].presence.subscribed(to_jid) + elif subs_type == "unsubscribe": + self.profiles[profile].presence.unsubscribe(to_jid) + elif subs_type == "unsubscribed": + self.profiles[profile].presence.unsubscribed(to_jid) + + def _add_contact(self, to_jid_s, profile_key): + return self.contact_add(jid.JID(to_jid_s), profile_key) + + def contact_add(self, to_jid, profile_key): + """Add a contact in roster list""" + profile = self.memory.get_profile_name(profile_key) + assert profile + # presence is sufficient, as a roster push will be sent according to + # RFC 6121 §3.1.2 + self.profiles[profile].presence.subscribe(to_jid) + + def _update_contact(self, to_jid_s, name, groups, profile_key): + client = self.get_client(profile_key) + return self.contact_update(client, jid.JID(to_jid_s), name, groups) + + def contact_update(self, client, to_jid, name, groups): + """update a contact in roster list""" + roster_item = RosterItem(to_jid) + roster_item.name = name or u'' + roster_item.groups = set(groups) + if not self.trigger.point("roster_update", client, roster_item): + return + return client.roster.setItem(roster_item) + + def _del_contact(self, to_jid_s, profile_key): + return self.contact_del(jid.JID(to_jid_s), profile_key) + + def contact_del(self, to_jid, profile_key): + """Remove contact from roster list""" + profile = self.memory.get_profile_name(profile_key) + assert profile + self.profiles[profile].presence.unsubscribe(to_jid) # is not asynchronous + return self.profiles[profile].roster.removeItem(to_jid) + + def _roster_resync(self, profile_key): + client = self.get_client(profile_key) + return client.roster.resync() + + ## Discovery ## + # discovery methods are shortcuts to self.memory.disco + # the main difference with client.disco is that self.memory.disco manage cache + + def hasFeature(self, *args, **kwargs): + return self.memory.disco.hasFeature(*args, **kwargs) + + def check_feature(self, *args, **kwargs): + return self.memory.disco.check_feature(*args, **kwargs) + + def check_features(self, *args, **kwargs): + return self.memory.disco.check_features(*args, **kwargs) + + def has_identity(self, *args, **kwargs): + return self.memory.disco.has_identity(*args, **kwargs) + + def get_disco_infos(self, *args, **kwargs): + return self.memory.disco.get_infos(*args, **kwargs) + + def getDiscoItems(self, *args, **kwargs): + return self.memory.disco.get_items(*args, **kwargs) + + def find_service_entity(self, *args, **kwargs): + return self.memory.disco.find_service_entity(*args, **kwargs) + + def find_service_entities(self, *args, **kwargs): + return self.memory.disco.find_service_entities(*args, **kwargs) + + def find_features_set(self, *args, **kwargs): + return self.memory.disco.find_features_set(*args, **kwargs) + + def _find_by_features(self, namespaces, identities, bare_jids, service, roster, own_jid, + local_device, profile_key): + client = self.get_client(profile_key) + identities = [tuple(i) for i in identities] if identities else None + return defer.ensureDeferred(self.find_by_features( + client, namespaces, identities, bare_jids, service, roster, own_jid, + local_device)) + + async def find_by_features( + self, + client: SatXMPPEntity, + namespaces: List[str], + identities: Optional[List[Tuple[str, str]]]=None, + bare_jids: bool=False, + service: bool=True, + roster: bool=True, + own_jid: bool=True, + local_device: bool=False + ) -> Tuple[ + Dict[jid.JID, Tuple[str, str, str]], + Dict[jid.JID, Tuple[str, str, str]], + Dict[jid.JID, Tuple[str, str, str]] + ]: + """Retrieve all services or contacts managing a set a features + + @param namespaces: features which must be handled + @param identities: if not None or empty, + only keep those identities + tuple must be (category, type) + @param bare_jids: retrieve only bare_jids if True + if False, retrieve full jid of connected devices + @param service: if True return service from our server + @param roster: if True, return entities in roster + full jid of all matching resources available will be returned + @param own_jid: if True, return profile's jid resources + @param local_device: if True, return profile's jid local resource + (i.e. client.jid) + @return: found entities in a tuple with: + - service entities + - own entities + - roster entities + Each element is a dict mapping from jid to a tuple with category, type and + name of the entity + """ + assert isinstance(namespaces, list) + if not identities: + identities = None + if not namespaces and not identities: + raise exceptions.DataError( + "at least one namespace or one identity must be set" + ) + found_service = {} + found_own = {} + found_roster = {} + if service: + services_jids = await self.find_features_set(client, namespaces) + services_jids = list(services_jids) # we need a list to map results below + services_infos = await defer.DeferredList( + [self.get_disco_infos(client, service_jid) for service_jid in services_jids] + ) + + for idx, (success, infos) in enumerate(services_infos): + service_jid = services_jids[idx] + if not success: + log.warning( + _("Can't find features for service {service_jid}, ignoring") + .format(service_jid=service_jid.full())) + continue + if (identities is not None + and not set(infos.identities.keys()).issuperset(identities)): + continue + found_identities = [ + (cat, type_, name or "") + for (cat, type_), name in infos.identities.items() + ] + found_service[service_jid.full()] = found_identities + + to_find = [] + if own_jid: + to_find.append((found_own, [client.jid.userhostJID()])) + if roster: + to_find.append((found_roster, client.roster.get_jids())) + + for found, jids in to_find: + full_jids = [] + disco_defers = [] + + for jid_ in jids: + if jid_.resource: + if bare_jids: + continue + resources = [jid_.resource] + else: + if bare_jids: + resources = [None] + else: + try: + resources = self.memory.get_available_resources(client, jid_) + except exceptions.UnknownEntityError: + continue + if not resources and jid_ == client.jid.userhostJID() and own_jid: + # small hack to avoid missing our own resource when this + # method is called at the very beginning of the session + # and our presence has not been received yet + resources = [client.jid.resource] + for resource in resources: + full_jid = jid.JID(tuple=(jid_.user, jid_.host, resource)) + if full_jid == client.jid and not local_device: + continue + full_jids.append(full_jid) + + disco_defers.append(self.get_disco_infos(client, full_jid)) + + d_list = defer.DeferredList(disco_defers) + # XXX: 10 seconds may be too low for slow connections (e.g. mobiles) + # but for discovery, that's also the time the user will wait the first time + # before seing the page, if something goes wrong. + d_list.addTimeout(10, reactor) + infos_data = await d_list + + for idx, (success, infos) in enumerate(infos_data): + full_jid = full_jids[idx] + if not success: + log.warning( + _("Can't retrieve {full_jid} infos, ignoring") + .format(full_jid=full_jid.full())) + continue + if infos.features.issuperset(namespaces): + if identities is not None and not set( + infos.identities.keys() + ).issuperset(identities): + continue + found_identities = [ + (cat, type_, name or "") + for (cat, type_), name in infos.identities.items() + ] + found[full_jid.full()] = found_identities + + return (found_service, found_own, found_roster) + + ## Generic HMI ## + + def _kill_action(self, keep_id, client): + log.debug("Killing action {} for timeout".format(keep_id)) + client.actions[keep_id] + + def action_new( + self, + action_data, + security_limit=C.NO_SECURITY_LIMIT, + keep_id=None, + profile=C.PROF_KEY_NONE, + ): + """Shortcut to bridge.action_new which generate an id and keep for retrieval + + @param action_data(dict): action data (see bridge documentation) + @param security_limit: %(doc_security_limit)s + @param keep_id(None, unicode): if not None, used to keep action for differed + retrieval. The value will be used as callback_id, be sure to use an unique + value. + Action will be deleted after 30 min. + @param profile: %(doc_profile)s + """ + if keep_id is not None: + id_ = keep_id + client = self.get_client(profile) + action_timer = reactor.callLater(60 * 30, self._kill_action, keep_id, client) + client.actions[keep_id] = (action_data, id_, security_limit, action_timer) + else: + id_ = str(uuid.uuid4()) + + self.bridge.action_new( + data_format.serialise(action_data), id_, security_limit, profile + ) + + def actions_get(self, profile): + """Return current non answered actions + + @param profile: %(doc_profile)s + """ + client = self.get_client(profile) + return [ + (data_format.serialise(action_tuple[0]), *action_tuple[1:-1]) + for action_tuple in client.actions.values() + ] + + def register_progress_cb( + self, progress_id, callback, metadata=None, profile=C.PROF_KEY_NONE + ): + """Register a callback called when progress is requested for id""" + if metadata is None: + metadata = {} + client = self.get_client(profile) + if progress_id in client._progress_cb: + raise exceptions.ConflictError("Progress ID is not unique !") + client._progress_cb[progress_id] = (callback, metadata) + + def remove_progress_cb(self, progress_id, profile): + """Remove a progress callback""" + client = self.get_client(profile) + try: + del client._progress_cb[progress_id] + except KeyError: + log.error(_("Trying to remove an unknow progress callback")) + + def _progress_get(self, progress_id, profile): + data = self.progress_get(progress_id, profile) + return {k: str(v) for k, v in data.items()} + + def progress_get(self, progress_id, profile): + """Return a dict with progress information + + @param progress_id(unicode): unique id of the progressing element + @param profile: %(doc_profile)s + @return (dict): data with the following keys: + 'position' (int): current possition + 'size' (int): end_position + if id doesn't exists (may be a finished progression), and empty dict is + returned + """ + client = self.get_client(profile) + try: + data = client._progress_cb[progress_id][0](progress_id, profile) + except KeyError: + data = {} + return data + + def _progress_get_all(self, profile_key): + progress_all = self.progress_get_all(profile_key) + for profile, progress_dict in progress_all.items(): + for progress_id, data in progress_dict.items(): + for key, value in data.items(): + data[key] = str(value) + return progress_all + + def progress_get_all_metadata(self, profile_key): + """Return all progress metadata at once + + @param profile_key: %(doc_profile)s + if C.PROF_KEY_ALL is used, all progress metadata from all profiles are + returned + @return (dict[dict[dict]]): a dict which map profile to progress_dict + progress_dict map progress_id to progress_data + progress_metadata is the same dict as sent by [progress_started] + """ + clients = self.get_clients(profile_key) + progress_all = {} + for client in clients: + profile = client.profile + progress_dict = {} + progress_all[profile] = progress_dict + for ( + progress_id, + (__, progress_metadata), + ) in client._progress_cb.items(): + progress_dict[progress_id] = progress_metadata + return progress_all + + def progress_get_all(self, profile_key): + """Return all progress status at once + + @param profile_key: %(doc_profile)s + if C.PROF_KEY_ALL is used, all progress status from all profiles are returned + @return (dict[dict[dict]]): a dict which map profile to progress_dict + progress_dict map progress_id to progress_data + progress_data is the same dict as returned by [progress_get] + """ + clients = self.get_clients(profile_key) + progress_all = {} + for client in clients: + profile = client.profile + progress_dict = {} + progress_all[profile] = progress_dict + for progress_id, (progress_cb, __) in client._progress_cb.items(): + progress_dict[progress_id] = progress_cb(progress_id, profile) + return progress_all + + def register_callback(self, callback, *args, **kwargs): + """Register a callback. + + @param callback(callable): method to call + @param kwargs: can contain: + with_data(bool): True if the callback use the optional data dict + force_id(unicode): id to avoid generated id. Can lead to name conflict, avoid + if possible + one_shot(bool): True to delete callback once it has been called + @return: id of the registered callback + """ + callback_id = kwargs.pop("force_id", None) + if callback_id is None: + callback_id = str(uuid.uuid4()) + else: + if callback_id in self._cb_map: + raise exceptions.ConflictError(_("id already registered")) + self._cb_map[callback_id] = (callback, args, kwargs) + + if "one_shot" in kwargs: # One Shot callback are removed after 30 min + + def purge_callback(): + try: + self.remove_callback(callback_id) + except KeyError: + pass + + reactor.callLater(1800, purge_callback) + + return callback_id + + def remove_callback(self, callback_id): + """ Remove a previously registered callback + @param callback_id: id returned by [register_callback] """ + log.debug("Removing callback [%s]" % callback_id) + del self._cb_map[callback_id] + + def _action_launch( + self, + callback_id: str, + data_s: str, + profile_key: str + ) -> defer.Deferred: + d = self.launch_callback( + callback_id, + data_format.deserialise(data_s), + profile_key + ) + d.addCallback(data_format.serialise) + return d + + def launch_callback( + self, + callback_id: str, + data: Optional[dict] = None, + profile_key: str = C.PROF_KEY_NONE + ) -> defer.Deferred: + """Launch a specific callback + + @param callback_id: id of the action (callback) to launch + @param data: optional data + @profile_key: %(doc_profile_key)s + @return: a deferred which fire a dict where key can be: + - xmlui: a XMLUI need to be displayed + - validated: if present, can be used to launch a callback, it can have the + values + - C.BOOL_TRUE + - C.BOOL_FALSE + """ + # FIXME: is it possible to use this method without profile connected? If not, + # client must be used instead of profile_key + # FIXME: security limit need to be checked here + try: + client = self.get_client(profile_key) + except exceptions.NotFound: + # client is not available yet + profile = self.memory.get_profile_name(profile_key) + if not profile: + raise exceptions.ProfileUnknownError( + _("trying to launch action with a non-existant profile") + ) + else: + profile = client.profile + # we check if the action is kept, and remove it + try: + action_tuple = client.actions[callback_id] + except KeyError: + pass + else: + action_tuple[-1].cancel() # the last item is the action timer + del client.actions[callback_id] + + try: + callback, args, kwargs = self._cb_map[callback_id] + except KeyError: + raise exceptions.DataError("Unknown callback id {}".format(callback_id)) + + if kwargs.get("with_data", False): + if data is None: + raise exceptions.DataError("Required data for this callback is missing") + args, kwargs = ( + list(args)[:], + kwargs.copy(), + ) # we don't want to modify the original (kw)args + args.insert(0, data) + kwargs["profile"] = profile + del kwargs["with_data"] + + if kwargs.pop("one_shot", False): + self.remove_callback(callback_id) + + return utils.as_deferred(callback, *args, **kwargs) + + # Menus management + + def _get_menu_canonical_path(self, path): + """give canonical form of path + + canonical form is a tuple of the path were every element is stripped and lowercase + @param path(iterable[unicode]): untranslated path to menu + @return (tuple[unicode]): canonical form of path + """ + return tuple((p.lower().strip() for p in path)) + + def import_menu(self, path, callback, security_limit=C.NO_SECURITY_LIMIT, + help_string="", type_=C.MENU_GLOBAL): + r"""register a new menu for frontends + + @param path(iterable[unicode]): path to go to the menu + (category/subcategory/.../item) (e.g.: ("File", "Open")) + /!\ use D_() instead of _() for translations (e.g. (D_("File"), D_("Open"))) + untranslated/lower case path can be used to identity a menu, for this reason + it must be unique independently of case. + @param callback(callable): method to be called when menuitem is selected, callable + or a callback id (string) as returned by [register_callback] + @param security_limit(int): %(doc_security_limit)s + /!\ security_limit MUST be added to data in launch_callback if used #TODO + @param help_string(unicode): string used to indicate what the menu do (can be + show as a tooltip). + /!\ use D_() instead of _() for translations + @param type(unicode): one of: + - C.MENU_GLOBAL: classical menu, can be shown in a menubar on top (e.g. + something like File/Open) + - C.MENU_ROOM: like a global menu, but only shown in multi-user chat + menu_data must contain a "room_jid" data + - C.MENU_SINGLE: like a global menu, but only shown in one2one chat + menu_data must contain a "jid" data + - C.MENU_JID_CONTEXT: contextual menu, used with any jid (e.g.: ad hoc + commands, jid is already filled) + menu_data must contain a "jid" data + - C.MENU_ROSTER_JID_CONTEXT: like JID_CONTEXT, but restricted to jids in + roster. + menu_data must contain a "room_jid" data + - C.MENU_ROSTER_GROUP_CONTEXT: contextual menu, used with group (e.g.: publish + microblog, group is already filled) + menu_data must contain a "group" data + @return (unicode): menu_id (same as callback_id) + """ + + if callable(callback): + callback_id = self.register_callback(callback, with_data=True) + elif isinstance(callback, str): + # The callback is already registered + callback_id = callback + try: + callback, args, kwargs = self._cb_map[callback_id] + except KeyError: + raise exceptions.DataError("Unknown callback id") + kwargs["with_data"] = True # we have to be sure that we use extra data + else: + raise exceptions.DataError("Unknown callback type") + + for menu_data in self._menus.values(): + if menu_data["path"] == path and menu_data["type"] == type_: + raise exceptions.ConflictError( + _("A menu with the same path and type already exists") + ) + + path_canonical = self._get_menu_canonical_path(path) + menu_key = (type_, path_canonical) + + if menu_key in self._menus_paths: + raise exceptions.ConflictError( + "this menu path is already used: {path} ({menu_key})".format( + path=path_canonical, menu_key=menu_key + ) + ) + + menu_data = { + "path": tuple(path), + "path_canonical": path_canonical, + "security_limit": security_limit, + "help_string": help_string, + "type": type_, + } + + self._menus[callback_id] = menu_data + self._menus_paths[menu_key] = callback_id + + return callback_id + + def get_menus(self, language="", security_limit=C.NO_SECURITY_LIMIT): + """Return all menus registered + + @param language: language used for translation, or empty string for default + @param security_limit: %(doc_security_limit)s + @return: array of tuple with: + - menu id (same as callback_id) + - menu type + - raw menu path (array of strings) + - translated menu path + - extra (dict(unicode, unicode)): extra data where key can be: + - icon: name of the icon to use (TODO) + - help_url: link to a page with more complete documentation (TODO) + """ + ret = [] + for menu_id, menu_data in self._menus.items(): + type_ = menu_data["type"] + path = menu_data["path"] + menu_security_limit = menu_data["security_limit"] + if security_limit != C.NO_SECURITY_LIMIT and ( + menu_security_limit == C.NO_SECURITY_LIMIT + or menu_security_limit > security_limit + ): + continue + language_switch(language) + path_i18n = [_(elt) for elt in path] + language_switch() + extra = {} # TODO: manage extra data like icon + ret.append((menu_id, type_, path, path_i18n, extra)) + + return ret + + def _launch_menu(self, menu_type, path, data=None, security_limit=C.NO_SECURITY_LIMIT, + profile_key=C.PROF_KEY_NONE): + client = self.get_client(profile_key) + return self.launch_menu(client, menu_type, path, data, security_limit) + + def launch_menu(self, client, menu_type, path, data=None, + security_limit=C.NO_SECURITY_LIMIT): + """launch action a menu action + + @param menu_type(unicode): type of menu to launch + @param path(iterable[unicode]): canonical path of the menu + @params data(dict): menu data + @raise NotFound: this path is not known + """ + # FIXME: manage security_limit here + # defaut security limit should be high instead of C.NO_SECURITY_LIMIT + canonical_path = self._get_menu_canonical_path(path) + menu_key = (menu_type, canonical_path) + try: + callback_id = self._menus_paths[menu_key] + except KeyError: + raise exceptions.NotFound( + "Can't find menu {path} ({menu_type})".format( + path=canonical_path, menu_type=menu_type + ) + ) + return self.launch_callback(callback_id, data, client.profile) + + def get_menu_help(self, menu_id, language=""): + """return the help string of the menu + + @param menu_id: id of the menu (same as callback_id) + @param language: language used for translation, or empty string for default + @param return: translated help + + """ + try: + menu_data = self._menus[menu_id] + except KeyError: + raise exceptions.DataError("Trying to access an unknown menu") + language_switch(language) + help_string = _(menu_data["help_string"]) + language_switch() + return help_string diff -r 040095a5dc7f -r 7c5654c54fed libervia/backend/core/sat_main.py --- a/libervia/backend/core/sat_main.py Fri Jun 02 11:55:48 2023 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,1666 +0,0 @@ -#!/usr/bin/env python3 - -# Libervia: an XMPP client -# Copyright (C) 2009-2021 Jérôme Poisson (goffi@goffi.org) - -# This program is free software: you can redistribute it and/or modify -# it under the terms of the GNU Affero General Public License as published by -# the Free Software Foundation, either version 3 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 Affero General Public License for more details. - -# You should have received a copy of the GNU Affero General Public License -# along with this program. If not, see . - -import sys -import os.path -import uuid -import hashlib -import copy -from pathlib import Path -from typing import Optional, List, Tuple, Dict - -from wokkel.data_form import Option -from libervia import backend -from libervia.backend.core.i18n import _, D_, language_switch -from libervia.backend.core import patches -patches.apply() -from twisted.application import service -from twisted.internet import defer -from twisted.words.protocols.jabber import jid -from twisted.internet import reactor -from wokkel.xmppim import RosterItem -from libervia.backend.core import xmpp -from libervia.backend.core import exceptions -from libervia.backend.core.core_types import SatXMPPEntity -from libervia.backend.core.log import getLogger - -from libervia.backend.core.constants import Const as C -from libervia.backend.memory import memory -from libervia.backend.memory import cache -from libervia.backend.memory import encryption -from libervia.backend.tools import async_trigger as trigger -from libervia.backend.tools import utils -from libervia.backend.tools import image -from libervia.backend.tools.common import dynamic_import -from libervia.backend.tools.common import regex -from libervia.backend.tools.common import data_format -from libervia.backend.stdui import ui_contact_list, ui_profile_manager -import libervia.backend.plugins - - -log = getLogger(__name__) - -class LiberviaBackend(service.Service): - - def _init(self): - # we don't use __init__ to avoid doule initialisation with twistd - # this _init is called in startService - log.info(f"{C.APP_NAME} {self.full_version}") - self._cb_map = {} # map from callback_id to callbacks - # dynamic menus. key: callback_id, value: menu data (dictionnary) - self._menus = {} - self._menus_paths = {} # path to id. key: (menu_type, lower case tuple of path), - # value: menu id - self.initialised = defer.Deferred() - self.profiles = {} - self.plugins = {} - # map for short name to whole namespace, - # extended by plugins with register_namespace - self.ns_map = { - "x-data": xmpp.NS_X_DATA, - "disco#info": xmpp.NS_DISCO_INFO, - } - - self.memory = memory.Memory(self) - - # trigger are used to change Libervia behaviour - self.trigger = ( - trigger.TriggerManager() - ) - - bridge_name = ( - os.getenv("LIBERVIA_BRIDGE_NAME") - or self.memory.config_get("", "bridge", "dbus") - ) - - bridge_module = dynamic_import.bridge(bridge_name) - if bridge_module is None: - log.error(f"Can't find bridge module of name {bridge_name}") - sys.exit(1) - log.info(f"using {bridge_name} bridge") - try: - self.bridge = bridge_module.bridge() - except exceptions.BridgeInitError: - log.exception("bridge can't be initialised, can't start Libervia Backend") - sys.exit(1) - - defer.ensureDeferred(self._post_init()) - - @property - def version(self): - """Return the short version of Libervia""" - return C.APP_VERSION - - @property - def full_version(self): - """Return the full version of Libervia - - In developement mode, release name and extra data are returned too - """ - version = self.version - if version[-1] == "D": - # we are in debug version, we add extra data - try: - return self._version_cache - except AttributeError: - self._version_cache = "{} « {} » ({})".format( - version, C.APP_RELEASE_NAME, utils.get_repository_data(backend) - ) - return self._version_cache - else: - return version - - @property - def bridge_name(self): - return os.path.splitext(os.path.basename(self.bridge.__file__))[0] - - async def _post_init(self): - try: - bridge_pi = self.bridge.post_init - except AttributeError: - pass - else: - try: - await bridge_pi() - except Exception: - log.exception("Could not initialize bridge") - # because init is not complete at this stage, we use callLater - reactor.callLater(0, self.stop) - return - - self.bridge.register_method("ready_get", lambda: self.initialised) - self.bridge.register_method("version_get", lambda: self.full_version) - self.bridge.register_method("features_get", self.features_get) - self.bridge.register_method("profile_name_get", self.memory.get_profile_name) - self.bridge.register_method("profiles_list_get", self.memory.get_profiles_list) - self.bridge.register_method("entity_data_get", self.memory._get_entity_data) - self.bridge.register_method("entities_data_get", self.memory._get_entities_data) - self.bridge.register_method("profile_create", self.memory.create_profile) - self.bridge.register_method("profile_delete_async", self.memory.profile_delete_async) - self.bridge.register_method("profile_start_session", self.memory.start_session) - self.bridge.register_method( - "profile_is_session_started", self.memory._is_session_started - ) - self.bridge.register_method("profile_set_default", self.memory.profile_set_default) - self.bridge.register_method("connect", self._connect) - self.bridge.register_method("disconnect", self.disconnect) - self.bridge.register_method("contact_get", self._contact_get) - self.bridge.register_method("contacts_get", self.contacts_get) - self.bridge.register_method("contacts_get_from_group", self.contacts_get_from_group) - self.bridge.register_method("main_resource_get", self.memory._get_main_resource) - self.bridge.register_method( - "presence_statuses_get", self.memory._get_presence_statuses - ) - self.bridge.register_method("sub_waiting_get", self.memory.sub_waiting_get) - self.bridge.register_method("message_send", self._message_send) - self.bridge.register_method("message_encryption_start", - self._message_encryption_start) - self.bridge.register_method("message_encryption_stop", - self._message_encryption_stop) - self.bridge.register_method("message_encryption_get", - self._message_encryption_get) - self.bridge.register_method("encryption_namespace_get", - self._encryption_namespace_get) - self.bridge.register_method("encryption_plugins_get", self._encryption_plugins_get) - self.bridge.register_method("encryption_trust_ui_get", self._encryption_trust_ui_get) - self.bridge.register_method("config_get", self._get_config) - self.bridge.register_method("param_set", self.param_set) - self.bridge.register_method("param_get_a", self.memory.get_string_param_a) - self.bridge.register_method("private_data_get", self.memory._private_data_get) - self.bridge.register_method("private_data_set", self.memory._private_data_set) - self.bridge.register_method("private_data_delete", self.memory._private_data_delete) - self.bridge.register_method("param_get_a_async", self.memory.async_get_string_param_a) - self.bridge.register_method( - "params_values_from_category_get_async", - self.memory._get_params_values_from_category, - ) - self.bridge.register_method("param_ui_get", self.memory._get_params_ui) - self.bridge.register_method( - "params_categories_get", self.memory.params_categories_get - ) - self.bridge.register_method("params_register_app", self.memory.params_register_app) - self.bridge.register_method("history_get", self.memory._history_get) - self.bridge.register_method("presence_set", self._set_presence) - self.bridge.register_method("subscription", self.subscription) - self.bridge.register_method("contact_add", self._add_contact) - self.bridge.register_method("contact_update", self._update_contact) - self.bridge.register_method("contact_del", self._del_contact) - self.bridge.register_method("roster_resync", self._roster_resync) - self.bridge.register_method("is_connected", self.is_connected) - self.bridge.register_method("action_launch", self._action_launch) - self.bridge.register_method("actions_get", self.actions_get) - self.bridge.register_method("progress_get", self._progress_get) - self.bridge.register_method("progress_get_all", self._progress_get_all) - self.bridge.register_method("menus_get", self.get_menus) - self.bridge.register_method("menu_help_get", self.get_menu_help) - self.bridge.register_method("menu_launch", self._launch_menu) - self.bridge.register_method("disco_infos", self.memory.disco._disco_infos) - self.bridge.register_method("disco_items", self.memory.disco._disco_items) - self.bridge.register_method("disco_find_by_features", self._find_by_features) - self.bridge.register_method("params_template_save", self.memory.save_xml) - self.bridge.register_method("params_template_load", self.memory.load_xml) - self.bridge.register_method("session_infos_get", self.get_session_infos) - self.bridge.register_method("devices_infos_get", self._get_devices_infos) - self.bridge.register_method("namespaces_get", self.get_namespaces) - self.bridge.register_method("image_check", self._image_check) - self.bridge.register_method("image_resize", self._image_resize) - self.bridge.register_method("image_generate_preview", self._image_generate_preview) - self.bridge.register_method("image_convert", self._image_convert) - - - await self.memory.initialise() - self.common_cache = cache.Cache(self, None) - log.info(_("Memory initialised")) - try: - self._import_plugins() - ui_contact_list.ContactList(self) - ui_profile_manager.ProfileManager(self) - except Exception as e: - log.error(f"Could not initialize backend: {e}") - sys.exit(1) - self._add_base_menus() - - self.initialised.callback(None) - log.info(_("Backend is ready")) - - # profile autoconnection must be done after self.initialised is called because - # start_session waits for it. - autoconnect_dict = await self.memory.storage.get_ind_param_values( - category='Connection', name='autoconnect_backend', - ) - profiles_autoconnect = [p for p, v in autoconnect_dict.items() if C.bool(v)] - if not self.trigger.point("profilesAutoconnect", profiles_autoconnect): - return - if profiles_autoconnect: - log.info(D_( - "Following profiles will be connected automatically: {profiles}" - ).format(profiles= ', '.join(profiles_autoconnect))) - connect_d_list = [] - for profile in profiles_autoconnect: - connect_d_list.append(defer.ensureDeferred(self.connect(profile))) - - if connect_d_list: - results = await defer.DeferredList(connect_d_list) - for idx, (success, result) in enumerate(results): - if not success: - profile = profiles_autoconnect[0] - log.warning( - _("Can't autoconnect profile {profile}: {reason}").format( - profile = profile, - reason = result) - ) - - def _add_base_menus(self): - """Add base menus""" - encryption.EncryptionHandler._import_menus(self) - - def _unimport_plugin(self, plugin_path): - """remove a plugin from sys.modules if it is there""" - try: - del sys.modules[plugin_path] - except KeyError: - pass - - def _import_plugins(self): - """import all plugins found in plugins directory""" - # FIXME: module imported but cancelled should be deleted - # TODO: make this more generic and reusable in tools.common - # FIXME: should use imp - # TODO: do not import all plugins if no needed: component plugins are not needed - # if we just use a client, and plugin blacklisting should be possible in - # libervia.conf - plugins_path = Path(libervia.backend.plugins.__file__).parent - plugins_to_import = {} # plugins we still have to import - for plug_path in plugins_path.glob("plugin_*"): - if plug_path.is_dir(): - init_path = plug_path / f"__init__.{C.PLUGIN_EXT}" - if not init_path.exists(): - log.warning( - f"{plug_path} doesn't appear to be a package, can't load it") - continue - plug_name = plug_path.name - elif plug_path.is_file(): - if plug_path.suffix != f".{C.PLUGIN_EXT}": - continue - plug_name = plug_path.stem - else: - log.warning( - f"{plug_path} is not a file or a dir, ignoring it") - continue - if not plug_name.isidentifier(): - log.warning( - f"{plug_name!r} is not a valid name for a plugin, ignoring it") - continue - plugin_path = f"libervia.backend.plugins.{plug_name}" - try: - __import__(plugin_path) - except exceptions.MissingModule as e: - self._unimport_plugin(plugin_path) - log.warning( - "Can't import plugin [{path}] because of an unavailale third party " - "module:\n{msg}".format( - path=plugin_path, msg=e - ) - ) - continue - except exceptions.CancelError as e: - log.info( - "Plugin [{path}] cancelled its own import: {msg}".format( - path=plugin_path, msg=e - ) - ) - self._unimport_plugin(plugin_path) - continue - except Exception: - import traceback - - log.error( - _("Can't import plugin [{path}]:\n{error}").format( - path=plugin_path, error=traceback.format_exc() - ) - ) - self._unimport_plugin(plugin_path) - continue - mod = sys.modules[plugin_path] - plugin_info = mod.PLUGIN_INFO - import_name = plugin_info["import_name"] - - plugin_modes = plugin_info["modes"] = set( - plugin_info.setdefault("modes", C.PLUG_MODE_DEFAULT) - ) - if not plugin_modes.intersection(C.PLUG_MODE_BOTH): - log.error( - f"Can't import plugin at {plugin_path}, invalid {C.PI_MODES!r} " - f"value: {plugin_modes!r}" - ) - continue - - # if the plugin is an entry point, it must work in component mode - if plugin_info["type"] == C.PLUG_TYPE_ENTRY_POINT: - # if plugin is an entrypoint, we cache it - if C.PLUG_MODE_COMPONENT not in plugin_modes: - log.error( - _( - "{type} type must be used with {mode} mode, ignoring plugin" - ).format(type=C.PLUG_TYPE_ENTRY_POINT, mode=C.PLUG_MODE_COMPONENT) - ) - self._unimport_plugin(plugin_path) - continue - - if import_name in plugins_to_import: - log.error( - _( - "Name conflict for import name [{import_name}], can't import " - "plugin [{name}]" - ).format(**plugin_info) - ) - continue - plugins_to_import[import_name] = (plugin_path, mod, plugin_info) - while True: - try: - self._import_plugins_from_dict(plugins_to_import) - except ImportError: - pass - if not plugins_to_import: - break - - def _import_plugins_from_dict( - self, plugins_to_import, import_name=None, optional=False - ): - """Recursively import and their dependencies in the right order - - @param plugins_to_import(dict): key=import_name and values=(plugin_path, module, - plugin_info) - @param import_name(unicode, None): name of the plugin to import as found in - PLUGIN_INFO['import_name'] - @param optional(bool): if False and plugin is not found, an ImportError exception - is raised - """ - if import_name in self.plugins: - log.debug("Plugin {} already imported, passing".format(import_name)) - return - if not import_name: - import_name, (plugin_path, mod, plugin_info) = plugins_to_import.popitem() - else: - if not import_name in plugins_to_import: - if optional: - log.warning( - _("Recommended plugin not found: {}").format(import_name) - ) - return - msg = "Dependency not found: {}".format(import_name) - log.error(msg) - raise ImportError(msg) - plugin_path, mod, plugin_info = plugins_to_import.pop(import_name) - dependencies = plugin_info.setdefault("dependencies", []) - recommendations = plugin_info.setdefault("recommendations", []) - for to_import in dependencies + recommendations: - if to_import not in self.plugins: - log.debug( - "Recursively import dependency of [%s]: [%s]" - % (import_name, to_import) - ) - try: - self._import_plugins_from_dict( - plugins_to_import, to_import, to_import not in dependencies - ) - except ImportError as e: - log.warning( - _("Can't import plugin {name}: {error}").format( - name=plugin_info["name"], error=e - ) - ) - if optional: - return - raise e - log.info("importing plugin: {}".format(plugin_info["name"])) - # we instanciate the plugin here - try: - self.plugins[import_name] = getattr(mod, plugin_info["main"])(self) - except Exception as e: - log.exception( - f"Can't load plugin \"{plugin_info['name']}\", ignoring it: {e}" - ) - if optional: - return - raise ImportError("Error during initiation") - if C.bool(plugin_info.get(C.PI_HANDLER, C.BOOL_FALSE)): - self.plugins[import_name].is_handler = True - else: - self.plugins[import_name].is_handler = False - # we keep metadata as a Class attribute - self.plugins[import_name]._info = plugin_info - # TODO: test xmppclient presence and register handler parent - - def plugins_unload(self): - """Call unload method on every loaded plugin, if exists - - @return (D): A deferred which return None when all method have been called - """ - # TODO: in the futur, it should be possible to hot unload a plugin - # pluging depending on the unloaded one should be unloaded too - # for now, just a basic call on plugin.unload is done - defers_list = [] - for plugin in self.plugins.values(): - try: - unload = plugin.unload - except AttributeError: - continue - else: - defers_list.append(utils.as_deferred(unload)) - return defers_list - - def _connect(self, profile_key, password="", options=None): - profile = self.memory.get_profile_name(profile_key) - return defer.ensureDeferred(self.connect(profile, password, options)) - - async def connect( - self, profile, password="", options=None, max_retries=C.XMPP_MAX_RETRIES): - """Connect a profile (i.e. connect client.component to XMPP server) - - Retrieve the individual parameters, authenticate the profile - and initiate the connection to the associated XMPP server. - @param profile: %(doc_profile)s - @param password (string): the Libervia profile password - @param options (dict): connection options. Key can be: - - - @param max_retries (int): max number of connection retries - @return (D(bool)): - - True if the XMPP connection was already established - - False if the XMPP connection has been initiated (it may still fail) - @raise exceptions.PasswordError: Profile password is wrong - """ - if options is None: - options = {} - - await self.memory.start_session(password, profile) - - if self.is_connected(profile): - log.info(_("already connected !")) - return True - - if self.memory.is_component(profile): - await xmpp.SatXMPPComponent.start_connection(self, profile, max_retries) - else: - await xmpp.SatXMPPClient.start_connection(self, profile, max_retries) - - return False - - def disconnect(self, profile_key): - """disconnect from jabber server""" - # FIXME: client should not be deleted if only disconnected - # it shoud be deleted only when session is finished - if not self.is_connected(profile_key): - # is_connected is checked here and not on client - # because client is deleted when session is ended - log.info(_("not connected !")) - return defer.succeed(None) - client = self.get_client(profile_key) - return client.entity_disconnect() - - def features_get(self, profile_key=C.PROF_KEY_NONE): - """Get available features - - Return list of activated plugins and plugin specific data - @param profile_key: %(doc_profile_key)s - C.PROF_KEY_NONE can be used to have general plugins data (i.e. not profile - dependent) - @return (dict)[Deferred]: features data where: - - key is plugin import name, present only for activated plugins - - value is a an other dict, when meaning is specific to each plugin. - this dict is return by plugin's getFeature method. - If this method doesn't exists, an empty dict is returned. - """ - try: - # FIXME: there is no method yet to check profile session - # as soon as one is implemented, it should be used here - self.get_client(profile_key) - except KeyError: - log.warning("Requesting features for a profile outside a session") - profile_key = C.PROF_KEY_NONE - except exceptions.ProfileNotSetError: - pass - - features = [] - for import_name, plugin in self.plugins.items(): - try: - features_d = utils.as_deferred(plugin.features_get, profile_key) - except AttributeError: - features_d = defer.succeed({}) - features.append(features_d) - - d_list = defer.DeferredList(features) - - def build_features(result, import_names): - assert len(result) == len(import_names) - ret = {} - for name, (success, data) in zip(import_names, result): - if success: - ret[name] = data - else: - log.warning( - "Error while getting features for {name}: {failure}".format( - name=name, failure=data - ) - ) - ret[name] = {} - return ret - - d_list.addCallback(build_features, list(self.plugins.keys())) - return d_list - - def _contact_get(self, entity_jid_s, profile_key): - client = self.get_client(profile_key) - entity_jid = jid.JID(entity_jid_s) - return defer.ensureDeferred(self.get_contact(client, entity_jid)) - - async def get_contact(self, client, entity_jid): - # we want to be sure that roster has been received - await client.roster.got_roster - item = client.roster.get_item(entity_jid) - if item is None: - raise exceptions.NotFound(f"{entity_jid} is not in roster!") - return (client.roster.get_attributes(item), list(item.groups)) - - def contacts_get(self, profile_key): - client = self.get_client(profile_key) - - def got_roster(__): - ret = [] - for item in client.roster.get_items(): # we get all items for client's roster - # and convert them to expected format - attr = client.roster.get_attributes(item) - # we use full() and not userhost() because jid with resources are allowed - # in roster, even if it's not common. - ret.append([item.entity.full(), attr, list(item.groups)]) - return ret - - return client.roster.got_roster.addCallback(got_roster) - - def contacts_get_from_group(self, group, profile_key): - client = self.get_client(profile_key) - return [jid_.full() for jid_ in client.roster.get_jids_from_group(group)] - - def purge_entity(self, profile): - """Remove reference to a profile client/component and purge cache - - the garbage collector can then free the memory - """ - try: - del self.profiles[profile] - except KeyError: - log.error(_("Trying to remove reference to a client not referenced")) - else: - self.memory.purge_profile_session(profile) - - def startService(self): - self._init() - log.info("Salut à toi ô mon frère !") - - def stopService(self): - log.info("Salut aussi à Rantanplan") - return self.plugins_unload() - - def run(self): - log.debug(_("running app")) - reactor.run() - - def stop(self): - log.debug(_("stopping app")) - reactor.stop() - - ## Misc methods ## - - def get_jid_n_stream(self, profile_key): - """Convenient method to get jid and stream from profile key - @return: tuple (jid, xmlstream) from profile, can be None""" - # TODO: deprecate this method (get_client is enough) - profile = self.memory.get_profile_name(profile_key) - if not profile or not self.profiles[profile].is_connected(): - return (None, None) - return (self.profiles[profile].jid, self.profiles[profile].xmlstream) - - def get_client(self, profile_key: str) -> xmpp.SatXMPPClient: - """Convenient method to get client from profile key - - @return: the client - @raise exceptions.ProfileKeyUnknown: the profile or profile key doesn't exist - @raise exceptions.NotFound: client is not available - This happen if profile has not been used yet - """ - profile = self.memory.get_profile_name(profile_key) - if not profile: - raise exceptions.ProfileKeyUnknown - try: - return self.profiles[profile] - except KeyError: - raise exceptions.NotFound(profile_key) - - def get_clients(self, profile_key): - """Convenient method to get list of clients from profile key - - Manage list through profile_key like C.PROF_KEY_ALL - @param profile_key: %(doc_profile_key)s - @return: list of clients - """ - if not profile_key: - raise exceptions.DataError(_("profile_key must not be empty")) - try: - profile = self.memory.get_profile_name(profile_key, True) - except exceptions.ProfileUnknownError: - return [] - if profile == C.PROF_KEY_ALL: - return list(self.profiles.values()) - elif profile[0] == "@": #  only profile keys can start with "@" - raise exceptions.ProfileKeyUnknown - return [self.profiles[profile]] - - def _get_config(self, section, name): - """Get the main configuration option - - @param section: section of the config file (None or '' for DEFAULT) - @param name: name of the option - @return: unicode representation of the option - """ - return str(self.memory.config_get(section, name, "")) - - def log_errback(self, failure_, msg=_("Unexpected error: {failure_}")): - """Generic errback logging - - @param msg(unicode): error message ("failure_" key will be use for format) - can be used as last errback to show unexpected error - """ - log.error(msg.format(failure_=failure_)) - return failure_ - - #  namespaces - - def register_namespace(self, short_name, namespace): - """associate a namespace to a short name""" - if short_name in self.ns_map: - raise exceptions.ConflictError("this short name is already used") - log.debug(f"registering namespace {short_name} => {namespace}") - self.ns_map[short_name] = namespace - - def get_namespaces(self): - return self.ns_map - - def get_namespace(self, short_name): - try: - return self.ns_map[short_name] - except KeyError: - raise exceptions.NotFound("namespace {short_name} is not registered" - .format(short_name=short_name)) - - def get_session_infos(self, profile_key): - """compile interesting data on current profile session""" - client = self.get_client(profile_key) - data = { - "jid": client.jid.full(), - "started": str(int(client.started)) - } - return defer.succeed(data) - - def _get_devices_infos(self, bare_jid, profile_key): - client = self.get_client(profile_key) - if not bare_jid: - bare_jid = None - d = defer.ensureDeferred(self.get_devices_infos(client, bare_jid)) - d.addCallback(lambda data: data_format.serialise(data)) - return d - - async def get_devices_infos(self, client, bare_jid=None): - """compile data on an entity devices - - @param bare_jid(jid.JID, None): bare jid of entity to check - None to use client own jid - @return (list[dict]): list of data, one item per resource. - Following keys can be set: - - resource(str): resource name - """ - own_jid = client.jid.userhostJID() - if bare_jid is None: - bare_jid = own_jid - else: - bare_jid = jid.JID(bare_jid) - resources = self.memory.get_all_resources(client, bare_jid) - if bare_jid == own_jid: - # our own jid is not stored in memory's cache - resources.add(client.jid.resource) - ret_data = [] - for resource in resources: - res_jid = copy.copy(bare_jid) - res_jid.resource = resource - cache_data = self.memory.entity_data_get(client, res_jid) - res_data = { - "resource": resource, - } - try: - presence = cache_data['presence'] - except KeyError: - pass - else: - res_data['presence'] = { - "show": presence.show, - "priority": presence.priority, - "statuses": presence.statuses, - } - - disco = await self.get_disco_infos(client, res_jid) - - for (category, type_), name in disco.identities.items(): - identities = res_data.setdefault('identities', []) - identities.append({ - "name": name, - "category": category, - "type": type_, - }) - - ret_data.append(res_data) - - return ret_data - - # images - - def _image_check(self, path): - report = image.check(self, path) - return data_format.serialise(report) - - def _image_resize(self, path, width, height): - d = image.resize(path, (width, height)) - d.addCallback(lambda new_image_path: str(new_image_path)) - return d - - def _image_generate_preview(self, path, profile_key): - client = self.get_client(profile_key) - d = defer.ensureDeferred(self.image_generate_preview(client, Path(path))) - d.addCallback(lambda preview_path: str(preview_path)) - return d - - async def image_generate_preview(self, client, path): - """Helper method to generate in cache a preview of an image - - @param path(Path): path to the image - @return (Path): path to the generated preview - """ - report = image.check(self, path, max_size=(300, 300)) - - if not report['too_large']: - # in the unlikely case that image is already smaller than a preview - preview_path = path - else: - # we use hash as id, to re-use potentially existing preview - path_hash = hashlib.sha256(str(path).encode()).hexdigest() - uid = f"{path.stem}_{path_hash}_preview" - filename = f"{uid}{path.suffix.lower()}" - metadata = client.cache.get_metadata(uid=uid) - if metadata is not None: - preview_path = metadata['path'] - else: - with client.cache.cache_data( - source='HOST_PREVIEW', - uid=uid, - filename=filename) as cache_f: - - preview_path = await image.resize( - path, - new_size=report['recommended_size'], - dest=cache_f - ) - - return preview_path - - def _image_convert(self, source, dest, extra, profile_key): - client = self.get_client(profile_key) if profile_key else None - source = Path(source) - dest = None if not dest else Path(dest) - extra = data_format.deserialise(extra) - d = defer.ensureDeferred(self.image_convert(client, source, dest, extra)) - d.addCallback(lambda dest_path: str(dest_path)) - return d - - async def image_convert(self, client, source, dest=None, extra=None): - """Helper method to convert an image from one format to an other - - @param client(SatClient, None): client to use for caching - this parameter is only used if dest is None - if client is None, common cache will be used insted of profile cache - @param source(Path): path to the image to convert - @param dest(None, Path, file): where to save the converted file - - None: use a cache file (uid generated from hash of source) - file will be converted to PNG - - Path: path to the file to create/overwrite - - file: a file object which must be opened for writing in binary mode - @param extra(dict, None): conversion options - see [image.convert] for details - @return (Path): path to the converted image - @raise ValueError: an issue happened with source of dest - """ - if not source.is_file: - raise ValueError(f"Source file {source} doesn't exist!") - if dest is None: - # we use hash as id, to re-use potentially existing conversion - path_hash = hashlib.sha256(str(source).encode()).hexdigest() - uid = f"{source.stem}_{path_hash}_convert_png" - filename = f"{uid}.png" - if client is None: - cache = self.common_cache - else: - cache = client.cache - metadata = cache.get_metadata(uid=uid) - if metadata is not None: - # there is already a conversion for this image in cache - return metadata['path'] - else: - with cache.cache_data( - source='HOST_IMAGE_CONVERT', - uid=uid, - filename=filename) as cache_f: - - converted_path = await image.convert( - source, - dest=cache_f, - extra=extra - ) - return converted_path - else: - return await image.convert(source, dest, extra) - - - # local dirs - - def get_local_path( - self, - client: Optional[SatXMPPEntity], - dir_name: str, - *extra_path: str, - component: bool = False, - ) -> Path: - """Retrieve path for local data - - if path doesn't exist, it will be created - @param client: client instance - if not none, client.profile will be used as last path element - @param dir_name: name of the main path directory - @param *extra_path: extra path element(s) to use - @param component: if True, path will be prefixed with C.COMPONENTS_DIR - @return: path - """ - local_dir = self.memory.config_get("", "local_dir") - if not local_dir: - raise exceptions.InternalError("local_dir must be set") - path_elts = [] - if component: - path_elts.append(C.COMPONENTS_DIR) - path_elts.append(regex.path_escape(dir_name)) - if extra_path: - path_elts.extend([regex.path_escape(p) for p in extra_path]) - if client is not None: - path_elts.append(regex.path_escape(client.profile)) - local_path = Path(*path_elts) - local_path.mkdir(0o700, parents=True, exist_ok=True) - return local_path - - ## Client management ## - - def param_set(self, name, value, category, security_limit, profile_key): - """set wanted paramater and notice observers""" - self.memory.param_set(name, value, category, security_limit, profile_key) - - def is_connected(self, profile_key): - """Return connection status of profile - - @param profile_key: key_word or profile name to determine profile name - @return: True if connected - """ - profile = self.memory.get_profile_name(profile_key) - if not profile: - log.error(_("asking connection status for a non-existant profile")) - raise exceptions.ProfileUnknownError(profile_key) - if profile not in self.profiles: - return False - return self.profiles[profile].is_connected() - - ## Encryption ## - - def register_encryption_plugin(self, *args, **kwargs): - return encryption.EncryptionHandler.register_plugin(*args, **kwargs) - - def _message_encryption_start(self, to_jid_s, namespace, replace=False, - profile_key=C.PROF_KEY_NONE): - client = self.get_client(profile_key) - to_jid = jid.JID(to_jid_s) - return defer.ensureDeferred( - client.encryption.start(to_jid, namespace or None, replace)) - - def _message_encryption_stop(self, to_jid_s, profile_key=C.PROF_KEY_NONE): - client = self.get_client(profile_key) - to_jid = jid.JID(to_jid_s) - return defer.ensureDeferred( - client.encryption.stop(to_jid)) - - def _message_encryption_get(self, to_jid_s, profile_key=C.PROF_KEY_NONE): - client = self.get_client(profile_key) - to_jid = jid.JID(to_jid_s) - session_data = client.encryption.getSession(to_jid) - return client.encryption.get_bridge_data(session_data) - - def _encryption_namespace_get(self, name): - return encryption.EncryptionHandler.get_ns_from_name(name) - - def _encryption_plugins_get(self): - plugins = encryption.EncryptionHandler.getPlugins() - ret = [] - for p in plugins: - ret.append({ - "name": p.name, - "namespace": p.namespace, - "priority": p.priority, - "directed": p.directed, - }) - return data_format.serialise(ret) - - def _encryption_trust_ui_get(self, to_jid_s, namespace, profile_key): - client = self.get_client(profile_key) - to_jid = jid.JID(to_jid_s) - d = defer.ensureDeferred( - client.encryption.get_trust_ui(to_jid, namespace=namespace or None)) - d.addCallback(lambda xmlui: xmlui.toXml()) - return d - - ## XMPP methods ## - - def _message_send( - self, to_jid_s, message, subject=None, mess_type="auto", extra_s="", - profile_key=C.PROF_KEY_NONE): - client = self.get_client(profile_key) - to_jid = jid.JID(to_jid_s) - return client.sendMessage( - to_jid, - message, - subject, - mess_type, - data_format.deserialise(extra_s) - ) - - def _set_presence(self, to="", show="", statuses=None, profile_key=C.PROF_KEY_NONE): - return self.presence_set(jid.JID(to) if to else None, show, statuses, profile_key) - - def presence_set(self, to_jid=None, show="", statuses=None, - profile_key=C.PROF_KEY_NONE): - """Send our presence information""" - if statuses is None: - statuses = {} - profile = self.memory.get_profile_name(profile_key) - assert profile - priority = int( - self.memory.param_get_a("Priority", "Connection", profile_key=profile) - ) - self.profiles[profile].presence.available(to_jid, show, statuses, priority) - # XXX: FIXME: temporary fix to work around openfire 3.7.0 bug (presence is not - # broadcasted to generating resource) - if "" in statuses: - statuses[C.PRESENCE_STATUSES_DEFAULT] = statuses.pop("") - self.bridge.presence_update( - self.profiles[profile].jid.full(), show, int(priority), statuses, profile - ) - - def subscription(self, subs_type, raw_jid, profile_key): - """Called to manage subscription - @param subs_type: subsciption type (cf RFC 3921) - @param raw_jid: unicode entity's jid - @param profile_key: profile""" - profile = self.memory.get_profile_name(profile_key) - assert profile - to_jid = jid.JID(raw_jid) - log.debug( - _("subsciption request [%(subs_type)s] for %(jid)s") - % {"subs_type": subs_type, "jid": to_jid.full()} - ) - if subs_type == "subscribe": - self.profiles[profile].presence.subscribe(to_jid) - elif subs_type == "subscribed": - self.profiles[profile].presence.subscribed(to_jid) - elif subs_type == "unsubscribe": - self.profiles[profile].presence.unsubscribe(to_jid) - elif subs_type == "unsubscribed": - self.profiles[profile].presence.unsubscribed(to_jid) - - def _add_contact(self, to_jid_s, profile_key): - return self.contact_add(jid.JID(to_jid_s), profile_key) - - def contact_add(self, to_jid, profile_key): - """Add a contact in roster list""" - profile = self.memory.get_profile_name(profile_key) - assert profile - # presence is sufficient, as a roster push will be sent according to - # RFC 6121 §3.1.2 - self.profiles[profile].presence.subscribe(to_jid) - - def _update_contact(self, to_jid_s, name, groups, profile_key): - client = self.get_client(profile_key) - return self.contact_update(client, jid.JID(to_jid_s), name, groups) - - def contact_update(self, client, to_jid, name, groups): - """update a contact in roster list""" - roster_item = RosterItem(to_jid) - roster_item.name = name or u'' - roster_item.groups = set(groups) - if not self.trigger.point("roster_update", client, roster_item): - return - return client.roster.setItem(roster_item) - - def _del_contact(self, to_jid_s, profile_key): - return self.contact_del(jid.JID(to_jid_s), profile_key) - - def contact_del(self, to_jid, profile_key): - """Remove contact from roster list""" - profile = self.memory.get_profile_name(profile_key) - assert profile - self.profiles[profile].presence.unsubscribe(to_jid) # is not asynchronous - return self.profiles[profile].roster.removeItem(to_jid) - - def _roster_resync(self, profile_key): - client = self.get_client(profile_key) - return client.roster.resync() - - ## Discovery ## - # discovery methods are shortcuts to self.memory.disco - # the main difference with client.disco is that self.memory.disco manage cache - - def hasFeature(self, *args, **kwargs): - return self.memory.disco.hasFeature(*args, **kwargs) - - def check_feature(self, *args, **kwargs): - return self.memory.disco.check_feature(*args, **kwargs) - - def check_features(self, *args, **kwargs): - return self.memory.disco.check_features(*args, **kwargs) - - def has_identity(self, *args, **kwargs): - return self.memory.disco.has_identity(*args, **kwargs) - - def get_disco_infos(self, *args, **kwargs): - return self.memory.disco.get_infos(*args, **kwargs) - - def getDiscoItems(self, *args, **kwargs): - return self.memory.disco.get_items(*args, **kwargs) - - def find_service_entity(self, *args, **kwargs): - return self.memory.disco.find_service_entity(*args, **kwargs) - - def find_service_entities(self, *args, **kwargs): - return self.memory.disco.find_service_entities(*args, **kwargs) - - def find_features_set(self, *args, **kwargs): - return self.memory.disco.find_features_set(*args, **kwargs) - - def _find_by_features(self, namespaces, identities, bare_jids, service, roster, own_jid, - local_device, profile_key): - client = self.get_client(profile_key) - identities = [tuple(i) for i in identities] if identities else None - return defer.ensureDeferred(self.find_by_features( - client, namespaces, identities, bare_jids, service, roster, own_jid, - local_device)) - - async def find_by_features( - self, - client: SatXMPPEntity, - namespaces: List[str], - identities: Optional[List[Tuple[str, str]]]=None, - bare_jids: bool=False, - service: bool=True, - roster: bool=True, - own_jid: bool=True, - local_device: bool=False - ) -> Tuple[ - Dict[jid.JID, Tuple[str, str, str]], - Dict[jid.JID, Tuple[str, str, str]], - Dict[jid.JID, Tuple[str, str, str]] - ]: - """Retrieve all services or contacts managing a set a features - - @param namespaces: features which must be handled - @param identities: if not None or empty, - only keep those identities - tuple must be (category, type) - @param bare_jids: retrieve only bare_jids if True - if False, retrieve full jid of connected devices - @param service: if True return service from our server - @param roster: if True, return entities in roster - full jid of all matching resources available will be returned - @param own_jid: if True, return profile's jid resources - @param local_device: if True, return profile's jid local resource - (i.e. client.jid) - @return: found entities in a tuple with: - - service entities - - own entities - - roster entities - Each element is a dict mapping from jid to a tuple with category, type and - name of the entity - """ - assert isinstance(namespaces, list) - if not identities: - identities = None - if not namespaces and not identities: - raise exceptions.DataError( - "at least one namespace or one identity must be set" - ) - found_service = {} - found_own = {} - found_roster = {} - if service: - services_jids = await self.find_features_set(client, namespaces) - services_jids = list(services_jids) # we need a list to map results below - services_infos = await defer.DeferredList( - [self.get_disco_infos(client, service_jid) for service_jid in services_jids] - ) - - for idx, (success, infos) in enumerate(services_infos): - service_jid = services_jids[idx] - if not success: - log.warning( - _("Can't find features for service {service_jid}, ignoring") - .format(service_jid=service_jid.full())) - continue - if (identities is not None - and not set(infos.identities.keys()).issuperset(identities)): - continue - found_identities = [ - (cat, type_, name or "") - for (cat, type_), name in infos.identities.items() - ] - found_service[service_jid.full()] = found_identities - - to_find = [] - if own_jid: - to_find.append((found_own, [client.jid.userhostJID()])) - if roster: - to_find.append((found_roster, client.roster.get_jids())) - - for found, jids in to_find: - full_jids = [] - disco_defers = [] - - for jid_ in jids: - if jid_.resource: - if bare_jids: - continue - resources = [jid_.resource] - else: - if bare_jids: - resources = [None] - else: - try: - resources = self.memory.get_available_resources(client, jid_) - except exceptions.UnknownEntityError: - continue - if not resources and jid_ == client.jid.userhostJID() and own_jid: - # small hack to avoid missing our own resource when this - # method is called at the very beginning of the session - # and our presence has not been received yet - resources = [client.jid.resource] - for resource in resources: - full_jid = jid.JID(tuple=(jid_.user, jid_.host, resource)) - if full_jid == client.jid and not local_device: - continue - full_jids.append(full_jid) - - disco_defers.append(self.get_disco_infos(client, full_jid)) - - d_list = defer.DeferredList(disco_defers) - # XXX: 10 seconds may be too low for slow connections (e.g. mobiles) - # but for discovery, that's also the time the user will wait the first time - # before seing the page, if something goes wrong. - d_list.addTimeout(10, reactor) - infos_data = await d_list - - for idx, (success, infos) in enumerate(infos_data): - full_jid = full_jids[idx] - if not success: - log.warning( - _("Can't retrieve {full_jid} infos, ignoring") - .format(full_jid=full_jid.full())) - continue - if infos.features.issuperset(namespaces): - if identities is not None and not set( - infos.identities.keys() - ).issuperset(identities): - continue - found_identities = [ - (cat, type_, name or "") - for (cat, type_), name in infos.identities.items() - ] - found[full_jid.full()] = found_identities - - return (found_service, found_own, found_roster) - - ## Generic HMI ## - - def _kill_action(self, keep_id, client): - log.debug("Killing action {} for timeout".format(keep_id)) - client.actions[keep_id] - - def action_new( - self, - action_data, - security_limit=C.NO_SECURITY_LIMIT, - keep_id=None, - profile=C.PROF_KEY_NONE, - ): - """Shortcut to bridge.action_new which generate an id and keep for retrieval - - @param action_data(dict): action data (see bridge documentation) - @param security_limit: %(doc_security_limit)s - @param keep_id(None, unicode): if not None, used to keep action for differed - retrieval. The value will be used as callback_id, be sure to use an unique - value. - Action will be deleted after 30 min. - @param profile: %(doc_profile)s - """ - if keep_id is not None: - id_ = keep_id - client = self.get_client(profile) - action_timer = reactor.callLater(60 * 30, self._kill_action, keep_id, client) - client.actions[keep_id] = (action_data, id_, security_limit, action_timer) - else: - id_ = str(uuid.uuid4()) - - self.bridge.action_new( - data_format.serialise(action_data), id_, security_limit, profile - ) - - def actions_get(self, profile): - """Return current non answered actions - - @param profile: %(doc_profile)s - """ - client = self.get_client(profile) - return [ - (data_format.serialise(action_tuple[0]), *action_tuple[1:-1]) - for action_tuple in client.actions.values() - ] - - def register_progress_cb( - self, progress_id, callback, metadata=None, profile=C.PROF_KEY_NONE - ): - """Register a callback called when progress is requested for id""" - if metadata is None: - metadata = {} - client = self.get_client(profile) - if progress_id in client._progress_cb: - raise exceptions.ConflictError("Progress ID is not unique !") - client._progress_cb[progress_id] = (callback, metadata) - - def remove_progress_cb(self, progress_id, profile): - """Remove a progress callback""" - client = self.get_client(profile) - try: - del client._progress_cb[progress_id] - except KeyError: - log.error(_("Trying to remove an unknow progress callback")) - - def _progress_get(self, progress_id, profile): - data = self.progress_get(progress_id, profile) - return {k: str(v) for k, v in data.items()} - - def progress_get(self, progress_id, profile): - """Return a dict with progress information - - @param progress_id(unicode): unique id of the progressing element - @param profile: %(doc_profile)s - @return (dict): data with the following keys: - 'position' (int): current possition - 'size' (int): end_position - if id doesn't exists (may be a finished progression), and empty dict is - returned - """ - client = self.get_client(profile) - try: - data = client._progress_cb[progress_id][0](progress_id, profile) - except KeyError: - data = {} - return data - - def _progress_get_all(self, profile_key): - progress_all = self.progress_get_all(profile_key) - for profile, progress_dict in progress_all.items(): - for progress_id, data in progress_dict.items(): - for key, value in data.items(): - data[key] = str(value) - return progress_all - - def progress_get_all_metadata(self, profile_key): - """Return all progress metadata at once - - @param profile_key: %(doc_profile)s - if C.PROF_KEY_ALL is used, all progress metadata from all profiles are - returned - @return (dict[dict[dict]]): a dict which map profile to progress_dict - progress_dict map progress_id to progress_data - progress_metadata is the same dict as sent by [progress_started] - """ - clients = self.get_clients(profile_key) - progress_all = {} - for client in clients: - profile = client.profile - progress_dict = {} - progress_all[profile] = progress_dict - for ( - progress_id, - (__, progress_metadata), - ) in client._progress_cb.items(): - progress_dict[progress_id] = progress_metadata - return progress_all - - def progress_get_all(self, profile_key): - """Return all progress status at once - - @param profile_key: %(doc_profile)s - if C.PROF_KEY_ALL is used, all progress status from all profiles are returned - @return (dict[dict[dict]]): a dict which map profile to progress_dict - progress_dict map progress_id to progress_data - progress_data is the same dict as returned by [progress_get] - """ - clients = self.get_clients(profile_key) - progress_all = {} - for client in clients: - profile = client.profile - progress_dict = {} - progress_all[profile] = progress_dict - for progress_id, (progress_cb, __) in client._progress_cb.items(): - progress_dict[progress_id] = progress_cb(progress_id, profile) - return progress_all - - def register_callback(self, callback, *args, **kwargs): - """Register a callback. - - @param callback(callable): method to call - @param kwargs: can contain: - with_data(bool): True if the callback use the optional data dict - force_id(unicode): id to avoid generated id. Can lead to name conflict, avoid - if possible - one_shot(bool): True to delete callback once it has been called - @return: id of the registered callback - """ - callback_id = kwargs.pop("force_id", None) - if callback_id is None: - callback_id = str(uuid.uuid4()) - else: - if callback_id in self._cb_map: - raise exceptions.ConflictError(_("id already registered")) - self._cb_map[callback_id] = (callback, args, kwargs) - - if "one_shot" in kwargs: # One Shot callback are removed after 30 min - - def purge_callback(): - try: - self.remove_callback(callback_id) - except KeyError: - pass - - reactor.callLater(1800, purge_callback) - - return callback_id - - def remove_callback(self, callback_id): - """ Remove a previously registered callback - @param callback_id: id returned by [register_callback] """ - log.debug("Removing callback [%s]" % callback_id) - del self._cb_map[callback_id] - - def _action_launch( - self, - callback_id: str, - data_s: str, - profile_key: str - ) -> defer.Deferred: - d = self.launch_callback( - callback_id, - data_format.deserialise(data_s), - profile_key - ) - d.addCallback(data_format.serialise) - return d - - def launch_callback( - self, - callback_id: str, - data: Optional[dict] = None, - profile_key: str = C.PROF_KEY_NONE - ) -> defer.Deferred: - """Launch a specific callback - - @param callback_id: id of the action (callback) to launch - @param data: optional data - @profile_key: %(doc_profile_key)s - @return: a deferred which fire a dict where key can be: - - xmlui: a XMLUI need to be displayed - - validated: if present, can be used to launch a callback, it can have the - values - - C.BOOL_TRUE - - C.BOOL_FALSE - """ - # FIXME: is it possible to use this method without profile connected? If not, - # client must be used instead of profile_key - # FIXME: security limit need to be checked here - try: - client = self.get_client(profile_key) - except exceptions.NotFound: - # client is not available yet - profile = self.memory.get_profile_name(profile_key) - if not profile: - raise exceptions.ProfileUnknownError( - _("trying to launch action with a non-existant profile") - ) - else: - profile = client.profile - # we check if the action is kept, and remove it - try: - action_tuple = client.actions[callback_id] - except KeyError: - pass - else: - action_tuple[-1].cancel() # the last item is the action timer - del client.actions[callback_id] - - try: - callback, args, kwargs = self._cb_map[callback_id] - except KeyError: - raise exceptions.DataError("Unknown callback id {}".format(callback_id)) - - if kwargs.get("with_data", False): - if data is None: - raise exceptions.DataError("Required data for this callback is missing") - args, kwargs = ( - list(args)[:], - kwargs.copy(), - ) # we don't want to modify the original (kw)args - args.insert(0, data) - kwargs["profile"] = profile - del kwargs["with_data"] - - if kwargs.pop("one_shot", False): - self.remove_callback(callback_id) - - return utils.as_deferred(callback, *args, **kwargs) - - # Menus management - - def _get_menu_canonical_path(self, path): - """give canonical form of path - - canonical form is a tuple of the path were every element is stripped and lowercase - @param path(iterable[unicode]): untranslated path to menu - @return (tuple[unicode]): canonical form of path - """ - return tuple((p.lower().strip() for p in path)) - - def import_menu(self, path, callback, security_limit=C.NO_SECURITY_LIMIT, - help_string="", type_=C.MENU_GLOBAL): - r"""register a new menu for frontends - - @param path(iterable[unicode]): path to go to the menu - (category/subcategory/.../item) (e.g.: ("File", "Open")) - /!\ use D_() instead of _() for translations (e.g. (D_("File"), D_("Open"))) - untranslated/lower case path can be used to identity a menu, for this reason - it must be unique independently of case. - @param callback(callable): method to be called when menuitem is selected, callable - or a callback id (string) as returned by [register_callback] - @param security_limit(int): %(doc_security_limit)s - /!\ security_limit MUST be added to data in launch_callback if used #TODO - @param help_string(unicode): string used to indicate what the menu do (can be - show as a tooltip). - /!\ use D_() instead of _() for translations - @param type(unicode): one of: - - C.MENU_GLOBAL: classical menu, can be shown in a menubar on top (e.g. - something like File/Open) - - C.MENU_ROOM: like a global menu, but only shown in multi-user chat - menu_data must contain a "room_jid" data - - C.MENU_SINGLE: like a global menu, but only shown in one2one chat - menu_data must contain a "jid" data - - C.MENU_JID_CONTEXT: contextual menu, used with any jid (e.g.: ad hoc - commands, jid is already filled) - menu_data must contain a "jid" data - - C.MENU_ROSTER_JID_CONTEXT: like JID_CONTEXT, but restricted to jids in - roster. - menu_data must contain a "room_jid" data - - C.MENU_ROSTER_GROUP_CONTEXT: contextual menu, used with group (e.g.: publish - microblog, group is already filled) - menu_data must contain a "group" data - @return (unicode): menu_id (same as callback_id) - """ - - if callable(callback): - callback_id = self.register_callback(callback, with_data=True) - elif isinstance(callback, str): - # The callback is already registered - callback_id = callback - try: - callback, args, kwargs = self._cb_map[callback_id] - except KeyError: - raise exceptions.DataError("Unknown callback id") - kwargs["with_data"] = True # we have to be sure that we use extra data - else: - raise exceptions.DataError("Unknown callback type") - - for menu_data in self._menus.values(): - if menu_data["path"] == path and menu_data["type"] == type_: - raise exceptions.ConflictError( - _("A menu with the same path and type already exists") - ) - - path_canonical = self._get_menu_canonical_path(path) - menu_key = (type_, path_canonical) - - if menu_key in self._menus_paths: - raise exceptions.ConflictError( - "this menu path is already used: {path} ({menu_key})".format( - path=path_canonical, menu_key=menu_key - ) - ) - - menu_data = { - "path": tuple(path), - "path_canonical": path_canonical, - "security_limit": security_limit, - "help_string": help_string, - "type": type_, - } - - self._menus[callback_id] = menu_data - self._menus_paths[menu_key] = callback_id - - return callback_id - - def get_menus(self, language="", security_limit=C.NO_SECURITY_LIMIT): - """Return all menus registered - - @param language: language used for translation, or empty string for default - @param security_limit: %(doc_security_limit)s - @return: array of tuple with: - - menu id (same as callback_id) - - menu type - - raw menu path (array of strings) - - translated menu path - - extra (dict(unicode, unicode)): extra data where key can be: - - icon: name of the icon to use (TODO) - - help_url: link to a page with more complete documentation (TODO) - """ - ret = [] - for menu_id, menu_data in self._menus.items(): - type_ = menu_data["type"] - path = menu_data["path"] - menu_security_limit = menu_data["security_limit"] - if security_limit != C.NO_SECURITY_LIMIT and ( - menu_security_limit == C.NO_SECURITY_LIMIT - or menu_security_limit > security_limit - ): - continue - language_switch(language) - path_i18n = [_(elt) for elt in path] - language_switch() - extra = {} # TODO: manage extra data like icon - ret.append((menu_id, type_, path, path_i18n, extra)) - - return ret - - def _launch_menu(self, menu_type, path, data=None, security_limit=C.NO_SECURITY_LIMIT, - profile_key=C.PROF_KEY_NONE): - client = self.get_client(profile_key) - return self.launch_menu(client, menu_type, path, data, security_limit) - - def launch_menu(self, client, menu_type, path, data=None, - security_limit=C.NO_SECURITY_LIMIT): - """launch action a menu action - - @param menu_type(unicode): type of menu to launch - @param path(iterable[unicode]): canonical path of the menu - @params data(dict): menu data - @raise NotFound: this path is not known - """ - # FIXME: manage security_limit here - # defaut security limit should be high instead of C.NO_SECURITY_LIMIT - canonical_path = self._get_menu_canonical_path(path) - menu_key = (menu_type, canonical_path) - try: - callback_id = self._menus_paths[menu_key] - except KeyError: - raise exceptions.NotFound( - "Can't find menu {path} ({menu_type})".format( - path=canonical_path, menu_type=menu_type - ) - ) - return self.launch_callback(callback_id, data, client.profile) - - def get_menu_help(self, menu_id, language=""): - """return the help string of the menu - - @param menu_id: id of the menu (same as callback_id) - @param language: language used for translation, or empty string for default - @param return: translated help - - """ - try: - menu_data = self._menus[menu_id] - except KeyError: - raise exceptions.DataError("Trying to access an unknown menu") - language_switch(language) - help_string = _(menu_data["help_string"]) - language_switch() - return help_string diff -r 040095a5dc7f -r 7c5654c54fed libervia/backend/plugins/plugin_xep_0082.py --- a/libervia/backend/plugins/plugin_xep_0082.py Fri Jun 02 11:55:48 2023 +0200 +++ b/libervia/backend/plugins/plugin_xep_0082.py Fri Jun 02 12:59:21 2023 +0200 @@ -19,7 +19,7 @@ from libervia.backend.core.constants import Const as C from libervia.backend.core.i18n import D_ -from libervia.backend.core.sat_main import LiberviaBackend +from libervia.backend.core.main import LiberviaBackend from libervia.backend.tools import xmpp_datetime diff -r 040095a5dc7f -r 7c5654c54fed libervia/backend/plugins/plugin_xep_0373.py --- a/libervia/backend/plugins/plugin_xep_0373.py Fri Jun 02 11:55:48 2023 +0200 +++ b/libervia/backend/plugins/plugin_xep_0373.py Fri Jun 02 12:59:21 2023 +0200 @@ -35,7 +35,7 @@ from libervia.backend.core.core_types import SatXMPPEntity from libervia.backend.core.i18n import _, D_ from libervia.backend.core.log import getLogger, Logger -from libervia.backend.core.sat_main import LiberviaBackend +from libervia.backend.core.main import LiberviaBackend from libervia.backend.core.xmpp import SatXMPPClient from libervia.backend.memory import persistent from libervia.backend.plugins.plugin_xep_0045 import XEP_0045 diff -r 040095a5dc7f -r 7c5654c54fed libervia/backend/plugins/plugin_xep_0374.py --- a/libervia/backend/plugins/plugin_xep_0374.py Fri Jun 02 11:55:48 2023 +0200 +++ b/libervia/backend/plugins/plugin_xep_0374.py Fri Jun 02 12:59:21 2023 +0200 @@ -26,7 +26,7 @@ from libervia.backend.core.core_types import SatXMPPEntity from libervia.backend.core.i18n import _, D_ from libervia.backend.core.log import getLogger, Logger -from libervia.backend.core.sat_main import LiberviaBackend +from libervia.backend.core.main import LiberviaBackend from libervia.backend.core.xmpp import SatXMPPClient from libervia.backend.plugins.plugin_xep_0045 import XEP_0045 from libervia.backend.plugins.plugin_xep_0334 import XEP_0334 diff -r 040095a5dc7f -r 7c5654c54fed libervia/backend/plugins/plugin_xep_0384.py --- a/libervia/backend/plugins/plugin_xep_0384.py Fri Jun 02 11:55:48 2023 +0200 +++ b/libervia/backend/plugins/plugin_xep_0384.py Fri Jun 02 12:59:21 2023 +0200 @@ -36,7 +36,7 @@ from libervia.backend.core.core_types import MessageData, SatXMPPEntity from libervia.backend.core.i18n import _, D_ from libervia.backend.core.log import getLogger, Logger -from libervia.backend.core.sat_main import LiberviaBackend +from libervia.backend.core.main import LiberviaBackend from libervia.backend.core.xmpp import SatXMPPClient from libervia.backend.memory import persistent from libervia.backend.plugins.plugin_misc_text_commands import TextCommands diff -r 040095a5dc7f -r 7c5654c54fed libervia/backend/plugins/plugin_xep_0420.py --- a/libervia/backend/plugins/plugin_xep_0420.py Fri Jun 02 11:55:48 2023 +0200 +++ b/libervia/backend/plugins/plugin_xep_0420.py Fri Jun 02 12:59:21 2023 +0200 @@ -30,7 +30,7 @@ from libervia.backend.core.constants import Const as C from libervia.backend.core.i18n import D_ from libervia.backend.core.log import Logger, getLogger -from libervia.backend.core.sat_main import LiberviaBackend +from libervia.backend.core.main import LiberviaBackend from libervia.backend.tools.xml_tools import ElementParser from libervia.backend.plugins.plugin_xep_0033 import NS_ADDRESS from libervia.backend.plugins.plugin_xep_0082 import XEP_0082 diff -r 040095a5dc7f -r 7c5654c54fed libervia/backend/tools/stream.py --- a/libervia/backend/tools/stream.py Fri Jun 02 11:55:48 2023 +0200 +++ b/libervia/backend/tools/stream.py Fri Jun 02 12:59:21 2023 +0200 @@ -31,7 +31,7 @@ from twisted.protocols import basic from twisted.internet import interfaces -from libervia.backend.core.sat_main import LiberviaBackend +from libervia.backend.core.main import LiberviaBackend log = getLogger(__name__) diff -r 040095a5dc7f -r 7c5654c54fed tests/unit/conftest.py --- a/tests/unit/conftest.py Fri Jun 02 11:55:48 2023 +0200 +++ b/tests/unit/conftest.py Fri Jun 02 12:59:21 2023 +0200 @@ -21,7 +21,7 @@ from pytest import fixture from twisted.internet import defer from twisted.words.protocols.jabber import jid -from libervia.backend.core.sat_main import LiberviaBackend +from libervia.backend.core.main import LiberviaBackend from libervia.backend.tools import async_trigger as trigger from libervia.backend.core import xmpp diff -r 040095a5dc7f -r 7c5654c54fed twisted/plugins/sat_plugin.py --- a/twisted/plugins/sat_plugin.py Fri Jun 02 11:55:48 2023 +0200 +++ b/twisted/plugins/sat_plugin.py Fri Jun 02 12:59:21 2023 +0200 @@ -69,7 +69,7 @@ # XXX: Libervia must be imported after log configuration, # because it write stuff to logs initialise(options.parent) - from libervia.backend.core.sat_main import LiberviaBackend + from libervia.backend.core.main import LiberviaBackend return LiberviaBackend()