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

comparison sat/core/xmpp.py @ 2624:56f94936df1e

code style reformatting using black

author	Goffi <goffi@goffi.org>
date	Wed, 27 Jun 2018 20:14:46 +0200
parents	93d64ce7a429
children	189e38fb11ff

comparison

equal deleted inserted replaced

-:49533de4540b
+:56f94936df1e
 from twisted.python import failure
 from wokkel import client as wokkel_client, disco, xmppim, generic, iwokkel
 from wokkel import component
 from wokkel import delay
 from sat.core.log import getLogger
 log = getLogger(__name__)
 from sat.core import exceptions
 from zope.interface import implements
 import time
 import calendar
 # else, it's a deferred which fire on disconnection
 self._connected = None
 self.profile = profile
 self.host_app = host_app
 self.cache = cache.Cache(host_app, profile)
-self._mess_id_uid = {} # map from message id to uid used in history. Key: (full_jid,message_id) Value: uid
+self._mess_id_uid = {}  # map from message id to uid used in history. Key: (full_jid,message_id) Value: uid
 self.conn_deferred = defer.Deferred()
 self._progress_cb = {}  # callback called when a progress is requested (key = progress id)
-self.actions = {} # used to keep track of actions for retrieval (key = action_id)
+self.actions = {}  # used to keep track of actions for retrieval (key = action_id)
 ## initialisation ##
 @defer.inlineCallbacks
 def _callConnectionTriggers(self):
 # FIXME: reconnection doesn't seems to be handled correclty (client is deleted then recreated from scrash
 #        most of methods called here should be called once on first connection (e.g. adding subprotocols)
 #        but client should not be deleted except if session is finished (independently of connection/deconnection
 #
 try:
-port = int(host.memory.getParamA(C.FORCE_PORT_PARAM, "Connection", profile_key=profile))
+port = int(
+host.memory.getParamA(
+C.FORCE_PORT_PARAM, "Connection", profile_key=profile
+)
+)
 except ValueError:
 log.debug(_("Can't parse port value, using default value"))
-port = None  # will use default value 5222 or be retrieved from a DNS SRV record
+port = (
+None
-password = yield host.memory.asyncGetParamA("Password", "Connection", profile_key=profile)
+)  # will use default value 5222 or be retrieved from a DNS SRV record
-entity = host.profiles[profile] = cls(host, profile,
+password = yield host.memory.asyncGetParamA(
+"Password", "Connection", profile_key=profile
+)
+entity = host.profiles[profile] = cls(
+host,
+profile,
 jid.JID(host.memory.getParamA("JabberID", "Connection", profile_key=profile)),
-password, host.memory.getParamA(C.FORCE_SERVER_PARAM, "Connection", profile_key=profile) or None,
+password,
-port, max_retries)
+host.memory.getParamA(C.FORCE_SERVER_PARAM, "Connection", profile_key=profile)
+or None,
+port,
+max_retries,
+)
 entity._createSubProtocols()
 entity.fallBack = SatFallbackHandler(host)
 entity.fallBack.setHandlerParent(entity)
-entity.versionHandler = SatVersionHandler(C.APP_NAME_FULL,
+entity.versionHandler = SatVersionHandler(C.APP_NAME_FULL, host.full_version)
-host.full_version)
 entity.versionHandler.setHandlerParent(entity)
 entity.identityHandler = SatIdentityHandler()
 entity.identityHandler.setHandlerParent(entity)
 all_succeed = all([success for success, result in results])
 if not all_succeed:
 log.error(_(u"Plugins initialisation error"))
 for idx, (success, result) in enumerate(results):
 if not success:
-log.error(u"error (plugin %(name)s): %(failure)s" %
+log.error(
-{'name': plugin_conn_cb[idx][0]._info['import_name'], 'failure': result})
+u"error (plugin %(name)s): %(failure)s"
+% {
-yield list_d.addCallback(logPluginResults) # FIXME: we should have a timeout here, and a way to know if a plugin freeze
+"name": plugin_conn_cb[idx][0]._info["import_name"],
+"failure": result,
+}
+)
+yield list_d.addCallback(
+logPluginResults
+)  # FIXME: we should have a timeout here, and a way to know if a plugin freeze
 # TODO: mesure launch time of each plugin
 def getConnectionDeferred(self):
 """Return a deferred which fire when the client is connected"""
 return self.conn_deferred
 self._connected = defer.Deferred()
 self._connected.addCallback(self._cleanConnection)
 self._connected.addCallback(self._disconnectionCb)
 self._connected.addErrback(self._disconnectionEb)
-log.info(_(u"********** [{profile}] CONNECTED **********").format(profile=self.profile))
+log.info(
+_(u"********** [{profile}] CONNECTED **********").format(profile=self.profile)
+)
 self.streamInitialized()
-self.host_app.bridge.connected(self.profile, unicode(self.jid))  # we send the signal to the clients
+self.host_app.bridge.connected(
+self.profile, unicode(self.jid)
+)  # we send the signal to the clients
 def _finish_connection(self, dummy):
 self.conn_deferred.callback(None)
 def streamInitialized(self):
 """Called after _authd"""
 log.debug(_(u"XML stream is initialized"))
-self.keep_alife = task.LoopingCall(self.xmlstream.send, " ")  # Needed to avoid disconnection (specially with openfire)
+self.keep_alife = task.LoopingCall(
+self.xmlstream.send, " "
+)  # Needed to avoid disconnection (specially with openfire)
 self.keep_alife.start(C.XMPP_KEEP_ALIFE)
 self.disco = SatDiscoProtocol(self)
 self.disco.setHandlerParent(self)
 self.discoHandler = disco.DiscoHandler()
 return
 disco_d.addCallback(self._finish_connection)
 def initializationFailed(self, reason):
-log.error(_(u"ERROR: XMPP connection failed for profile '%(profile)s': %(reason)s" % {'profile': self.profile, 'reason': reason}))
+log.error(
+_(
+u"ERROR: XMPP connection failed for profile '%(profile)s': %(reason)s"
+% {"profile": self.profile, "reason": reason}
+)
+)
 self.conn_deferred.errback(reason.value)
 try:
 super(SatXMPPEntity, self).initializationFailed(reason)
 except:
 # we already chained an errback, no need to raise an exception
 try:
 self.keep_alife.stop()
 except AttributeError:
 log.debug(_("No keep_alife"))
 if self._connected is not None:
-self.host_app.bridge.disconnected(self.profile)  # we send the signal to the clients
+self.host_app.bridge.disconnected(
+self.profile
+)  # we send the signal to the clients
 self._connected.callback(None)
-self.host_app.purgeEntity(self.profile)  # and we remove references to this client
+self.host_app.purgeEntity(
-log.info(_(u"********** [{profile}] DISCONNECTED **********").format(profile=self.profile))
+self.profile
+)  # and we remove references to this client
+log.info(
+_(u"********** [{profile}] DISCONNECTED **********").format(
+profile=self.profile
+)
+)
 if not self.conn_deferred.called:
 # FIXME: real error is not gotten here (e.g. if jid is not know by Prosody,
 #        we should have the real error)
-self.conn_deferred.errback(error.StreamError(u"Server unexpectedly closed the connection"))
+self.conn_deferred.errback(
+error.StreamError(u"Server unexpectedly closed the connection")
+)
 @defer.inlineCallbacks
 def _cleanConnection(self, dummy):
 """method called on disconnection
 else:
 return defer.succeed(None)
 ## sending ##
-def IQ(self, type_=u'set', timeout=60):
+def IQ(self, type_=u"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
 - type
 - subject
 - extra
 @return (dict) message data
 """
-data['xml'] = message_elt = domish.Element((None, 'message'))
+data["xml"] = message_elt = domish.Element((None, "message"))
 message_elt["to"] = data["to"].full()
-message_elt["from"] = data['from'].full()
+message_elt["from"] = data["from"].full()
 message_elt["type"] = data["type"]
-if data['uid']: # key must be present but can be set to ''
+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']
+message_elt["id"] = data["uid"]
 for lang, subject in data["subject"].iteritems():
 subject_elt = message_elt.addElement("subject", content=subject)
 if lang:
-subject_elt[(C.NS_XML, 'lang')] = lang
+subject_elt[(C.NS_XML, "lang")] = lang
 for lang, message in data["message"].iteritems():
 body_elt = message_elt.addElement("body", content=message)
 if lang:
-body_elt[(C.NS_XML, 'lang')] = lang
+body_elt[(C.NS_XML, "lang")] = lang
 try:
-thread = data['extra']['thread']
+thread = data["extra"]["thread"]
 except KeyError:
-if 'thread_parent' in data['extra']:
+if "thread_parent" in data["extra"]:
-raise exceptions.InternalError(u"thread_parent found while there is not associated thread")
+raise exceptions.InternalError(
+u"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"]
 except KeyError:
 @param post_xml_treatments(D): the same Deferred as in sendMessage trigger
 """
 raise NotImplementedError
-def sendMessage(self, to_jid, message, subject=None, mess_type='auto', extra=None, uid=None, no_trigger=False):
+def sendMessage(
+self,
+to_jid,
+message,
+subject=None,
+mess_type="auto",
+extra=None,
+uid=None,
+no_trigger=False,
+):
 """Send a message to an entity
 @param to_jid(jid.JID): destinee of the message
 @param message(dict): message body, key is the language (use '' when unknown)
 @param subject(dict): message subject, key is the language (use '' when unknown)
 "subject": subject,
 "type": mess_type,
 "extra": extra,
 "timestamp": time.time(),
 }
-pre_xml_treatments = defer.Deferred() # XXX: plugin can add their pre XML treatments to this deferred
+pre_xml_treatments = (
-post_xml_treatments = defer.Deferred() # XXX: plugin can add their post XML treatments to this deferred
+defer.Deferred()
+)  # XXX: plugin can add their pre XML treatments to this deferred
+post_xml_treatments = (
+defer.Deferred()
+)  # XXX: plugin can add their post XML treatments to this deferred
 if data["type"] == C.MESS_TYPE_AUTO:
 # we try to guess the type
 if data["subject"]:
 data["type"] = C.MESS_TYPE_NORMAL
-elif not data["to"].resource:  # if to JID has a resource, the type is not 'groupchat'
+elif not data[
+"to"
+].resource:  # if to JID has a resource, the type is not 'groupchat'
 # we may have a groupchat message, we check if the we know this jid
 try:
-entity_type = self.host_app.memory.getEntityData(data["to"], ['type'], self.profile)["type"]
+entity_type = self.host_app.memory.getEntityData(
-#FIXME: should entity_type manage resources ?
+data["to"], ["type"], self.profile
+)["type"]
+# FIXME: should entity_type manage resources ?
 except (exceptions.UnknownEntityError, KeyError):
 entity_type = "contact"
 if entity_type == "chatroom":
 data["type"] = C.MESS_TYPE_GROUPCHAT
 data["type"] == C.MESS_TYPE_CHAT if data["subject"] else C.MESS_TYPE_NORMAL
 # FIXME: send_only is used by libervia's OTR plugin to avoid
 #        the triggers from frontend, and no_trigger do the same
 #        thing internally, this could be unified
-send_only = data['extra'].get('send_only', False)
+send_only = data["extra"].get("send_only", False)
 if not no_trigger and not send_only:
-if not self.host_app.trigger.point("sendMessage" + self.trigger_suffix, self, data, pre_xml_treatments, post_xml_treatments):
+if not self.host_app.trigger.point(
+"sendMessage" + self.trigger_suffix,
+self,
+data,
+pre_xml_treatments,
+post_xml_treatments,
+):
 return defer.succeed(None)
-log.debug(_(u"Sending message (type {type}, to {to})").format(type=data["type"], to=to_jid.full()))
+log.debug(
+_(u"Sending message (type {type}, to {to})").format(
+type=data["type"], to=to_jid.full()
+)
+)
 pre_xml_treatments.addCallback(lambda dummy: self.generateMessageXML(data))
 pre_xml_treatments.chainDeferred(post_xml_treatments)
 post_xml_treatments.addCallback(self.sendMessageData)
 if send_only:
-log.debug(_("Triggers, storage and echo have been inhibited by the 'send_only' parameter"))
+log.debug(
+_(
+"Triggers, storage and echo have been inhibited by the '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)
 @param client: profile's client
 """
 if data[u"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[u"message"] or data[u"subject"]:  # we need a message to store
 self.host_app.memory.addToHistory(self, data)
 else:
-log.warning(u"No message found") # empty body should be managed by plugins before this point
+log.warning(
+u"No message found"
+)  # empty body should be managed by plugins before this point
 return data
 def messageSendToBridge(self, data):
 """Send message to bridge, so frontends can display it
 @param client: profile's client
 """
 if data[u"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 something
+if (
+data[u"message"] or data[u"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(data[u'uid'], data[u'timestamp'], data[u'from'].full(), data[u'to'].full(), data[u'message'], data[u'subject'], data[u'type'], data[u'extra'], profile=self.profile)
+self.host_app.bridge.messageNew(
+data[u"uid"],
+data[u"timestamp"],
+data[u"from"].full(),
+data[u"to"].full(),
+data[u"message"],
+data[u"subject"],
+data[u"type"],
+data[u"extra"],
+profile=self.profile,
+)
 else:
 log.warning(_(u"No message found"))
 return data
 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):
+def __init__(
+self,
+host_app,
+profile,
+user_jid,
+password,
+host=None,
+port=C.XMPP_C2S_PORT,
+max_retries=C.XMPP_MAX_RETRIES,
+):
 # XXX: DNS SRV records are checked when the host is not specified.
 # If no SRV record is found, the host is directly extracted from the JID.
 self.started = time.time()
 # Currently, we use "client/pc/Salut à Toi", but as
 if host is None and user_jid.host in hosts_map:
 host_data = hosts_map[user_jid.host]
 if isinstance(host_data, basestring):
 host = host_data
 elif isinstance(host_data, dict):
-if u'host' in host_data:
+if u"host" in host_data:
-host = host_data[u'host']
+host = host_data[u"host"]
-if u'port' in host_data:
+if u"port" in host_data:
-port = host_data[u'port']
+port = host_data[u"port"]
 else:
-log.warning(_(u"invalid data used for host: {data}").format(data=host_data))
+log.warning(
+_(u"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".format(
+log.info(
-host_ori = user_jid.host,
+u"using {host}:{port} for host {host_ori} as requested in config".format(
-host = host,
+host_ori=user_jid.host, host=host, port=port
-port = port))
+)
+)
-wokkel_client.XMPPClient.__init__(self, user_jid, password, host or None, port or C.XMPP_C2S_PORT)
+wokkel_client.XMPPClient.__init__(
+self, user_jid, password, host or None, port or C.XMPP_C2S_PORT
+)
 SatXMPPEntity.__init__(self, host_app, profile, max_retries)
 def _getPluginsList(self):
 for p in self.host_app.plugins.itervalues():
-if C.PLUG_MODE_CLIENT in p._info[u'modes']:
+if C.PLUG_MODE_CLIENT in p._info[u"modes"]:
 yield p
 def _createSubProtocols(self):
 self.messageProt = SatMessageProtocol(self.host_app)
 self.messageProt.setHandlerParent(self)
 #      it is intended for things like end 2 end encryption.
 #      *DO NOT* cancel (i.e. return False) without very good reason
 #      (out of band transmission for instance).
 #      e2e should have a priority of 0 here, and out of band transmission
 #      a lower priority
-# FIXME: trigger not used yet, can be uncommented when e2e full stanza encryption is implemented
+#  FIXME: trigger not used yet, can be uncommented when e2e full stanza encryption is implemented
-# if not self.host_app.trigger.point("send", self, obj):
+#  if not self.host_app.trigger.point("send", self, obj):
-#     return
+#      return
 super(SatXMPPClient, self).send(obj)
 def sendMessageData(self, mess_data):
 """Convenient method to send message data to stream
 """
 # XXX: This is the last trigger before u"send" (last but one globally) for sending message.
 #      This is intented for e2e encryption which doesn't do full stanza encryption (e.g. OTR)
 #      This trigger point can't cancel the method
 self.host_app.trigger.point("sendMessageData", self, mess_data)
-self.send(mess_data[u'xml'])
+self.send(mess_data[u"xml"])
 return mess_data
 def feedback(self, to_jid, message):
 """Send message to frontends
 This message will be an info message, not recorded in history.
 It can be used to give feedback of a command
 @param to_jid(jid.JID): destinee jid
 @param message(unicode): message to send to frontends
 """
-self.host_app.bridge.messageNew(uid=unicode(uuid.uuid4()),
+self.host_app.bridge.messageNew(
-timestamp=time.time(),
+uid=unicode(uuid.uuid4()),
-from_jid=self.jid.full(),
+timestamp=time.time(),
-to_jid=to_jid.full(),
+from_jid=self.jid.full(),
-message={u'': message},
+to_jid=to_jid.full(),
-subject={},
+message={u"": message},
-mess_type=C.MESS_TYPE_INFO,
+subject={},
-extra={},
+mess_type=C.MESS_TYPE_INFO,
-profile=self.profile)
+extra={},
+profile=self.profile,
+)
 def _finish_connection(self, dummy):
 self.roster.requestRoster()
 self.presence.available()
 super(SatXMPPClient, self)._finish_connection(dummy)
 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
+trigger_suffix = (
+"Component"
+)  # used for to distinguish some trigger points set in SatXMPPEntity
 is_component = True
-sendHistory = False  # XXX: set to True from entry plugin to keep messages in history for received messages
+sendHistory = (
+False
-def __init__(self, host_app, profile, component_jid, password, host=None, port=None, max_retries=C.XMPP_MAX_RETRIES):
+)  # XXX: set to True from entry plugin to keep messages in history for received messages
+def __init__(
+self,
+host_app,
+profile,
+component_jid,
+password,
+host=None,
+port=None,
+max_retries=C.XMPP_MAX_RETRIES,
+):
 self.started = time.time()
 if port is None:
 port = C.XMPP_COMPONENT_PORT
 ## entry point ##
 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(
+raise exceptions.NotFound(
-entry_point = entry_point))
+_(u"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)]
 # 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(u".", 1)[1]
 except IndexError:
 raise ValueError(u"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)
 @param required(bool): True if plugin is mandatory
 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[u"modes"]:
 if not required:
 return
 else:
-log.error(_(u"Plugin {current_name} is needed for {entry_name}, but it doesn't handle component mode").format(
+log.error(
-current_name = current._info[u'import_name'],
+_(
-entry_name = self.entry_plugin._info[u'import_name']
+u"Plugin {current_name} is needed for {entry_name}, but it doesn't handle component mode"
-))
+).format(
+current_name=current._info[u"import_name"],
+entry_name=self.entry_plugin._info[u"import_name"],
+)
+)
 raise exceptions.InternalError(_(u"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
 # so they may not exist in self.host_app.plugins
 try:
 dep = self.host_app.plugins[import_name]
 except KeyError:
 continue
-self._buildDependencies(dep, plugins, required = False)
+self._buildDependencies(dep, plugins, required=False)
 if current not in plugins:
 # current can be required for several plugins and so
 # it can already be present in the list
 plugins.append(current)
 if self.sendHistory:
 post_xml_treatments.addCallback(self.messageAddToHistory)
 class SatMessageProtocol(xmppim.MessageProtocol):
 def __init__(self, host):
 xmppim.MessageProtocol.__init__(self)
 self.host = host
 @staticmethod
 @return(dict): message data
 """
 message = {}
 subject = {}
 extra = {}
-data = {"from": jid.JID(message_elt['from']),
+data = {
-"to": jid.JID(message_elt['to']),
+"from": jid.JID(message_elt["from"]),
-"uid": message_elt.getAttribute('uid', unicode(uuid.uuid4())), # XXX: uid is not a standard attribute but may be added by plugins
+"to": jid.JID(message_elt["to"]),
-"message": message,
+"uid": message_elt.getAttribute(
-"subject": subject,
+"uid", unicode(uuid.uuid4())
-"type": message_elt.getAttribute('type', 'normal'),
+),  # XXX: uid is not a standard attribute but may be added by plugins
-"extra": extra}
+"message": message,
+"subject": subject,
+"type": message_elt.getAttribute("type", "normal"),
+"extra": extra,
+}
 if client is not None:
 try:
-data['stanza_id'] = message_elt['id']
+data["stanza_id"] = message_elt["id"]
 except KeyError:
 pass
 else:
-client._mess_id_uid[(data['from'], data['stanza_id'])] = data['uid']
+client._mess_id_uid[(data["from"], data["stanza_id"])] = data["uid"]
 # message
-for e in message_elt.elements(C.NS_CLIENT, 'body'):
+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"), "")] = unicode(e)
 # subject
-for e in message_elt.elements(C.NS_CLIENT, '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"), "")] = unicode(e)
 # delay and timestamp
 try:
-delay_elt = message_elt.elements(delay.NS_DELAY, 'delay').next()
+delay_elt = message_elt.elements(delay.NS_DELAY, "delay").next()
 except StopIteration:
-data['timestamp'] = time.time()
+data["timestamp"] = time.time()
 else:
 parsed_delay = delay.Delay.fromElement(delay_elt)
-data['timestamp'] = calendar.timegm(parsed_delay.stamp.utctimetuple())
+data["timestamp"] = calendar.timegm(parsed_delay.stamp.utctimetuple())
-data['received_timestamp'] = unicode(time.time())
+data["received_timestamp"] = unicode(time.time())
 if parsed_delay.sender:
-data['delay_sender'] = parsed_delay.sender.full()
+data["delay_sender"] = parsed_delay.sender.full()
 return data
 def onMessage(self, message_elt):
 # TODO: handle threads
 client = self.parent
-if not 'from' in message_elt.attributes:
+if not "from" in message_elt.attributes:
-message_elt['from'] = client.jid.host
+message_elt["from"] = client.jid.host
-log.debug(_(u"got message from: {from_}").format(from_=message_elt['from']))
+log.debug(_(u"got message from: {from_}").format(from_=message_elt["from"]))
-post_treat = defer.Deferred() # XXX: plugin can add their treatments to this deferred
+post_treat = (
+defer.Deferred()
-if not self.host.trigger.point("MessageReceived", client, message_elt, post_treat):
+)  # XXX: plugin can add their treatments to this deferred
+if not self.host.trigger.point(
+"MessageReceived", client, message_elt, post_treat
+):
 return
 data = self.parseMessage(message_elt, client)
 post_treat.addCallback(self.skipEmptyMessage)
 post_treat.addCallback(self.bridgeSignal, client, data)
 post_treat.addErrback(self.cancelErrorTrap)
 post_treat.callback(data)
 def skipEmptyMessage(self, data):
-if not data['message'] and not data['extra'] and not data['subject']:
+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, client):
-if data.pop(u'history', None) == C.HISTORY_SKIP:
+if data.pop(u"history", None) == C.HISTORY_SKIP:
-log.info(u'history is skipped as requested')
+log.info(u"history is skipped as requested")
-data[u'extra'][u'history'] = C.HISTORY_SKIP
+data[u"extra"][u"history"] = C.HISTORY_SKIP
 else:
 return self.host.memory.addToHistory(client, data)
 def bridgeSignal(self, dummy, client, data):
 try:
-data['extra']['received_timestamp'] = data['received_timestamp']
+data["extra"]["received_timestamp"] = data["received_timestamp"]
-data['extra']['delay_sender'] = data['delay_sender']
+data["extra"]["delay_sender"] = data["delay_sender"]
 except KeyError:
 pass
 if data is not None:
-self.host.bridge.messageNew(data['uid'], data['timestamp'], data['from'].full(), data['to'].full(), data['message'], data['subject'], data['type'], data['extra'], profile=client.profile)
+self.host.bridge.messageNew(
+data["uid"],
+data["timestamp"],
+data["from"].full(),
+data["to"].full(),
+data["message"],
+data["subject"],
+data["type"],
+data["extra"],
+profile=client.profile,
+)
 return data
 def cancelErrorTrap(self, failure_):
 """A message sending can be cancelled by a plugin treatment"""
 failure_.trap(exceptions.CancelError)
 class SatRosterProtocol(xmppim.RosterClientProtocol):
 def __init__(self, host):
 xmppim.RosterClientProtocol.__init__(self)
 self.host = host
-self.got_roster = defer.Deferred() # called when roster is received and ready
+self.got_roster = defer.Deferred()  # called when roster is received and ready
-#XXX: the two following dicts keep a local copy of the roster
+# XXX: the two following dicts keep a local copy of the roster
 self._groups = {}  # map from groups to jids: key=group value=set of jids
 self._jids = None  # map from jids to RosterItem: key=jid value=RosterItem
 def rosterCb(self, roster):
-assert roster is not None # FIXME: must be managed with roster versioning
+assert roster is not None  # FIXME: must be managed with roster versioning
 self._groups.clear()
 self._jids = roster
 for item in roster.itervalues():
 if not item.subscriptionTo and not item.subscriptionFrom and not item.ask:
-#XXX: current behaviour: we don't want contact in our roster list
+# 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 subscription".format(item.jid))
+log.info(
-self.removeItem(item.entity) # FIXME: to be checked
+u"Removing contact {} from roster because there is no presence subscription".format(
+item.jid
+)
+)
+self.removeItem(item.entity)  # FIXME: to be checked
 else:
 self._registerItem(item)
 def _registerItem(self, item):
 """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()))
 if item.entity.resource:
-log.warning(u"Received a roster item with a resource, this is not common but not restricted by RFC 6121, this case may be not well tested.")
+log.warning(
+u"Received a roster item with a resource, this is not common but not 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(item.entity.full()))
+log.info(
+_(u"There's no subscription between you and [{}]!").format(
+item.entity.full()
+)
+)
 else:
 log.info(_(u"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()))
 """Return dictionary of attributes as used in bridge from a RosterItem
 @param item: RosterItem
 @return: dictionary of attributes
 """
-item_attr = {'to': unicode(item.subscriptionTo),
+item_attr = {
-'from': unicode(item.subscriptionFrom),
+"to": unicode(item.subscriptionTo),
-'ask': unicode(item.ask)
+"from": unicode(item.subscriptionFrom),
-}
+"ask": unicode(item.ask),
+}
 if item.name:
-item_attr['name'] = item.name
+item_attr["name"] = item.name
 return item_attr
 def setReceived(self, request):
-#TODO: implement roster versioning (cf RFC 6121 §2.6)
+# TODO: implement roster versioning (cf RFC 6121 §2.6)
 item = request.item
 try:  # update the cache for the groups the contact has been removed from
 left_groups = set(self._jids[item.entity].groups).difference(item.groups)
 for group in left_groups:
 jids_set = self._groups[group]
 del self._groups[group]
 except KeyError:
 pass  # no previous item registration (or it's been cleared)
 self._jids[item.entity] = item
 self._registerItem(item)
-self.host.bridge.newContact(item.entity.full(), self.getAttributes(item), item.groups, self.parent.profile)
+self.host.bridge.newContact(
+item.entity.full(), self.getAttributes(item), item.groups, self.parent.profile
+)
 def removeReceived(self, request):
 entity = request.item.entity
 log.info(u"removing %s from roster list" % 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(entity))
+log.error(
+u"Received a roster remove event for an item not in cache ({})".format(
+entity
+)
+)
 return
 for group in item.groups:
 try:
 jids_set = self._groups[group]
 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)s] of the removed roster item [%(jid)s]" %
+log.warning(
-{"group": group, "jid": entity})
+u"there is no cache for the group [%(group)s] of the removed roster item [%(jid)s]"
+% {"group": group, "jid": entity}
+)
 # then we send the bridge signal
 self.host.bridge.contactDeleted(entity.full(), self.parent.profile)
 def getGroups(self):
 C.GROUP: get jids from groups (listed in "groups")
 @groups(list[unicode]): list of groups used if type_==C.GROUP
 @return (set(jid.JID)): set of selected jids
 """
 if type_ == C.ALL and groups is not None:
-raise ValueError('groups must not be set for {} type'.format(C.ALL))
+raise ValueError("groups must not be set for {} type".format(C.ALL))
 if type_ == C.ALL:
 return set(self.getJids())
 elif type_ == C.GROUP:
 jids = set()
 for group in groups:
 jids.update(self.getJidsFromGroup(group))
 return jids
 else:
-raise ValueError(u'Unexpected type_ {}'.format(type_))
+raise ValueError(u"Unexpected type_ {}".format(type_))
 def getNick(self, entity_jid):
 """Return a nick name for an entity
 return nick choosed by user if available
 else:
 return item.name or entity_jid.user
 class SatPresenceProtocol(xmppim.PresenceClientProtocol):
 def __init__(self, host):
 xmppim.PresenceClientProtocol.__init__(self)
 self.host = host
 def send(self, obj):
 if not self.host.trigger.point("Presence send", self.parent, obj, presence_d):
 return
 presence_d.addCallback(lambda __: super(SatPresenceProtocol, self).send(obj))
 def availableReceived(self, entity, show=None, statuses=None, priority=0):
-log.debug(_(u"presence update for [%(entity)s] (available, show=%(show)s statuses=%(statuses)s priority=%(priority)d)") % {'entity': entity, C.PRESENCE_SHOW: show, C.PRESENCE_STATUSES: statuses, C.PRESENCE_PRIORITY: priority})
+log.debug(
+_(
+u"presence update for [%(entity)s] (available, show=%(show)s statuses=%(statuses)s priority=%(priority)d)"
+)
+% {
+"entity": entity,
+C.PRESENCE_SHOW: show,
+C.PRESENCE_STATUSES: statuses,
+C.PRESENCE_PRIORITY: priority,
+}
+)
 if not statuses:
 statuses = {}
 if None in statuses:  # we only want string keys
 statuses[C.PRESENCE_STATUSES_DEFAULT] = statuses.pop(None)
-if not self.host.trigger.point("presenceReceived", entity, show, priority, statuses, self.parent.profile):
+if not self.host.trigger.point(
+"presenceReceived", entity, show, priority, statuses, self.parent.profile
+):
 return
-self.host.memory.setPresenceStatus(entity, show or "",
+self.host.memory.setPresenceStatus(
-int(priority), statuses,
+entity, show or "", int(priority), statuses, self.parent.profile
-self.parent.profile)
+)
 # now it's time to notify frontends
-self.host.bridge.presenceUpdate(entity.full(), show or "",
+self.host.bridge.presenceUpdate(
-int(priority), statuses,
+entity.full(), show or "", int(priority), statuses, self.parent.profile
-self.parent.profile)
+)
 def unavailableReceived(self, entity, statuses=None):
-log.debug(_(u"presence update for [%(entity)s] (unavailable, statuses=%(statuses)s)") % {'entity': entity, C.PRESENCE_STATUSES: statuses})
+log.debug(
+_(u"presence update for [%(entity)s] (unavailable, statuses=%(statuses)s)")
+% {"entity": entity, C.PRESENCE_STATUSES: statuses}
+)
 if not statuses:
 statuses = {}
 if None in statuses:  # we only want string keys
 statuses[C.PRESENCE_STATUSES_DEFAULT] = statuses.pop(None)
-if not self.host.trigger.point("presenceReceived", entity, "unavailable", 0, statuses, self.parent.profile):
+if not self.host.trigger.point(
+"presenceReceived", entity, "unavailable", 0, statuses, self.parent.profile
+):
 return
 # now it's time to notify frontends
 # if the entity is not known yet in this session or is already unavailable, there is no need to send an unavailable signal
 try:
-presence = self.host.memory.getEntityDatum(entity, "presence", self.parent.profile)
+presence = self.host.memory.getEntityDatum(
+entity, "presence", self.parent.profile
+)
 except (KeyError, exceptions.UnknownEntityError):
 # the entity has not been seen yet in this session
 pass
 else:
 if presence.show != C.PRESENCE_UNAVAILABLE:
-self.host.bridge.presenceUpdate(entity.full(), C.PRESENCE_UNAVAILABLE, 0, statuses, self.parent.profile)
+self.host.bridge.presenceUpdate(
+entity.full(),
-self.host.memory.setPresenceStatus(entity, C.PRESENCE_UNAVAILABLE, 0, statuses, self.parent.profile)
+C.PRESENCE_UNAVAILABLE,
+0,
+statuses,
+self.parent.profile,
+)
+self.host.memory.setPresenceStatus(
+entity, C.PRESENCE_UNAVAILABLE, 0, statuses, self.parent.profile
+)
 def available(self, entity=None, show=None, statuses=None, priority=None):
 """Set a presence and statuses.
 @param entity (jid.JID): entity
 @param statuses (dict{unicode: unicode}): multilingual statuses with
 the entry key beeing a language code on 2 characters or "default".
 """
 if priority is None:
 try:
-priority = int(self.host.memory.getParamA("Priority", "Connection", profile_key=self.parent.profile))
+priority = int(
+self.host.memory.getParamA(
+"Priority", "Connection", profile_key=self.parent.profile
+)
+)
 except ValueError:
 priority = 0
 if statuses is None:
 statuses = {}
 presence_elt = xmppim.AvailablePresence(entity, show, statuses, priority)
 # ... before switching back
 if None in statuses:
-statuses['default'] = statuses.pop(None)
+statuses["default"] = statuses.pop(None)
 if not self.host.trigger.point("presence_available", presence_elt, self.parent):
 return
 self.send(presence_elt)
 def subscribed(self, entity):
 yield self.parent.roster.got_roster
 xmppim.PresenceClientProtocol.subscribed(self, entity)
 self.host.memory.delWaitingSub(entity.userhost(), self.parent.profile)
 item = self.parent.roster.getItem(entity)
-if not item or not item.subscriptionTo:  # we automatically subscribe to 'to' presence
+if (
+not item or not item.subscriptionTo
+):  # we automatically subscribe to 'to' presence
 log.debug(_('sending automatic "from" subscription request'))
 self.subscribe(entity)
 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())
-self.host.bridge.subscribe('subscribed', entity.userhost(), self.parent.profile)
+self.host.bridge.subscribe("subscribed", entity.userhost(), self.parent.profile)
 def unsubscribedReceived(self, entity):
 log.debug(_(u"unsubscription confirmed for [%s]") % entity.userhost())
-self.host.bridge.subscribe('unsubscribed', entity.userhost(), self.parent.profile)
+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())
 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
-log.debug(_('sending automatic subscription acceptance'))
+log.debug(_("sending automatic subscription acceptance"))
 self.subscribed(entity)
 else:
-self.host.memory.addWaitingSub('subscribe', entity.userhost(), self.parent.profile)
+self.host.memory.addWaitingSub(
-self.host.bridge.subscribe('subscribe', entity.userhost(), self.parent.profile)
+"subscribe", entity.userhost(), self.parent.profile
+)
+self.host.bridge.subscribe(
+"subscribe", entity.userhost(), self.parent.profile
+)
 @defer.inlineCallbacks
 def unsubscribeReceived(self, entity):
 log.debug(_(u"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'))
+log.debug(_("automatic contact deletion"))
 self.host.delContact(entity, self.parent.profile)
-self.host.bridge.subscribe('unsubscribe', entity.userhost(), self.parent.profile)
+self.host.bridge.subscribe("unsubscribe", entity.userhost(), self.parent.profile)
 class SatDiscoProtocol(disco.DiscoClientProtocol):
 def __init__(self, host):
 disco.DiscoClientProtocol.__init__(self)
 log.debug(u"iqFallback: xml = [%s]" % (iq.toXml()))
 generic.FallbackHandler.iqFallback(self, iq)
 class SatVersionHandler(generic.VersionHandler):
 def getDiscoInfo(self, requestor, target, node):
-#XXX: We need to work around wokkel's behaviour (namespace not added if there is a
+# XXX: We need to work around wokkel's behaviour (namespace not added if there is a
 # node) as it cause issues with XEP-0115 & PEP (XEP-0163): there is a node when server
 # ask for disco info, and not when we generate the key, so the hash is used with different
 # disco features, and when the server (seen 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)
 class SatIdentityHandler(XMPPHandler):
 """ Manage disco Identity of SàT.
 """
-#TODO: dynamic identity update (see docstring). Note that a XMPP entity can have several identities
+# TODO: dynamic identity update (see docstring). Note that a XMPP entity can have several identities
 implements(iwokkel.IDisco)
-def getDiscoInfo(self, requestor, target, nodeIdentifier=''):
+def getDiscoInfo(self, requestor, target, nodeIdentifier=""):
 return self.parent.identities
-def getDiscoItems(self, requestor, target, nodeIdentifier=''):
+def getDiscoItems(self, requestor, target, nodeIdentifier=""):
 return []

Mercurial > libervia-backend

comparison sat/core/xmpp.py @ 2624:56f94936df1e