libervia-backend: sat/core/xmpp.py comparison

comparison sat/core/xmpp.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	94708a7d3ecf
children	fee60f17ebac

comparison

equal deleted inserted replaced

-:ff5bcb12ae60
+:ab2696e34d29
-#!/usr/bin/env python2
+#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 # SAT: a jabber client
 # Copyright (C) 2009-2019 Jérôme Poisson (goffi@goffi.org)
 from sat.core.log import getLogger
 from sat.core import exceptions
 from sat.memory import encryption
 from sat.memory import persistent
 from sat.tools import xml_tools
-from zope.interface import implements
+from zope.interface import implementer
 log = getLogger(__name__)
-NS_X_DATA = u"jabber:x:data"
+NS_X_DATA = "jabber:x:data"
-NS_DISCO_INFO = u"http://jabber.org/protocol/disco#info"
+NS_DISCO_INFO = "http://jabber.org/protocol/disco#info"
-NS_XML_ELEMENT = u"urn:xmpp:xml-element"
+NS_XML_ELEMENT = "urn:xmpp:xml-element"
-NS_ROSTER_VER = u"urn:xmpp:features:rosterver"
+NS_ROSTER_VER = "urn:xmpp:features:rosterver"
 # we use 2 "@" which is illegal in a jid, to be sure we are not mixing keys
 # with roster jids
-ROSTER_VER_KEY = u"@version@"
+ROSTER_VER_KEY = "@version@"
 class SatXMPPEntity(object):
 """Common code for Client and Component"""
 # we monkey patch clientConnectionLost to handle networkEnabled/networkDisabled
 # and to allow plugins to tune reconnection mechanism
 clientConnectionFailed_ori = factory.clientConnectionFailed
 clientConnectionLost_ori = factory.clientConnectionLost
 factory.clientConnectionFailed = partial(
-self.connectionTerminated, term_type=u"failed", cb=clientConnectionFailed_ori)
+self.connectionTerminated, term_type="failed", cb=clientConnectionFailed_ori)
 factory.clientConnectionLost = partial(
-self.connectionTerminated, term_type=u"lost", cb=clientConnectionLost_ori)
+self.connectionTerminated, term_type="lost", cb=clientConnectionLost_ori)
 factory.maxRetries = max_retries
 factory.maxDelay = 30
 # when self._connected_d is None, we are not connected
 # else, it's a deferred which fire on disconnection
 # (key = progress id)
 self.actions = {}  # used to keep track of actions for retrieval (key = action_id)
 self.encryption = encryption.EncryptionHandler(self)
 def __unicode__(self):
-return u"Client instance for profile {profile}".format(profile=self.profile)
+return "Client instance for profile {profile}".format(profile=self.profile)
 def __str__(self):
 return self.__unicode__.encode('utf-8')
 ## initialisation ##
 list_d = defer.DeferredList(conn_cb_list)
 def logPluginResults(results):
 all_succeed = all([success for success, result in results])
 if not all_succeed:
-log.error(_(u"Plugins initialisation error"))
+log.error(_("Plugins initialisation error"))
 for idx, (success, result) in enumerate(results):
 if not success:
 log.error(
-u"error (plugin %(name)s): %(failure)s"
+"error (plugin %(name)s): %(failure)s"
 % {
 "name": plugin_conn_cb[idx][0]._info["import_name"],
 "failure": result,
 }
 )
 def _disconnectionCb(self, __):
 self._connected_d = None
 def _disconnectionEb(self, failure_):
-log.error(_(u"Error while disconnecting: {}".format(failure_)))
+log.error(_("Error while disconnecting: {}".format(failure_)))
 def _authd(self, xmlstream):
 super(SatXMPPEntity, self)._authd(xmlstream)
-log.debug(_(u"{profile} identified").format(profile=self.profile))
+log.debug(_("{profile} identified").format(profile=self.profile))
 self.streamInitialized()
 def _finish_connection(self, __):
 self.conn_deferred.callback(None)
 def streamInitialized(self):
 """Called after _authd"""
-log.debug(_(u"XML stream is initialized"))
+log.debug(_("XML stream is initialized"))
 if not self.host_app.trigger.point("xml_init", self):
 return
 self.postStreamInit()
 def postStreamInit(self):
 """Workflow after stream initalisation."""
 log.info(
-_(u"********** [{profile}] CONNECTED **********").format(profile=self.profile)
+_("********** [{profile}] CONNECTED **********").format(profile=self.profile)
 )
 # the following Deferred is used to know when we are connected
 # so we need to be set it to None when connection is lost
 self._connected_d = defer.Deferred()
 disco_d.addCallback(self._finish_connection)
 def initializationFailed(self, reason):
 log.error(
 _(
-u"ERROR: XMPP connection failed for profile '%(profile)s': %(reason)s"
+"ERROR: XMPP connection failed for profile '%(profile)s': %(reason)s"
 % {"profile": self.profile, "reason": reason}
 )
 )
 self.conn_deferred.errback(reason.value)
 try:
 # if reconnection is disabled
 self._saved_connector = connector
 if reason is not None and not isinstance(reason.value,
 internet_error.ConnectionDone):
 try:
-reason_str = unicode(reason.value)
+reason_str = str(reason.value)
 except Exception:
 # FIXME: workaround for Android were p4a strips docstrings
 #        while Twisted use docstring in __str__
 # TODO: create a ticket upstream, Twisted should work when optimization
 #       is used
-reason_str = unicode(reason.value.__class__)
+reason_str = str(reason.value.__class__)
-log.warning(u"Connection {term_type}: {reason}".format(
+log.warning("Connection {term_type}: {reason}".format(
 term_type = term_type,
 reason=reason_str))
-if not self.host_app.trigger.point(u"connection_" + term_type, connector, reason):
+if not self.host_app.trigger.point("connection_" + term_type, connector, reason):
 return
 return cb(connector, reason)
 def networkDisabled(self):
 """Indicate that network has been completely disabled
 In other words, internet is not available anymore and transport must be stopped.
 Retrying is disabled too, as it makes no sense to try without network, and it may
 use resources (notably battery on mobiles).
 """
-log.info(_(u"stopping connection because of network disabled"))
+log.info(_("stopping connection because of network disabled"))
 self.factory.continueTrying = 0
 self._network_disabled = True
 if self.xmlstream is not None:
 self.xmlstream.transport.abortConnection()
 connector = self._saved_connector
 network_disabled = self._network_disabled
 except AttributeError:
 # connection has not been stopped by networkDisabled
 # we don't have to restart it
-log.debug(u"no connection to restart")
+log.debug("no connection to restart")
 return
 else:
 del self._network_disabled
 if not network_disabled:
-raise exceptions.InternalError(u"network_disabled should be True")
+raise exceptions.InternalError("network_disabled should be True")
-log.info(_(u"network is available, trying to connect"))
+log.info(_("network is available, trying to connect"))
 # we want to be sure to start fresh
 self.factory.resetDelay()
 # we have a saved connector, meaning the connection has been stopped previously
 # we can now try to reconnect
 connector.connect()
 self._connected_d.callback(None)
 self.host_app.purgeEntity(
 self.profile
 )  # and we remove references to this client
 log.info(
-_(u"********** [{profile}] DISCONNECTED **********").format(
+_("********** [{profile}] DISCONNECTED **********").format(
 profile=self.profile
 )
 )
 if not self.conn_deferred.called:
 if reason is None:
-err = error.StreamError(u"Server unexpectedly closed the connection")
+err = error.StreamError("Server unexpectedly closed the connection")
 else:
 err = reason
 try:
 if err.value.args[0][0][2] == "certificate verify failed":
 err = exceptions.InvalidCertificate(
-_(u"Your server certificate is not valid "
+_("Your server certificate is not valid "
-u"(its identity can't be checked).\n\n"
+"(its identity can't be checked).\n\n"
-u"This should never happen and may indicate that "
+"This should never happen and may indicate that "
-u"somebody is trying to spy on you.\n"
+"somebody is trying to spy on you.\n"
-u"Please contact your server administrator."))
+"Please contact your server administrator."))
 self.factory.stopTrying()
 try:
 # with invalid certificate, we should not retry to connect
 # so we delete saved connector to avoid reconnection if
 # networkEnabled is called.
 return False
 def entityDisconnect(self):
 if not self.host_app.trigger.point("disconnecting", self):
 return
-log.info(_(u"Disconnecting..."))
+log.info(_("Disconnecting..."))
 self.stopService()
 if self._connected_d is not None:
 return self._connected_d
 else:
 return defer.succeed(None)
 ## sending ##
-def IQ(self, type_=u"set", timeout=60):
+def IQ(self, type_="set", timeout=60):
 """shortcut to create an IQ element managing deferred
 @param type_(unicode): IQ type ('set' or 'get')
 @param timeout(None, int): timeout in seconds
 @return((D)domish.Element: result stanza
 message_elt["from"] = data["from"].full()
 message_elt["type"] = data["type"]
 if data["uid"]:  # key must be present but can be set to ''
 # by a plugin to avoid id on purpose
 message_elt["id"] = data["uid"]
-for lang, subject in data["subject"].iteritems():
+for lang, subject in data["subject"].items():
 subject_elt = message_elt.addElement("subject", content=subject)
 if lang:
 subject_elt[(C.NS_XML, "lang")] = lang
-for lang, message in data["message"].iteritems():
+for lang, message in data["message"].items():
 body_elt = message_elt.addElement("body", content=message)
 if lang:
 body_elt[(C.NS_XML, "lang")] = lang
 try:
 thread = data["extra"]["thread"]
 except KeyError:
 if "thread_parent" in data["extra"]:
 raise exceptions.InternalError(
-u"thread_parent found while there is not associated thread"
+"thread_parent found while there is not associated thread"
 )
 else:
 thread_elt = message_elt.addElement("thread", content=thread)
 try:
 thread_elt["parent"] = data["extra"]["thread_parent"]
 assert mess_type in C.MESS_TYPE_ALL
 data = {  # dict is similar to the one used in client.onMessage
 "from": self.jid,
 "to": to_jid,
-"uid": uid or unicode(uuid.uuid4()),
+"uid": uid or str(uuid.uuid4()),
 "message": message,
 "subject": subject,
 "type": mess_type,
 "extra": extra,
 "timestamp": time.time(),
 pre_xml_treatments,
 post_xml_treatments,
 ):
 return defer.succeed(None)
-log.debug(_(u"Sending message (type {type}, to {to})")
+log.debug(_("Sending message (type {type}, to {to})")
 .format(type=data["type"], to=to_jid.full()))
 pre_xml_treatments.addCallback(lambda __: self.generateMessageXML(data))
 pre_xml_treatments.chainDeferred(post_xml_treatments)
 post_xml_treatments.addCallback(self.sendMessageData)
 if send_only:
-log.debug(_(u"Triggers, storage and echo have been inhibited by the "
+log.debug(_("Triggers, storage and echo have been inhibited by the "
-u"'send_only' parameter"))
+"'send_only' parameter"))
 else:
 self.addPostXmlCallbacks(post_xml_treatments)
 post_xml_treatments.addErrback(self._cancelErrorTrap)
 post_xml_treatments.addErrback(self.host_app.logErrback)
 pre_xml_treatments.callback(data)
 """Store message into database (for local history)
 @param data: message data dictionnary
 @param client: profile's client
 """
-if data[u"type"] != C.MESS_TYPE_GROUPCHAT:
+if data["type"] != C.MESS_TYPE_GROUPCHAT:
 # we don't add groupchat message to history, as we get them back
 # and they will be added then
-if data[u"message"] or data[u"subject"]:  # we need a message to store
+if data["message"] or data["subject"]:  # we need a message to store
 self.host_app.memory.addToHistory(self, data)
 else:
 log.warning(
-u"No message found"
+"No message found"
 )  # empty body should be managed by plugins before this point
 return data
 def messageGetBridgeArgs(self, data):
 """Generate args to use with bridge from data dict"""
-return (data[u"uid"], data[u"timestamp"], data[u"from"].full(),
+return (data["uid"], data["timestamp"], data["from"].full(),
-data[u"to"].full(), data[u"message"], data[u"subject"],
+data["to"].full(), data["message"], data["subject"],
-data[u"type"], data[u"extra"])
+data["type"], data["extra"])
 def messageSendToBridge(self, data):
 """Send message to bridge, so frontends can display it
 @param data: message data dictionnary
 @param client: profile's client
 """
-if data[u"type"] != C.MESS_TYPE_GROUPCHAT:
+if data["type"] != C.MESS_TYPE_GROUPCHAT:
 # we don't send groupchat message to bridge, as we get them back
 # and they will be added the
-if (data[u"message"] or data[u"subject"]):  # we need a message to send
+if (data["message"] or data["subject"]):  # we need a message to send
 # something
 # We send back the message, so all frontends are aware of it
 self.host_app.bridge.messageNew(
 *self.messageGetBridgeArgs(data),
 profile=self.profile
 )
 else:
-log.warning(_(u"No message found"))
+log.warning(_("No message found"))
 return data
+@implementer(iwokkel.IDisco)
 class SatXMPPClient(SatXMPPEntity, wokkel_client.XMPPClient):
-implements(iwokkel.IDisco)
 trigger_suffix = ""
 is_component = False
 def __init__(self, host_app, profile, user_jid, password, host=None,
 port=C.XMPP_C2S_PORT, max_retries=C.XMPP_MAX_RETRIES):
 # Currently, we use "client/pc/Salut à Toi", but as
 # SàT is multi-frontends and can be used on mobile devices, as a bot,
 # with a web frontend,
 # etc., we should implement a way to dynamically update identities through the
 # bridge
-self.identities = [disco.DiscoIdentity(u"client", u"pc", C.APP_NAME)]
+self.identities = [disco.DiscoIdentity("client", "pc", C.APP_NAME)]
 if sys.platform == "android":
 # FIXME: temporary hack as SRV is not working on android
 # TODO: remove this hack and fix SRV
-log.info(u"FIXME: Android hack, ignoring SRV")
+log.info("FIXME: Android hack, ignoring SRV")
 if host is None:
 host = user_jid.host
 # for now we consider Android devices to be always phones
-self.identities = [disco.DiscoIdentity(u"client", u"phone", C.APP_NAME)]
+self.identities = [disco.DiscoIdentity("client", "phone", C.APP_NAME)]
 hosts_map = host_app.memory.getConfig(None, "hosts_dict", {})
 if host is None and user_jid.host in hosts_map:
 host_data = hosts_map[user_jid.host]
-if isinstance(host_data, basestring):
+if isinstance(host_data, str):
 host = host_data
 elif isinstance(host_data, dict):
-if u"host" in host_data:
+if "host" in host_data:
-host = host_data[u"host"]
+host = host_data["host"]
-if u"port" in host_data:
+if "port" in host_data:
-port = host_data[u"port"]
+port = host_data["port"]
 else:
 log.warning(
-_(u"invalid data used for host: {data}").format(data=host_data)
+_("invalid data used for host: {data}").format(data=host_data)
 )
 host_data = None
 if host_data is not None:
 log.info(
-u"using {host}:{port} for host {host_ori} as requested in config"
+"using {host}:{port} for host {host_ori} as requested in config"
 .format(host_ori=user_jid.host, host=host, port=port)
 )
 self.check_certificate = host_app.memory.getParamA(
 "check_certificate", "Connection", profile_key=profile)
 wokkel_client.XMPPClient.__init__(
 self, user_jid, password, host or None, port or C.XMPP_C2S_PORT,
-check_certificate = self.check_certificate
+# check_certificate = self.check_certificate  # FIXME: currently disabled with Python 3 port
 )
 SatXMPPEntity.__init__(self, host_app, profile, max_retries)
 if not self.check_certificate:
-msg = (_(u"Certificate validation is deactivated, this is unsecure and "
+msg = (_("Certificate validation is deactivated, this is unsecure and "
-u"somebody may be spying on you. If you have no good reason to disable "
+"somebody may be spying on you. If you have no good reason to disable "
-u"certificate validation, please activate \"Check certificate\" in your "
+"certificate validation, please activate \"Check certificate\" in your "
-u"settings in \"Connection\" tab."))
+"settings in \"Connection\" tab."))
-xml_tools.quickNote(host_app, self, msg, _(u"Security notice"),
+xml_tools.quickNote(host_app, self, msg, _("Security notice"),
 level = C.XMLUI_DATA_LVL_WARNING)
 def _getPluginsList(self):
-for p in self.host_app.plugins.itervalues():
+for p in self.host_app.plugins.values():
-if C.PLUG_MODE_CLIENT in p._info[u"modes"]:
+if C.PLUG_MODE_CLIENT in p._info["modes"]:
 yield p
 def _createSubProtocols(self):
 self.messageProt = SatMessageProtocol(self.host_app)
 self.messageProt.setHandlerParent(self)
 #      This is intented for e2e encryption which doesn't do full stanza
 #      encryption (e.g. OTR)
 #      This trigger point can't cancel the method
 yield self.host_app.trigger.asyncPoint("sendMessageData", self, mess_data,
 triggers_no_cancel=True)
-self.send(mess_data[u"xml"])
+self.send(mess_data["xml"])
 defer.returnValue(mess_data)
 def feedback(self, to_jid, message, extra=None):
 """Send message to frontends
 in particular, info subtype can be specified with MESS_EXTRA_INFO
 """
 if extra is None:
 extra = {}
 self.host_app.bridge.messageNew(
-uid=unicode(uuid.uuid4()),
+uid=str(uuid.uuid4()),
 timestamp=time.time(),
 from_jid=self.jid.full(),
 to_jid=to_jid.full(),
-message={u"": message},
+message={"": message},
 subject={},
 mess_type=C.MESS_TYPE_INFO,
 extra=extra,
 profile=self.profile,
 )
 def _finish_connection(self, __):
 d = self.roster.requestRoster()
 d.addCallback(lambda __: super(SatXMPPClient, self)._finish_connection(__))
+@implementer(iwokkel.IDisco)
 class SatXMPPComponent(SatXMPPEntity, component.Component):
 """XMPP component
 This component are similar but not identical to clients.
 An entry point plugin is launched after component is connected.
 Component need to instantiate MessageProtocol itself
 """
-implements(iwokkel.IDisco)
 trigger_suffix = (
 "Component"
 )  # used for to distinguish some trigger points set in SatXMPPEntity
 is_component = True
 sendHistory = (
 entry_point = host_app.memory.getEntryPoint(profile)
 try:
 self.entry_plugin = host_app.plugins[entry_point]
 except KeyError:
 raise exceptions.NotFound(
-_(u"The requested entry point ({entry_point}) is not available").format(
+_("The requested entry point ({entry_point}) is not available").format(
 entry_point=entry_point
 )
 )
-self.identities = [disco.DiscoIdentity(u"component", u"generic", C.APP_NAME)]
+self.identities = [disco.DiscoIdentity("component", "generic", C.APP_NAME)]
 # jid is set automatically on bind by Twisted for Client, but not for Component
 self.jid = component_jid
 if host is None:
 try:
-host = component_jid.host.split(u".", 1)[1]
+host = component_jid.host.split(".", 1)[1]
 except IndexError:
-raise ValueError(u"Can't guess host from jid, please specify a host")
+raise ValueError("Can't guess host from jid, please specify a host")
 # XXX: component.Component expect unicode jid, while Client expect jid.JID.
 #      this is not consistent, so we use jid.JID for SatXMPP*
 component.Component.__init__(self, host, port, component_jid.full(), password)
 SatXMPPEntity.__init__(self, host_app, profile, max_retries)
 for recursive calls only, should not be modified by inital caller
 @raise InternalError: one of the plugin is not handling components
 @raise KeyError: one plugin should be present in self.host_app.plugins but it
 is not
 """
-if C.PLUG_MODE_COMPONENT not in current._info[u"modes"]:
+if C.PLUG_MODE_COMPONENT not in current._info["modes"]:
 if not required:
 return
 else:
 log.error(
 _(
-u"Plugin {current_name} is needed for {entry_name}, "
+"Plugin {current_name} is needed for {entry_name}, "
-u"but it doesn't handle component mode"
+"but it doesn't handle component mode"
 ).format(
-current_name=current._info[u"import_name"],
+current_name=current._info["import_name"],
-entry_name=self.entry_plugin._info[u"import_name"],
+entry_name=self.entry_plugin._info["import_name"],
 )
 )
-raise exceptions.InternalError(_(u"invalid plugin mode"))
+raise exceptions.InternalError(_("invalid plugin mode"))
 for import_name in current._info.get(C.PI_DEPENDENCIES, []):
 # plugins are already loaded as dependencies
 # so we know they are in self.host_app.plugins
 dep = self.host_app.plugins[import_name]
 @param message_elt(domish.Element): raw <message> xml
 @param client(SatXMPPClient, None): client to map message id to uid
 if None, mapping will not be done
 @return(dict): message data
 """
-if message_elt.name != u"message":
+if message_elt.name != "message":
 log.warning(_(
-u"parseMessage used with a non <message/> stanza, ignoring: {xml}"
+"parseMessage used with a non <message/> stanza, ignoring: {xml}"
 .format(xml=message_elt.toXml())))
 return {}
 if message_elt.uri is None:
 # wokkel element parsing strip out root namespace
 for c in message_elt.elements():
 if c.uri is None:
 c.uri = C.NS_CLIENT
 elif message_elt.uri != C.NS_CLIENT:
 log.warning(_(
-u"received <message> with a wrong namespace: {xml}"
+"received <message> with a wrong namespace: {xml}"
 .format(xml=message_elt.toXml())))
 client = self.parent
-if not message_elt.hasAttribute(u'to'):
+if not message_elt.hasAttribute('to'):
 message_elt['to'] = client.jid.full()
 message = {}
 subject = {}
 extra = {}
 data = {
-u"from": jid.JID(message_elt["from"]),
+"from": jid.JID(message_elt["from"]),
-u"to": jid.JID(message_elt["to"]),
+"to": jid.JID(message_elt["to"]),
-u"uid": message_elt.getAttribute(
+"uid": message_elt.getAttribute(
-u"uid", unicode(uuid.uuid4())
+"uid", str(uuid.uuid4())
 ),  # XXX: uid is not a standard attribute but may be added by plugins
-u"message": message,
+"message": message,
-u"subject": subject,
+"subject": subject,
-u"type": message_elt.getAttribute(u"type", u"normal"),
+"type": message_elt.getAttribute("type", "normal"),
-u"extra": extra,
+"extra": extra,
 }
 try:
-message_id = data[u"extra"][u"message_id"] = message_elt[u"id"]
+message_id = data["extra"]["message_id"] = message_elt["id"]
 except KeyError:
 pass
 else:
 client.mess_id2uid[(data["from"], message_id)] = data["uid"]
 # message
 for e in message_elt.elements(C.NS_CLIENT, "body"):
-message[e.getAttribute((C.NS_XML, "lang"), "")] = unicode(e)
+message[e.getAttribute((C.NS_XML, "lang"), "")] = str(e)
 # subject
 for e in message_elt.elements(C.NS_CLIENT, "subject"):
-subject[e.getAttribute((C.NS_XML, "lang"), "")] = unicode(e)
+subject[e.getAttribute((C.NS_XML, "lang"), "")] = str(e)
 # delay and timestamp
 try:
 received_timestamp = message_elt._received_timestamp
 except AttributeError:
 # message_elt._received_timestamp should have been set in onMessage
 # but if parseMessage is called directly, it can be missing
-log.debug(u"missing received timestamp for {message_elt}".format(
+log.debug("missing received timestamp for {message_elt}".format(
 message_elt=message_elt))
 received_timestamp = time.time()
 try:
-delay_elt = message_elt.elements(delay.NS_DELAY, "delay").next()
+delay_elt = next(message_elt.elements(delay.NS_DELAY, "delay"))
 except StopIteration:
 data["timestamp"] = received_timestamp
 else:
 parsed_delay = delay.Delay.fromElement(delay_elt)
 data["timestamp"] = calendar.timegm(parsed_delay.stamp.utctimetuple())
 # TODO: handle threads
 message_elt._received_timestamp = time.time()
 client = self.parent
 if not "from" in message_elt.attributes:
 message_elt["from"] = client.jid.host
-log.debug(_(u"got message from: {from_}").format(from_=message_elt["from"]))
+log.debug(_("got message from: {from_}").format(from_=message_elt["from"]))
 # plugin can add their treatments to this deferred
 post_treat = defer.Deferred()
 d = self.host.trigger.asyncPoint(
 if not data["message"] and not data["extra"] and not data["subject"]:
 raise failure.Failure(exceptions.CancelError("Cancelled empty message"))
 return data
 def addToHistory(self, data):
-if data.pop(u"history", None) == C.HISTORY_SKIP:
+if data.pop("history", None) == C.HISTORY_SKIP:
-log.info(u"history is skipped as requested")
+log.info("history is skipped as requested")
-data[u"extra"][u"history"] = C.HISTORY_SKIP
+data["extra"]["history"] = C.HISTORY_SKIP
 else:
-if data[u"message"] or data[u"subject"]:  # we need a message to store
+if data["message"] or data["subject"]:  # we need a message to store
 return self.host.memory.addToHistory(self.parent, data)
 else:
-log.debug(u"not storing empty message to history: {data}"
+log.debug("not storing empty message to history: {data}"
 .format(data=data))
 def bridgeSignal(self, __, data):
 try:
-data["extra"]["received_timestamp"] = unicode(data["received_timestamp"])
+data["extra"]["received_timestamp"] = str(data["received_timestamp"])
 data["extra"]["delay_sender"] = data["delay_sender"]
 except KeyError:
 pass
 if C.MESS_KEY_ENCRYPTION in data:
-data[u"extra"][u"encrypted"] = C.BOOL_TRUE
+data["extra"]["encrypted"] = C.BOOL_TRUE
 if data is not None:
 if data["message"] or data["subject"] or data["type"] == C.MESS_TYPE_INFO:
 self.host.bridge.messageNew(
 data["uid"],
 data["timestamp"],
 data["type"],
 data["extra"],
 profile=self.parent.profile,
 )
 else:
-log.debug(u"Discarding bridge signal for empty message: {data}".format(
+log.debug("Discarding bridge signal for empty message: {data}".format(
 data=data))
 return data
 def cancelErrorTrap(self, failure_):
 """A message sending can be cancelled by a plugin treatment"""
 self._groups = {}  # map from groups to jids: key=group value=set of jids
 @property
 def versioning(self):
 """True if server support roster versioning"""
-return (NS_ROSTER_VER, u'ver') in self.parent.xmlstream.features
+return (NS_ROSTER_VER, 'ver') in self.parent.xmlstream.features
 @property
 def roster_cache(self):
 """Cache of roster from storage
 """Register item in local cache
 item must be already registered in self._jids before this method is called
 @param item (RosterIem): item added
 """
-log.debug(u"registering item: {}".format(item.entity.full()))
+log.debug("registering item: {}".format(item.entity.full()))
 if item.entity.resource:
 log.warning(
-u"Received a roster item with a resource, this is not common but not "
+"Received a roster item with a resource, this is not common but not "
-u"restricted by RFC 6121, this case may be not well tested."
+"restricted by RFC 6121, this case may be not well tested."
 )
 if not item.subscriptionTo:
 if not item.subscriptionFrom:
 log.info(
-_(u"There's no subscription between you and [{}]!").format(
+_("There's no subscription between you and [{}]!").format(
 item.entity.full()
 )
 )
 else:
-log.info(_(u"You are not subscribed to [{}]!").format(item.entity.full()))
+log.info(_("You are not subscribed to [{}]!").format(item.entity.full()))
 if not item.subscriptionFrom:
-log.info(_(u"[{}] is not subscribed to you!").format(item.entity.full()))
+log.info(_("[{}] is not subscribed to you!").format(item.entity.full()))
 for group in item.groups:
 self._groups.setdefault(group, set()).add(item.entity)
 @defer.inlineCallbacks
 @param version(unicode): version of roster in local cache
 """
 roster_cache = self.roster_cache
 yield roster_cache.clear()
 roster_cache[ROSTER_VER_KEY] = version
-for roster_jid, roster_item in self._jids.iteritems():
+for roster_jid, roster_item in self._jids.items():
 roster_jid_s = roster_jid.full()
 roster_item_elt = roster_item.toElement().toXml()
 roster_cache[roster_jid_s] = roster_item_elt
 @defer.inlineCallbacks
 @defer.inlineCallbacks
 def requestRoster(self):
 """Ask the server for Roster list """
 if self.versioning:
-log.info(_(u"our server support roster versioning, we use it"))
+log.info(_("our server support roster versioning, we use it"))
 roster_cache = self.roster_cache
 yield roster_cache.load()
 try:
 version = roster_cache[ROSTER_VER_KEY]
 except KeyError:
-log.info(_(u"no roster in cache, we start fresh"))
+log.info(_("no roster in cache, we start fresh"))
 # u"" means we use versioning without valid roster in cache
-version = u""
+version = ""
 else:
-log.info(_(u"We have roster v{version} in cache").format(version=version))
+log.info(_("We have roster v{version} in cache").format(version=version))
 # we deserialise cached roster to our local cache
-for roster_jid_s, roster_item_elt_s in roster_cache.iteritems():
+for roster_jid_s, roster_item_elt_s in roster_cache.items():
 if roster_jid_s == ROSTER_VER_KEY:
 continue
 roster_jid = jid.JID(roster_jid_s)
 roster_item_elt = generic.parseXml(roster_item_elt_s.encode('utf-8'))
 roster_item = xmppim.RosterItem.fromElement(roster_item_elt)
 self._jids[roster_jid] = roster_item
 self._registerItem(roster_item)
 else:
-log.warning(_(u"our server doesn't support roster versioning"))
+log.warning(_("our server doesn't support roster versioning"))
 version = None
 log.debug("requesting roster")
 roster = yield self.getRoster(version=version)
 if roster is None:
-log.debug(u"empty roster result received, we'll get roster item with roster "
+log.debug("empty roster result received, we'll get roster item with roster "
-u"pushes")
+"pushes")
 else:
 # a full roster is received
 self._groups.clear()
 self._jids = roster
-for item in roster.itervalues():
+for item in roster.values():
 if not item.subscriptionTo and not item.subscriptionFrom and not item.ask:
 # XXX: current behaviour: we don't want contact in our roster list
 # if there is no presence subscription
 # may change in the future
 log.info(
-u"Removing contact {} from roster because there is no presence "
+"Removing contact {} from roster because there is no presence "
-u"subscription".format(
+"subscription".format(
 item.jid
 )
 )
 self.removeItem(item.entity)  # FIXME: to be checked
 else:
 @param item: RosterItem
 @return: dictionary of attributes
 """
 item_attr = {
-"to": unicode(item.subscriptionTo),
+"to": str(item.subscriptionTo),
-"from": unicode(item.subscriptionFrom),
+"from": str(item.subscriptionFrom),
-"ask": unicode(item.ask),
+"ask": str(item.ask),
 }
 if item.name:
 item_attr["name"] = item.name
 return item_attr
 def setReceived(self, request):
 item = request.item
 entity = item.entity
-log.info(_(u"adding {entity} to roster").format(entity=entity.full()))
+log.info(_("adding {entity} to roster").format(entity=entity.full()))
 if request.version is not None:
 # we update the cache in storage
 roster_cache = self.roster_cache
 roster_cache[entity.full()] = item.toElement().toXml()
 roster_cache[ROSTER_VER_KEY] = request.version
 entity.full(), self.getAttributes(item), item.groups, self.parent.profile
 )
 def removeReceived(self, request):
 entity = request.item.entity
-log.info(_(u"removing {entity} from roster").format(entity=entity.full()))
+log.info(_("removing {entity} from roster").format(entity=entity.full()))
 if request.version is not None:
 # we update the cache in storage
 roster_cache = self.roster_cache
 try:
 del roster_cache[request.item.entity.full()]
 # we first remove item from local cache (self._groups and self._jids)
 try:
 item = self._jids.pop(entity)
 except KeyError:
 log.error(
-u"Received a roster remove event for an item not in cache ({})".format(
+"Received a roster remove event for an item not in cache ({})".format(
 entity
 )
 )
 return
 for group in item.groups:
 jids_set.remove(entity)
 if not jids_set:
 del self._groups[group]
 except KeyError:
 log.warning(
-u"there is no cache for the group [{group}] of the removed roster "
+"there is no cache for the group [{group}] of the removed roster "
-u"item [{jid_}]".format(group=group, jid=entity)
+"item [{jid_}]".format(group=group, jid=entity)
 )
 # then we send the bridge signal
 self.host.bridge.contactDeleted(entity.full(), self.parent.profile)
 def getGroups(self):
 """Return a list of groups"""
-return self._groups.keys()
+return list(self._groups.keys())
 def getItem(self, entity_jid):
 """Return RosterItem for a given jid
 @param entity_jid(jid.JID): jid of the contact
 """
 return self._jids.get(entity_jid, None)
 def getJids(self):
 """Return all jids of the roster"""
-return self._jids.keys()
+return list(self._jids.keys())
 def isJidInRoster(self, entity_jid):
 """Return True if jid is in roster"""
 return entity_jid in self._jids
 return False
 return item.subscriptionFrom
 def getItems(self):
 """Return all items of the roster"""
-return self._jids.values()
+return list(self._jids.values())
 def getJidsFromGroup(self, group):
 try:
 return self._groups[group]
 except KeyError:
 jids = set()
 for group in groups:
 jids.update(self.getJidsFromGroup(group))
 return jids
 else:
-raise ValueError(u"Unexpected type_ {}".format(type_))
+raise ValueError("Unexpected type_ {}".format(type_))
 def getNick(self, entity_jid):
 """Return a nick name for an entity
 return nick choosed by user if available
 entity.full(), show or "", int(priority), statuses, self.parent.profile
 )
 def unavailableReceived(self, entity, statuses=None):
 log.debug(
-_(u"presence update for [%(entity)s] (unavailable, statuses=%(statuses)s)")
+_("presence update for [%(entity)s] (unavailable, statuses=%(statuses)s)")
 % {"entity": entity, C.PRESENCE_STATUSES: statuses}
 )
 if not statuses:
 statuses = {}
 def unsubscribed(self, entity):
 xmppim.PresenceClientProtocol.unsubscribed(self, entity)
 self.host.memory.delWaitingSub(entity.userhost(), self.parent.profile)
 def subscribedReceived(self, entity):
-log.debug(_(u"subscription approved for [%s]") % entity.userhost())
+log.debug(_("subscription approved for [%s]") % entity.userhost())
 self.host.bridge.subscribe("subscribed", entity.userhost(), self.parent.profile)
 def unsubscribedReceived(self, entity):
-log.debug(_(u"unsubscription confirmed for [%s]") % entity.userhost())
+log.debug(_("unsubscription confirmed for [%s]") % entity.userhost())
 self.host.bridge.subscribe("unsubscribed", entity.userhost(), self.parent.profile)
 @defer.inlineCallbacks
 def subscribeReceived(self, entity):
-log.debug(_(u"subscription request from [%s]") % entity.userhost())
+log.debug(_("subscription request from [%s]") % entity.userhost())
 yield self.parent.roster.got_roster
 item = self.parent.roster.getItem(entity)
 if item and item.subscriptionTo:
 # We automatically accept subscription if we are already subscribed to
 # contact presence
 "subscribe", entity.userhost(), self.parent.profile
 )
 @defer.inlineCallbacks
 def unsubscribeReceived(self, entity):
-log.debug(_(u"unsubscription asked for [%s]") % entity.userhost())
+log.debug(_("unsubscription asked for [%s]") % entity.userhost())
 yield self.parent.roster.got_roster
 item = self.parent.roster.getItem(entity)
 if item and item.subscriptionFrom:  # we automatically remove contact
 log.debug(_("automatic contact deletion"))
 self.host.delContact(entity, self.parent.profile)
 self.host.bridge.subscribe("unsubscribe", entity.userhost(), self.parent.profile)
+@implementer(iwokkel.IDisco)
 class SatDiscoProtocol(disco.DiscoClientProtocol):
-implements(iwokkel.IDisco)
 def __init__(self, host):
 disco.DiscoClientProtocol.__init__(self)
 def getDiscoInfo(self, requestor, target, nodeIdentifier=""):
 generic.FallbackHandler.__init__(self)
 def iqFallback(self, iq):
 if iq.handled is True:
 return
-log.debug(u"iqFallback: xml = [%s]" % (iq.toXml()))
+log.debug("iqFallback: xml = [%s]" % (iq.toXml()))
 generic.FallbackHandler.iqFallback(self, iq)
 class SatVersionHandler(generic.VersionHandler):
 #      on ejabberd) generate its own hash for security check it reject our
 #      features (resulting in e.g. no notification on PEP)
 return generic.VersionHandler.getDiscoInfo(self, requestor, target, None)
+@implementer(iwokkel.IDisco)
 class SatIdentityHandler(XMPPHandler):
 """Manage disco Identity of SàT."""
-implements(iwokkel.IDisco)
 # TODO: dynamic identity update (see docstring). Note that a XMPP entity can have
 #       several identities
 def getDiscoInfo(self, requestor, target, nodeIdentifier=""):
 return self.parent.identities

Mercurial > libervia-backend

comparison sat/core/xmpp.py @ 3028:ab2696e34d29