libervia-backend: sat/plugins/plugin_xep

comparison sat/plugins/plugin_xep_0313.py @ 3028:ab2696e34d29

Python 3 port: /!\ this is a huge commit /!\ starting from this commit, SàT is needs Python 3.6+ /!\ SàT maybe be instable or some feature may not work anymore, this will improve with time This patch port backend, bridge and frontends to Python 3. Roughly this has been done this way: - 2to3 tools has been applied (with python 3.7) - all references to python2 have been replaced with python3 (notably shebangs) - fixed files not handled by 2to3 (notably the shell script) - several manual fixes - fixed issues reported by Python 3 that where not handled in Python 2 - replaced "async" with "async_" when needed (it's a reserved word from Python 3.7) - replaced zope's "implements" with @implementer decorator - temporary hack to handle data pickled in database, as str or bytes may be returned, to be checked later - fixed hash comparison for password - removed some code which is not needed anymore with Python 3 - deactivated some code which needs to be checked (notably certificate validation) - tested with jp, fixed reported issues until some basic commands worked - ported Primitivus (after porting dependencies like urwid satext) - more manual fixes

author	Goffi <goffi@goffi.org>
date	Tue, 13 Aug 2019 19:08:41 +0200
parents	1f74cd0f22c3
children	9d0df638c8b4

comparison

equal deleted inserted replaced

-:ff5bcb12ae60
+:ab2696e34d29
-#!/usr/bin/env python2
+#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 # SAT plugin for Message Archive Management (XEP-0313)
 # Copyright (C) 2009-2019 Jérôme Poisson (goffi@goffi.org)
 # Copyright (C) 2013-2016 Adrien Cossa (souliane@mailoo.org)
 from sat.core.log import getLogger
 from sat.core import exceptions
 from sat.tools.common import data_format
 from twisted.words.protocols.jabber import jid
 from twisted.internet import defer
-from zope.interface import implements
+from zope.interface import implementer
 from datetime import datetime
 from dateutil import tz
 from wokkel import disco
 from wokkel import data_form
 import uuid
 log = getLogger(__name__)
 PLUGIN_INFO = {
-C.PI_NAME: u"Message Archive Management",
+C.PI_NAME: "Message Archive Management",
-C.PI_IMPORT_NAME: u"XEP-0313",
+C.PI_IMPORT_NAME: "XEP-0313",
-C.PI_TYPE: u"XEP",
+C.PI_TYPE: "XEP",
-C.PI_PROTOCOLS: [u"XEP-0313"],
+C.PI_PROTOCOLS: ["XEP-0313"],
-C.PI_DEPENDENCIES: [u"XEP-0059", u"XEP-0359"],
+C.PI_DEPENDENCIES: ["XEP-0059", "XEP-0359"],
-C.PI_MAIN: u"XEP_0313",
+C.PI_MAIN: "XEP_0313",
-C.PI_HANDLER: u"yes",
+C.PI_HANDLER: "yes",
-C.PI_DESCRIPTION: _(u"""Implementation of Message Archive Management"""),
+C.PI_DESCRIPTION: _("""Implementation of Message Archive Management"""),
 }
-MAM_PREFIX = u"mam_"
+MAM_PREFIX = "mam_"
 FILTER_PREFIX = MAM_PREFIX + "filter_"
-KEY_LAST_STANZA_ID = u"last_stanza_id"
+KEY_LAST_STANZA_ID = "last_stanza_id"
 MESSAGE_RESULT = "/message/result[@xmlns='{mam_ns}' and @queryid='{query_id}']"
 MESSAGE_STANZA_ID = '/message/stanza-id[@xmlns="{ns_stanza_id}"]'
 class XEP_0313(object):
 def __init__(self, host):
 log.info(_("Message Archive Management plugin initialization"))
 self.host = host
-self.host.registerNamespace(u"mam", mam.NS_MAM)
+self.host.registerNamespace("mam", mam.NS_MAM)
-self._rsm = host.plugins[u"XEP-0059"]
+self._rsm = host.plugins["XEP-0059"]
-self._sid = host.plugins[u"XEP-0359"]
+self._sid = host.plugins["XEP-0359"]
 # Deferred used to store last stanza id in order of reception
 self._last_stanza_id_d = defer.Deferred()
 self._last_stanza_id_d.callback(None)
 host.bridge.addMethod(
 "MAMGet", ".plugin", in_sign='sss',
 out_sign='(a(sdssa{ss}a{ss}sa{ss})a{ss}s)', method=self._getArchives,
-async=True)
+async_=True)
 @defer.inlineCallbacks
 def resume(self, client):
 """Retrieve one2one messages received since the last we have in local storage"""
 stanza_id_data = yield self.host.memory.storage.getPrivates(
 mam.NS_MAM, [KEY_LAST_STANZA_ID], profile=client.profile)
 stanza_id = stanza_id_data.get(KEY_LAST_STANZA_ID)
 if stanza_id is None:
-log.info(u"can't retrieve last stanza ID, checking history")
+log.info("can't retrieve last stanza ID, checking history")
 last_mess = yield self.host.memory.historyGet(
-None, None, limit=1, filters={u'not_types': C.MESS_TYPE_GROUPCHAT,
+None, None, limit=1, filters={'not_types': C.MESS_TYPE_GROUPCHAT,
-u'last_stanza_id': True},
+'last_stanza_id': True},
 profile=client.profile)
 if not last_mess:
-log.info(_(u"It seems that we have no MAM history yet"))
+log.info(_("It seems that we have no MAM history yet"))
 return
-stanza_id = last_mess[0][-1][u'stanza_id']
+stanza_id = last_mess[0][-1]['stanza_id']
 rsm_req = rsm.RSMRequest(max_=100, after=stanza_id)
 mam_req = mam.MAMRequest(rsm_=rsm_req)
 complete = False
 count = 0
 while not complete:
 mam_data = yield self.getArchives(client, mam_req,
 service=client.jid.userhostJID())
 elt_list, rsm_response, mam_response = mam_data
-complete = mam_response[u"complete"]
+complete = mam_response["complete"]
 # we update MAM request for next iteration
 mam_req.rsm.after = rsm_response.last
 if not elt_list:
 break
 else:
 continue
 try:
 destinee = jid.JID(fwd_message_elt['to'])
 except KeyError:
-log.warning(_(u'missing "to" attribute in forwarded message'))
+log.warning(_('missing "to" attribute in forwarded message'))
 destinee = client.jid
 if destinee.userhostJID() == client.jid.userhostJID():
 # message to use, we insert the forwarded message in the normal
 # workflow
 client.xmlstream.dispatch(fwd_message_elt)
 else:
 # this message should be from us, we just add it to history
 try:
 from_jid = jid.JID(fwd_message_elt['from'])
 except KeyError:
-log.warning(_(u'missing "from" attribute in forwarded message'))
+log.warning(_('missing "from" attribute in forwarded message'))
 from_jid = client.jid
 if from_jid.userhostJID() != client.jid.userhostJID():
 log.warning(_(
-u'was expecting a message sent by our jid, but this one if '
+'was expecting a message sent by our jid, but this one if '
-u'from {from_jid}, ignoring\n{xml}').format(
+'from {from_jid}, ignoring\n{xml}').format(
 from_jid=from_jid.full(), xml=mess_elt.toXml()))
 continue
 # adding message to history
 mess_data = client.messageProt.parseMessage(fwd_message_elt)
 try:
 yield client.messageProt.addToHistory(mess_data)
 except exceptions.CancelError as e:
 log.warning(
-u"message has not been added to history: {e}".format(e=e))
+"message has not been added to history: {e}".format(e=e))
 except Exception as e:
 log.error(
-u"can't add message to history: {e}\n{xml}"
+"can't add message to history: {e}\n{xml}"
 .format(e=e, xml=mess_elt.toXml()))
 if not count:
-log.info(_(u"We have received no message while offline"))
+log.info(_("We have received no message while offline"))
 else:
-log.info(_(u"We have received {num_mess} message(s) while offline.")
+log.info(_("We have received {num_mess} message(s) while offline.")
 .format(num_mess=count))
 def profileConnected(self, client):
 return self.resume(client)
 @return (data_form, None): request with parsed arguments
 or None if no MAM arguments have been found
 """
 mam_args = {}
 form_args = {}
-for arg in (u"start", u"end"):
+for arg in ("start", "end"):
 try:
 value = extra.pop(MAM_PREFIX + arg)
 form_args[arg] = datetime.fromtimestamp(float(value), tz.tzutc())
 except (TypeError, ValueError):
-log.warning(u"Bad value for {arg} filter ({value}), ignoring".format(
+log.warning("Bad value for {arg} filter ({value}), ignoring".format(
 arg=arg, value=value))
 except KeyError:
 continue
 try:
-form_args[u"with_jid"] = jid.JID(extra.pop(
+form_args["with_jid"] = jid.JID(extra.pop(
-MAM_PREFIX + u"with"))
+MAM_PREFIX + "with"))
 except (jid.InvalidFormat):
-log.warning(u"Bad value for jid filter")
+log.warning("Bad value for jid filter")
 except KeyError:
 pass
-for name, value in extra.iteritems():
+for name, value in extra.items():
 if name.startswith(FILTER_PREFIX):
 var = name[len(FILTER_PREFIX):]
-extra_fields = form_args.setdefault(u"extra_fields", [])
+extra_fields = form_args.setdefault("extra_fields", [])
 extra_fields.append(data_form.Field(var=var, value=value))
-for arg in (u"node", u"query_id"):
+for arg in ("node", "query_id"):
 try:
 value = extra.pop(MAM_PREFIX + arg)
 mam_args[arg] = value
 except KeyError:
 continue
 if form_args:
 mam_args["form"] = mam.buildForm(**form_args)
 # we only set orderBy if we have other MAM args
 # else we would make a MAM query while it's not expected
-if u"order_by" in extra and mam_args:
+if "order_by" in extra and mam_args:
-order_by = extra.pop(u"order_by")
+order_by = extra.pop("order_by")
 assert isinstance(order_by, list)
 mam_args["orderBy"] = order_by
 return mam.MAMRequest(**mam_args) if mam_args else None
 If None, a new dict is created
 @return (dict): data dict
 """
 if data is None:
 data = {}
-data[u"mam_complete"] = C.boolConst(mam_response[u'complete'])
+data["mam_complete"] = C.boolConst(mam_response['complete'])
-data[u"mam_stable"] = C.boolConst(mam_response[u'stable'])
+data["mam_stable"] = C.boolConst(mam_response['stable'])
 return data
 def getMessageFromResult(self, client, mess_elt, mam_req, service=None):
 """Extract usable <message/> from MAM query result
 @param mam_req(mam.MAMRequest): request used (needed to get query_id)
 @param service(jid.JID, None): MAM service where the request has been sent
 None if it's user server
 @return domish.Element): <message/> that can be used directly with onMessage
 """
-if mess_elt.name != u"message":
+if mess_elt.name != "message":
-log.warning(u"unexpected stanza in archive: {xml}".format(
+log.warning("unexpected stanza in archive: {xml}".format(
 xml=mess_elt.toXml()))
-raise exceptions.DataError(u"Invalid element")
+raise exceptions.DataError("Invalid element")
 service_jid = client.jid.userhostJID() if service is None else service
-mess_from = mess_elt[u"from"]
+mess_from = mess_elt["from"]
 # we check that the message has been sent by the right service
 # if service is None (i.e. message expected from our own server)
 # from can be server jid or user's bare jid
 if (mess_from != service_jid.full()
 and not (service is None and mess_from == client.jid.host)):
-log.error(u"Message is not from our server, something went wrong: "
+log.error("Message is not from our server, something went wrong: "
-u"{xml}".format(xml=mess_elt.toXml()))
+"{xml}".format(xml=mess_elt.toXml()))
-raise exceptions.DataError(u"Invalid element")
+raise exceptions.DataError("Invalid element")
 try:
-result_elt = next(mess_elt.elements(mam.NS_MAM, u"result"))
+result_elt = next(mess_elt.elements(mam.NS_MAM, "result"))
-forwarded_elt = next(result_elt.elements(C.NS_FORWARD, u"forwarded"))
+forwarded_elt = next(result_elt.elements(C.NS_FORWARD, "forwarded"))
 try:
-delay_elt = next(forwarded_elt.elements(C.NS_DELAY, u"delay"))
+delay_elt = next(forwarded_elt.elements(C.NS_DELAY, "delay"))
 except StopIteration:
 # delay_elt is not mandatory
 delay_elt = None
-fwd_message_elt = next(forwarded_elt.elements(C.NS_CLIENT, u"message"))
+fwd_message_elt = next(forwarded_elt.elements(C.NS_CLIENT, "message"))
 except StopIteration:
-log.warning(u"Invalid message received from MAM: {xml}".format(
+log.warning("Invalid message received from MAM: {xml}".format(
 xml=mess_elt.toXml()))
-raise exceptions.DataError(u"Invalid element")
+raise exceptions.DataError("Invalid element")
 else:
-if not result_elt[u"queryid"] == mam_req.query_id:
+if not result_elt["queryid"] == mam_req.query_id:
-log.error(u"Unexpected query id (was expecting {query_id}): {xml}"
+log.error("Unexpected query id (was expecting {query_id}): {xml}"
 .format(query_id=mam.query_id, xml=mess_elt.toXml()))
-raise exceptions.DataError(u"Invalid element")
+raise exceptions.DataError("Invalid element")
 stanza_id = self._sid.getStanzaId(fwd_message_elt,
 service_jid)
 if stanza_id is None:
 # not stanza-id element is present, we add one so message
 # will be archived with it, and we won't request several times
 # the same MAM achive
 try:
-stanza_id = result_elt[u"id"]
+stanza_id = result_elt["id"]
 except AttributeError:
-log.warning(u'Invalid MAM result: missing "id" attribute: {xml}'
+log.warning('Invalid MAM result: missing "id" attribute: {xml}'
 .format(xml=result_elt.toXml()))
-raise exceptions.DataError(u"Invalid element")
+raise exceptions.DataError("Invalid element")
 self._sid.addStanzaId(client, fwd_message_elt, stanza_id, by=service_jid)
 if delay_elt is not None:
 fwd_message_elt.addChild(delay_elt)
 elt_list.append(message_elt)
 def _queryFinished(self, iq_result, client, elt_list, event):
 client.xmlstream.removeObserver(event, self._appendMessage)
 try:
-fin_elt = iq_result.elements(mam.NS_MAM, "fin").next()
+fin_elt = next(iq_result.elements(mam.NS_MAM, "fin"))
 except StopIteration:
-raise exceptions.DataError(u"Invalid MAM result")
+raise exceptions.DataError("Invalid MAM result")
-mam_response = {u"complete": C.bool(fin_elt.getAttribute(u"complete", C.BOOL_FALSE)),
+mam_response = {"complete": C.bool(fin_elt.getAttribute("complete", C.BOOL_FALSE)),
-u"stable": C.bool(fin_elt.getAttribute(u"stable", C.BOOL_TRUE))}
+"stable": C.bool(fin_elt.getAttribute("stable", C.BOOL_TRUE))}
 try:
 rsm_response = rsm.RSMResponse.fromElement(fin_elt)
 except rsm.RSMNotFoundError:
 rsm_response = None
 - MAM response, which is a dict with following value:
 - complete: a boolean which is True if all items have been received
 - stable: a boolean which is False if items order may be changed
 """
 if query.query_id is None:
-query.query_id = unicode(uuid.uuid4())
+query.query_id = str(uuid.uuid4())
 elt_list = []
 event = MESSAGE_RESULT.format(mam_ns=mam.NS_MAM, query_id=query.query_id)
 client.xmlstream.addObserver(event, self._appendMessage, 0, elt_list, message_cb)
 d = self.queryArchive(client, query, service)
 d.addCallback(self._queryFinished, client, elt_list, event)
 @param message_elt(domish.Element): <message> with a stanza-id
 """
 service_jid = client.jid.userhostJID()
 stanza_id = self._sid.getStanzaId(message_elt, service_jid)
 if stanza_id is None:
-log.debug(u"Ignoring <message>, stanza id is not from our server")
+log.debug("Ignoring <message>, stanza id is not from our server")
 else:
 # we use self._last_stanza_id_d do be sure that last_stanza_id is stored in
 # the order of reception
 self._last_stanza_id_d.addCallback(
 lambda __: self.host.memory.storage.setPrivateValue(
 key=KEY_LAST_STANZA_ID,
 value=stanza_id,
 profile=client.profile))
+@implementer(disco.IDisco)
 class SatMAMClient(mam.MAMClient):
-implements(disco.IDisco)
 def __init__(self, plugin_parent):
 self.plugin_parent = plugin_parent
 @property
 def host(self):
 return self.parent.host_app
 def connectionInitialized(self):
 observer_xpath = MESSAGE_STANZA_ID.format(
-ns_stanza_id=self.host.ns_map[u'stanza_id'])
+ns_stanza_id=self.host.ns_map['stanza_id'])
 self.xmlstream.addObserver(
 observer_xpath, self.plugin_parent.onMessageStanzaId, client=self.parent
 )
 def getDiscoInfo(self, requestor, target, nodeIdentifier=""):

Mercurial > libervia-backend

comparison sat/plugins/plugin_xep_0313.py @ 3028:ab2696e34d29