libervia-backend: sat/plugins/plugin_xep

comparison sat/plugins/plugin_xep_0050.py @ 2667:8dd9db785ac8

plugin XEP-0050, adhoc D-Bus: Ad-Hoc improvment + remote media control: - "commands" namespace is now registered - added "do" and "getCommandElt" methods to XEP-0050 to run ad-hoc commands from backend - commands for a profile are now stored in client._XEP_0050_commands - Ad-Hoc D-Bus plugin can now be run without lxml or dbus (degraded) - use MPRIS to control media players - new adHocRemotesGet bridge method retrieve media players announced in all devices of the profile

author	Goffi <goffi@goffi.org>
date	Fri, 31 Aug 2018 15:47:00 +0200
parents	56f94936df1e
children	003b8b4b56a7

comparison

equal deleted inserted replaced

-:bc122b68eacd
+:8dd9db785ac8
 log = getLogger(__name__)
 from twisted.words.protocols.jabber import jid
 from twisted.words.protocols import jabber
 from twisted.words.xish import domish
 from twisted.internet import defer
-from wokkel import disco, iwokkel, data_form, compat
+from wokkel import disco, iwokkel, data_form
 from sat.core import exceptions
 from sat.memory.memory import Sessions
 from uuid import uuid4
 from sat.tools import xml_tools
 C.PI_IMPORT_NAME: "XEP-0050",
 C.PI_TYPE: "XEP",
 C.PI_PROTOCOLS: ["XEP-0050"],
 C.PI_MAIN: "XEP_0050",
 C.PI_HANDLER: "yes",
-C.PI_DESCRIPTION: _("""Implementation of Ad-Hoc Commands"""),
+C.PI_DESCRIPTION: _(u"""Implementation of Ad-Hoc Commands"""),
 }
 class AdHocError(Exception):
 def __init__(self, error_const):
 class AdHocCommand(XMPPHandler):
 implements(iwokkel.IDisco)
-def __init__(
+def __init__(self, callback, label, node, features, timeout,
-self,
+allowed_jids, allowed_groups, allowed_magics, forbidden_jids,
-parent,
+forbidden_groups):
-callback,
+XMPPHandler.__init__(self)
-label,
-node,
-features,
-timeout,
-allowed_jids,
-allowed_groups,
-allowed_magics,
-forbidden_jids,
-forbidden_groups,
-client,
-):
-self.parent = parent
 self.callback = callback
 self.label = label
 self.node = node
 self.features = [disco.DiscoFeature(feature) for feature in features]
-self.allowed_jids, self.allowed_groups, self.allowed_magics, self.forbidden_jids, self.forbidden_groups = (
+(
+self.allowed_jids,
+self.allowed_groups,
+self.allowed_magics,
+self.forbidden_jids,
+self.forbidden_groups,
+) = (
 allowed_jids,
 allowed_groups,
 allowed_magics,
 forbidden_jids,
 forbidden_groups,
 )
-self.client = client
 self.sessions = Sessions(timeout=timeout)
+@property
+def client(self):
+return self.parent
 def getName(self, xml_lang=None):
 return self.label
 def isAuthorised(self, requestor):
 allowed = set(self.allowed_jids)
 for group in self.allowed_groups:
 try:
 allowed.update(self.client.roster.getJidsFromGroup(group))
 except exceptions.UnknownGroupError:
-log.warning(
+log.warning(_(u"The groups [{group}] is unknown for profile [{profile}])")
-_(
+.format(group=group, profile=self.client.profile))
-u"The groups [%(group)s] is unknown for profile [%(profile)s])"
-% {"group": group, "profile": self.client.profile}
-)
-)
 if requestor.userhostJID() in allowed:
 return True
 return False
 def getDiscoInfo(self, requestor, target, nodeIdentifier=""):
 def getDiscoItems(self, requestor, target, nodeIdentifier=""):
 return []
 def _sendAnswer(self, callback_data, session_id, request):
 """ Send result of the command
 @param callback_data: tuple (payload, status, actions, note) with:
-- payload (domish.Element) usualy containing data form
+- payload (domish.Element, None) usualy containing data form
 - status: current status, see XEP_0050.STATUS
-- actions: list of allowed actions (see XEP_0050.ACTION). First action is the default one. Default to EXECUTE
+- actions(list[str], None): list of allowed actions (see XEP_0050.ACTION).
-- note: optional additional note: either None or a tuple with (note type, human readable string),
+First action is the default one. Default to EXECUTE
-note type being in XEP_0050.NOTE
+- note(tuple[str, unicode]): optional additional note: either None or a
+tuple with (note type, human readable string), "note type" being in
+XEP_0050.NOTE
 @param session_id: current session id
 @param request: original request (domish.Element)
 @return: deferred
 """
 payload, status, actions, note = callback_data
 if status in (XEP_0050.STATUS.COMPLETED, XEP_0050.STATUS.CANCELED):
 del self.sessions[session_id]
 def _sendError(self, error_constant, session_id, request):
 """ Send error stanza
 @param error_constant: one of XEP_OO50.ERROR
 @param request: original request (domish.Element)
 """
 xmpp_condition, cmd_condition = error_constant
 iq_elt = jabber.error.StanzaError(xmpp_condition).toResponse(request)
 if action == XEP_0050.ACTION.CANCEL:
 d = defer.succeed((None, XEP_0050.STATUS.CANCELED, None, None))
 else:
 d = defer.maybeDeferred(
 self.callback,
+self.client,
 command_elt,
 session_data,
 action,
 self.node,
-self.client.profile,
 )
 d.addCallback(self._sendAnswer, session_id, command_elt.parent)
 d.addErrback(
 lambda failure, request: self._sendError(
 failure.value.callback_error, session_id, request
 def __init__(self, host):
 log.info(_("plugin XEP-0050 initialization"))
 self.host = host
 self.requesting = Sessions()
-self.answering = {}
 host.bridge.addMethod(
 "adHocRun",
 ".plugin",
 in_sign="sss",
 out_sign="s",
 host.bridge.addMethod(
 "adHocList",
 ".plugin",
 in_sign="ss",
 out_sign="s",
-method=self._list,
+method=self._listUI,
 async=True,
 )
 self.__requesting_id = host.registerCallback(
 self._requestingEntity, with_data=True
 )
 (D_("Service"), D_("Commands")),
 self._commandsMenu,
 security_limit=2,
 help_string=D_("Execute ad-hoc commands"),
 )
+host.registerNamespace(u'commands', NS_COMMANDS)
 def getHandler(self, client):
 return XEP_0050_handler(self)
 def profileConnected(self, client):
-self.addAdHocCommand(
+# map from node to AdHocCommand instance
-self._statusCallback, _("Status"), profile_key=client.profile
+client._XEP_0050_commands = {}
-)
+self.addAdHocCommand(client, self._statusCallback, _("Status"))
-def profileDisconnected(self, client):
+def do(self, client, entity, node, action=ACTION.EXECUTE, session_id=None,
+form_values=None, timeout=30):
+"""Do an Ad-Hoc Command
+@param entity(jid.JID): entity which will execture the command
+@param node(unicode): node of the command
+@param action(unicode): one of XEP_0050.ACTION
+@param session_id(unicode, None): id of the ad-hoc session
+None if no session is involved
+@param form_values(dict, None): values to use to create command form
+values will be passed to data_form.Form.makeFields
+@return
+"""
+iq_elt = client.IQ(timeout=timeout)
+iq_elt["to"] = entity.full()
+command_elt = iq_elt.addElement("command", NS_COMMANDS)
+command_elt["node"] = node
+command_elt["action"] = action
+if session_id is not None:
+command_elt["sessionid"] = session_id
+if form_values:
+# We add the XMLUI result to the command payload
+form = data_form.Form("submit")
+form.makeFields(form_values)
+command_elt.addChild(form.toElement())
+d = iq_elt.send()
+return d
+def getCommandElt(self, iq_elt):
 try:
-del self.answering[client.profile]
+return iq_elt.elements(NS_COMMANDS, "command").next()
-except KeyError:
+except StopIteration:
-pass
+raise exceptions.NotFound(_(u"Missing command element"))
 def _items2XMLUI(self, items, no_instructions):
-""" Convert discovery items to XMLUI dialog """
+"""Convert discovery items to XMLUI dialog """
 # TODO: manage items on different jids
 form_ui = xml_tools.XMLUI("form", submit_id=self.__requesting_id)
 if not no_instructions:
 form_ui.addText(_("Please select a command"), "instructions")
 C.XMLUI_DATA_LVL_ERROR: "%s: " % _("ERROR"),
 }
 return [u"%s%s" % (lvl_map[lvl], msg) for lvl, msg in notes]
 def _commandsAnswer2XMLUI(self, iq_elt, session_id, session_data):
-"""
+"""Convert command answer to an ui for frontend
-Convert command answer to an ui for frontend
 @param iq_elt: command result
 @param session_id: id of the session used with the frontend
 @param profile_key: %(doc_profile_key)s
+"""
-"""
+command_elt = self.getCommandElt(iq_elt)
-command_elt = iq_elt.elements(NS_COMMANDS, "command").next()
 status = command_elt.getAttribute("status", XEP_0050.STATUS.EXECUTING)
 if status in [XEP_0050.STATUS.COMPLETED, XEP_0050.STATUS.CANCELED]:
 # the command session is finished, we purge our session
 del self.requesting[session_id]
 if status == XEP_0050.STATUS.COMPLETED:
 d = self.requestingEntity(data, profile)
 d.addCallback(serialise)
 return d
 def requestingEntity(self, data, profile):
-"""
+"""Request and entity and create XMLUI accordingly.
-request and entity and create XMLUI accordingly
-@param data: data returned by previous XMLUI (first one must come from self._commandsMenu)
+@param data: data returned by previous XMLUI (first one must come from
+self._commandsMenu)
 @param profile: %(doc_profile)s
-@return: callback dict result (with "xmlui" corresponding to the answering dialog, or empty if it's finished without error)
+@return: callback dict result (with "xmlui" corresponding to the answering
+dialog, or empty if it's finished without error)
 """
 if C.bool(data.get("cancelled", C.BOOL_FALSE)):
 return defer.succeed({})
+data_form_values = xml_tools.XMLUIResult2DataFormResult(data)
 client = self.host.getClient(profile)
 # TODO: cancel, prev and next are not managed
 # TODO: managed answerer errors
 # TODO: manage nodes with a non data form payload
 if "session_id" not in data:
 # we just had the jid, we now request it for the available commands
 session_id, session_data = self.requesting.newSession(profile=client.profile)
 entity = jid.JID(data[xml_tools.SAT_FORM_PREFIX + "jid"])
 session_data["jid"] = entity
-d = self.list(client, entity)
+d = self.listUI(client, entity)
 def sendItems(xmlui):
 xmlui.session_id = session_id  # we need to keep track of the session
 return {"xmlui": xmlui}
 try:
 session_data["node"]
 # node has already been received
 except KeyError:
 # it's the first time we know the node, we save it in session data
-session_data["node"] = data[xml_tools.SAT_FORM_PREFIX + "node"]
+session_data["node"] = data_form_values.pop("node")
+# remote_id is the XEP_0050 sessionid used by answering command
+# while session_id is our own session id used with the frontend
+remote_id = session_data.get("remote_id")
 # we request execute node's command
-iq_elt = compat.IQ(client.xmlstream, "set")
+d = self.do(client, entity, session_data["node"], action=XEP_0050.ACTION.EXECUTE,
-iq_elt["to"] = entity.full()
+session_id=remote_id, form_values=data_form_values)
-command_elt = iq_elt.addElement("command", NS_COMMANDS)
-command_elt["node"] = session_data["node"]
-command_elt["action"] = XEP_0050.ACTION.EXECUTE
-try:
-# remote_id is the XEP_0050 sessionid used by answering command
-# while session_id is our own session id used with the frontend
-command_elt["sessionid"] = session_data["remote_id"]
-except KeyError:
-pass
-command_elt.addChild(
-xml_tools.XMLUIResultToElt(data)
-)  # We add the XMLUI result to the command payload
-d = iq_elt.send()
 d.addCallback(self._commandsAnswer2XMLUI, session_id, session_data)
 d.addCallback(lambda xmlui: {"xmlui": xmlui} if xmlui is not None else {})
 return d
 def _commandsMenu(self, menu_data, profile):
-""" First XMLUI activated by menu: ask for target jid
+"""First XMLUI activated by menu: ask for target jid
 @param profile: %(doc_profile)s
 """
 form_ui = xml_tools.XMLUI("form", submit_id=self.__requesting_id)
 form_ui.addText(_("Please enter target jid"), "instructions")
 form_ui.changeContainer("pairs")
 form_ui.addLabel("jid")
 form_ui.addString("jid", value=self.host.getClient(profile).jid.host)
 return {"xmlui": form_ui.toXml()}
-def _statusCallback(self, command_elt, session_data, action, node, profile):
+def _statusCallback(self, client, command_elt, session_data, action, node):
-""" Ad-hoc command used to change the "show" part of status """
+"""Ad-hoc command used to change the "show" part of status"""
 actions = session_data.setdefault("actions", [])
 actions.append(action)
 if len(actions) == 1:
 # it's our first request, we ask the desired new status
 except (KeyError, StopIteration):
 raise AdHocError(XEP_0050.ERROR.BAD_PAYLOAD)
 if show not in SHOWS:
 raise AdHocError(XEP_0050.ERROR.BAD_PAYLOAD)
 if show == "disconnect":
-self.host.disconnect(profile)
+self.host.disconnect(client.profile)
 else:
-self.host.setPresence(show=show, profile_key=profile)
+self.host.setPresence(show=show, profile_key=client.profile)
 # job done, we can end the session
 form = data_form.Form("form", title=_(u"Updated"))
 form.addField(data_form.Field("fixed", u"Status updated"))
 status = XEP_0050.STATUS.COMPLETED
 if service_jid is None:
 service_jid = jid.JID(client.jid.host)
 session_id, session_data = self.requesting.newSession(profile=client.profile)
 session_data["jid"] = service_jid
 if node is None:
-xmlui = yield self.list(client, service_jid)
+xmlui = yield self.listUI(client, service_jid)
 else:
 session_data["node"] = node
 cb_data = yield self.requestingEntity(
 {"session_id": session_id}, client.profile
 )
 xmlui = cb_data["xmlui"]
 xmlui.session_id = session_id
 defer.returnValue(xmlui)
-def _list(self, to_jid_s, profile_key):
+def list(self, client, to_jid):
+"""Request available commands
+@param to_jid(jid.JID, None): the entity answering the commands
+None to use profile's server
+@return D(disco.DiscoItems): found commands
+"""
+d = self.host.getDiscoItems(client, to_jid, NS_COMMANDS)
+return d
+def _listUI(self, to_jid_s, profile_key):
 client = self.host.getClient(profile_key)
 to_jid = jid.JID(to_jid_s) if to_jid_s else None
-d = self.list(client, to_jid, no_instructions=True)
+d = self.listUI(client, to_jid, no_instructions=True)
 d.addCallback(lambda xmlui: xmlui.toXml())
 return d
-def list(self, client, to_jid, no_instructions=False):
+def listUI(self, client, to_jid, no_instructions=False):
-"""Request available commands
+"""Request available commands and generate XMLUI
 @param to_jid(jid.JID, None): the entity answering the commands
 None to use profile's server
 @param no_instructions(bool): if True, don't add instructions widget
-"""
+@return D(xml_tools.XMLUI): UI with the commands
-d = self.host.getDiscoItems(client, to_jid, NS_COMMANDS)
+"""
+d = self.list(client, to_jid)
 d.addCallback(self._items2XMLUI, no_instructions)
 return d
-def addAdHocCommand(
+def addAdHocCommand(self, client, callback, label, node=None, features=None,
-self,
+timeout=600, allowed_jids=None, allowed_groups=None,
-callback,
+allowed_magics=None, forbidden_jids=None, forbidden_groups=None,
-label,
+):
-node=None,
-features=None,
-timeout=600,
-allowed_jids=None,
-allowed_groups=None,
-allowed_magics=None,
-forbidden_jids=None,
-forbidden_groups=None,
-profile_key=C.PROF_KEY_NONE,
-):
 """Add an ad-hoc command for the current profile
-@param callback: method associated with this ad-hoc command which return the payload data (see AdHocCommand._sendAnswer), can return a deferred
+@param callback: method associated with this ad-hoc command which return the
+payload data (see AdHocCommand._sendAnswer), can return a
+deferred
 @param label: label associated with this command on the main menu
-@param node: disco item node associated with this command. None to use autogenerated node
+@param node: disco item node associated with this command. None to use
-@param features: features associated with the payload (list of strings), usualy data form
+autogenerated node
-@param timeout: delay between two requests before canceling the session (in seconds)
+@param features: features associated with the payload (list of strings), usualy
+data form
+@param timeout: delay between two requests before canceling the session (in
+seconds)
 @param allowed_jids: list of allowed entities
 @param allowed_groups: list of allowed roster groups
 @param allowed_magics: list of allowed magic keys, can be:
 @ALL@: allow everybody
 @PROFILE_BAREJID@: allow only the jid of the profile
 @param forbidden_jids: black list of entities which can't access this command
 @param forbidden_groups: black list of groups which can't access this command
-@param profile_key: profile key associated with this command, @ALL@ means can be accessed with every profiles
 @return: node of the added command, useful to remove the command later
 """
 # FIXME: "@ALL@" for profile_key seems useless and dangerous
 if node is None:
 if forbidden_jids is None:
 forbidden_jids = []
 if forbidden_groups is None:
 forbidden_groups = []
-for client in self.host.getClients(profile_key):
+# TODO: manage newly created/removed profiles
-# TODO: manage newly created/removed profiles
+_allowed_jids = (
-_allowed_jids = (
+(allowed_jids + [client.jid.userhostJID()])
-(allowed_jids + [client.jid.userhostJID()])
+if "@PROFILE_BAREJID@" in allowed_magics
-if "@PROFILE_BAREJID@" in allowed_magics
+else allowed_jids
-else allowed_jids
+)
-)
+ad_hoc_command = AdHocCommand(
-ad_hoc_command = AdHocCommand(
+callback,
-self,
+label,
-callback,
+node,
-label,
+features,
-node,
+timeout,
-features,
+_allowed_jids,
-timeout,
+allowed_groups,
-_allowed_jids,
+allowed_magics,
-allowed_groups,
+forbidden_jids,
-allowed_magics,
+forbidden_groups,
-forbidden_jids,
+)
-forbidden_groups,
+ad_hoc_command.setHandlerParent(client)
-client,
+commands = client._XEP_0050_commands
-)
+commands[node] = ad_hoc_command
-ad_hoc_command.setHandlerParent(client)
-profile_commands = self.answering.setdefault(client.profile, {})
+def onCmdRequest(self, request, client):
-profile_commands[node] = ad_hoc_command
-def onCmdRequest(self, request, profile):
 request.handled = True
 requestor = jid.JID(request["from"])
 command_elt = request.elements(NS_COMMANDS, "command").next()
 action = command_elt.getAttribute("action", self.ACTION.EXECUTE)
 node = command_elt.getAttribute("node")
 if not node:
-raise exceptions.DataError
+client.sendError(request, u"bad-request")
+return
 sessionid = command_elt.getAttribute("sessionid")
+commands = client._XEP_0050_commands
 try:
-command = self.answering[profile][node]
+command = commands[node]
 except KeyError:
-raise exceptions.DataError
+client.sendError(request, u"item-not-found")
+return
 command.onRequest(command_elt, requestor, action, sessionid)
 class XEP_0050_handler(XMPPHandler):
 implements(iwokkel.IDisco)
 def __init__(self, plugin_parent):
 self.plugin_parent = plugin_parent
+@property
+def client(self):
+return self.parent
 def connectionInitialized(self):
 self.xmlstream.addObserver(
-CMD_REQUEST, self.plugin_parent.onCmdRequest, profile=self.parent.profile
+CMD_REQUEST, self.plugin_parent.onCmdRequest, client=self.parent
 )
 def getDiscoInfo(self, requestor, target, nodeIdentifier=""):
 identities = []
-if nodeIdentifier == NS_COMMANDS and self.plugin_parent.answering.get(
+if nodeIdentifier == NS_COMMANDS and self.client._XEP_0050_commands:
-self.parent.profile
+# we only add the identity if we have registred commands
-):  # we only add the identity if we have registred commands
 identities.append(ID_CMD_LIST)
 return [disco.DiscoFeature(NS_COMMANDS)] + identities
 def getDiscoItems(self, requestor, target, nodeIdentifier=""):
 ret = []
 if nodeIdentifier == NS_COMMANDS:
-for command in self.plugin_parent.answering.get(
+commands = self.client._XEP_0050_commands
-self.parent.profile, {}
+for command in commands.values():
-).values():
 if command.isAuthorised(requestor):
 ret.append(
 disco.DiscoItem(self.parent.jid, command.node, command.getName())
 )  # TODO: manage name language
 return ret

Mercurial > libervia-backend

comparison sat/plugins/plugin_xep_0050.py @ 2667:8dd9db785ac8