libervia-backend: src/plugins/plugin_xep

comparison src/plugins/plugin_xep_0054.py @ 2123:c42aab22c2c0

plugin XEP-0054, quick frontend(app): various improvments: - memory.cache is now used - getAvatar and setAvatar has been renamed to avatarGet and avatarSet to follow new convention - getAvatar now return (optionally) full path, and may request vCard or only return avatar in cache - getAvatarFile has been removed as it is not needed anymore (avatarGet can return full path) - getCard has been removed from bridge as it was only used to request avatar - new internal method getBareOfFull return jid to use depending of the jid being part of a MUC or not - cache is now set per profile in client, instead of a general one for all profiles - thanks to the use of memory.cache, correct extension is now used in saved file, according to MIME type - fixed and better cache handling - a warning message is shown if given avatar hash differs from computed one - empty hash value is now in a constant, and ignored if received - QuickApp has been updated to follow new behaviour - Primitivus has been fixed (it was not declaring not using avatars correclty) - jp has been updated to follow new methods name

author	Goffi <goffi@goffi.org>
date	Sun, 15 Jan 2017 17:51:37 +0100
parents	11fb5f5e2f89
children	1d3f73e065e1

comparison

equal deleted inserted replaced

-:3970ebcf8830
+:c42aab22c2c0
 from sat.core.constants import Const as C
 from sat.core.log import getLogger
 log = getLogger(__name__)
 from twisted.internet import threads, defer
 from twisted.words.protocols.jabber import jid
-from twisted.words.protocols.jabber.xmlstream import IQ
 from twisted.words.xish import domish
 from twisted.python.failure import Failure
-import os.path
 from zope.interface import implements
 from wokkel import disco, iwokkel
 from base64 import b64decode, b64encode
 from hashlib import sha1
 from sat.core import exceptions
 from sat.memory import persistent
+import mimetypes
 try:
 from PIL import Image
 except:
 raise exceptions.MissingModule(u"Missing module pillow, please download/install it from https://python-pillow.github.io")
 from cStringIO import StringIO
 from twisted.words.protocols.xmlstream import XMPPHandler
 except ImportError:
 from wokkel.subprotocols import XMPPHandler
 AVATAR_PATH = "avatars"
-AVATAR_DIM = (64, 64)
+AVATAR_DIM = (64, 64)  # FIXME: dim are not adapted to modern resolutions !
 IQ_GET = '/iq[@type="get"]'
 NS_VCARD = 'vcard-temp'
 VCARD_REQUEST = IQ_GET + '/vCard[@xmlns="' + NS_VCARD + '"]'  # TODO: manage requests
 PRESENCE = '/presence'
 NS_VCARD_UPDATE = 'vcard-temp:x:update'
 VCARD_UPDATE = PRESENCE + '/x[@xmlns="' + NS_VCARD_UPDATE + '"]'
 CACHED_DATA = {'avatar', 'nick'}
+MAX_AGE = 60 * 60 * 24 * 365
 PLUGIN_INFO = {
 "name": "XEP 0054 Plugin",
 "import_name": "XEP-0054",
 "type": "XEP",
 #TODO: - check that nickname is ok
 #      - refactor the code/better use of Wokkel
 #      - get missing values
 def __init__(self, host):
-log.info(_("Plugin XEP_0054 initialization"))
+log.info(_(u"Plugin XEP_0054 initialization"))
 self.host = host
-self.avatar_path = os.path.join(self.host.memory.getConfig('', 'local_dir'), AVATAR_PATH)
+host.bridge.addMethod(u"avatarGet", u".plugin", in_sign=u'sbbs', out_sign=u's', method=self._getAvatar, async=True)
-if not os.path.exists(self.avatar_path):
+host.bridge.addMethod(u"avatarSet", u".plugin", in_sign=u'ss', out_sign=u'', method=self._setAvatar, async=True)
-os.makedirs(self.avatar_path)
+host.trigger.add(u"presence_available", self.presenceAvailableTrigger)
-self.cache = {}
+host.memory.setSignalOnUpdate(u"avatar")
-host.bridge.addMethod("getCard", ".plugin", in_sign='ss', out_sign='', method=self._getCard, async=True)
+host.memory.setSignalOnUpdate(u"nick")
-host.bridge.addMethod("getAvatarFile", ".plugin", in_sign='s', out_sign='s', method=self.getAvatarFile)
-host.bridge.addMethod("getAvatar", ".plugin", in_sign='ss', out_sign='s', method=self._getAvatar, async=True)
-host.bridge.addMethod("setAvatar", ".plugin", in_sign='ss', out_sign='', method=self.setAvatar, async=True)
-host.trigger.add("presence_available", self.presenceAvailableTrigger)
-host.memory.setSignalOnUpdate("avatar")
-host.memory.setSignalOnUpdate("nick")
 def getHandler(self, profile):
 return XEP_0054_handler(self)
+def isRoom(self, client, entity_jid):
+"""Tell if a jid is a MUC one
+@param entity_jid(jid.JID): full or bare jid of the entity check
+@return (bool): True if the bare jid of the entity is a room jid
+"""
+try:
+self.host.plugins['XEP-0045'].checkRoomJoined(client, entity_jid.userhostJID())
+except exceptions.NotFound:
+return False
+else:
+return True
+def getBareOrFull(self, client, jid_):
+"""use full jid if jid_ is an occupant of a room, bare jid else
+@param jid_(jid.JID): entity to test
+@return (jid.JID): bare or full jid
+"""
+if jid_.resource:
+if not self.isRoom(client, jid_):
+return jid_.userhostJID()
+return jid_
 def presenceAvailableTrigger(self, presence_elt, client):
-if client.jid.userhost() in self.cache[client.profile]:
+if client.jid.userhost() in client._cache_0054:
 try:
-avatar_hash = self.cache[client.profile][client.jid.userhost()]['avatar']
+avatar_hash = client._cache_0054[client.jid.userhost()]['avatar']
 except KeyError:
 log.info(u"No avatar in cache for {}".format(client.jid.userhost()))
 return True
 x_elt = domish.Element((NS_VCARD_UPDATE, 'x'))
 x_elt.addElement('photo', content=avatar_hash)
 presence_elt.addChild(x_elt)
 return True
-def isRoom(self, client, entity_jid):
+@defer.inlineCallbacks
-"""Tell if a jid is a MUC one
+def profileConnecting(self, profile):
+client = self.host.getClient(profile)
-@param entity_jid(jid.JID): full or bare jid of the entity check
+client._cache_0054 = persistent.PersistentBinaryDict(NS_VCARD, profile)
-@return (bool): True if the bare jid of the entity is a room jid
+yield client._cache_0054.load()
-"""
+self._fillCachedValues(profile)
-try:
-self.host.plugins['XEP-0045'].checkRoomJoined(client, entity_jid.userhostJID())
-except exceptions.NotFound:
-return False
-else:
-return True
 def _fillCachedValues(self, profile):
-#FIXME: this is really suboptimal, need to be reworked
+#FIXME: this may need to be reworked
-#       the current naive approach keeps a map between all jids of all profiles
+#       the current naive approach keeps a map between all jids
 #       in persistent cache, then put avatar hashs in memory.
-#       Hashes should be shared between profiles
+#       Hashes should be shared between profiles (or not ? what
-for jid_s, data in self.cache[profile].iteritems():
+#       if the avatar is different depending on who is requesting it
+#       this is not possible with vcard-tmp, but it is with XEP-0084).
+#       Loading avatar on demand per jid may be a option to investigate.
+client = self.host.getClient(profile)
+for jid_s, data in client._cache_0054.iteritems():
 jid_ = jid.JID(jid_s)
 for name in CACHED_DATA:
 try:
+value = data[name]
+if value is None:
+log.error(u"{name} value for {jid_} is None, ignoring".format(name=name, jid_=jid_))
+continue
 self.host.memory.updateEntityData(jid_, name, data[name], silent=True, profile_key=profile)
 except KeyError:
 pass
-@defer.inlineCallbacks
-def profileConnecting(self, profile):
-self.cache[profile] = persistent.PersistentBinaryDict(NS_VCARD, profile)
-yield self.cache[profile].load()
-self._fillCachedValues(profile)
-def profileDisconnected(self, profile):
-log.debug(u"Deleting profile cache for avatars")
-del self.cache[profile]
 def updateCache(self, client, jid_, name, value):
 """update cache value
 save value in memory in case of change
 @param jid_(jid.JID): jid of the owner of the vcard
 @param name(str): name of the item which changed
-@param value(unicode): new value of the item
+@param value(unicode, None): new value of the item
-"""
+None to delete
-if jid_.resource:
+"""
-if not self.isRoom(client, jid_):
+jid_ = self.getBareOrFull(client, jid_)
-# VCard are retrieved with bare jid
+jid_s = jid_.full()
-# but MUC room is a special case
-jid_ = jid.userhostJID()
+if value is None:
+try:
-self.host.memory.updateEntityData(jid_, name, value, profile_key=client.profile)
+self.host.memory.delEntityDatum(jid_, name, client.profile)
-if name in CACHED_DATA:
+except (KeyError, exceptions.UnknownEntityError):
-jid_s = jid_.userhost()
+pass
-self.cache[client.profile].setdefault(jid_s, {})[name] = value
+if name in CACHED_DATA:
-self.cache[client.profile].force(jid_s)
+try:
+del client._cache_0054[jid_s][name]
+except KeyError:
+pass
+else:
+client._cache_0054.force(jid_s)
+else:
+self.host.memory.updateEntityData(jid_, name, value, profile_key=client.profile)
+if name in CACHED_DATA:
+client._cache_0054.setdefault(jid_s, {})[name] = value
+client._cache_0054.force(jid_s)
 def getCache(self, client, entity_jid, name):
 """return cached value for jid
 @param entity_jid: target contact
 @param name: name of the value ('nick' or 'avatar')
 @return: wanted value or None"""
-if entity_jid.resource:
+entity_jid = self.getBareOrFull(client, entity_jid)
-if not self.isRoom(client, entity_jid):
-# VCard are retrieved with bare jid
-# but MUC room is a special case
-entity_jid = jid.userhostJID()
 try:
 data = self.host.memory.getEntityData(entity_jid, [name], client.profile)
 except exceptions.UnknownEntityError:
 return None
 return data.get(name)
-def _getFilename(self, hash_):
+def savePhoto(self, client, photo_elt, entity_jid):
-"""Get filename from hash
+"""Parse a <PHOTO> photo_elt and save the picture"""
+# XXX: this method is launched in a separate thread
-@param hash_: hash of the avatar
+try:
-@return (str): absolute filename of the avatar
+mime_type = unicode(photo_elt.elements(NS_VCARD, 'TYPE').next())
-"""
+except StopIteration:
-return os.path.join(self.avatar_path, hash_)
+log.warning(u"no MIME type found, assuming image/png")
+mime_type = u"image/png"
-def saveAvatarFile(self, data, hash_):
-"""Save the avatar picture if it doesn't already exists
-@param data(str): binary image of the avatar
-@param hash_(str): hash of the binary data (will be used for the filename)
-"""
-filename = self._getFilename(hash_)
-if not os.path.exists(filename):
-with open(filename, 'wb') as file_:
-file_.write(data)
-log.debug(_(u"file saved to %s") % hash_)
 else:
-log.debug(_(u"file [%s] already in cache") % hash_)
+if not mime_type:
+log.warning(u"empty MIME type, assuming image/png")
-def savePhoto(self, photo_elt, target):
+mime_type = u"image/png"
-"""Parse a <PHOTO> photo_elt and save the picture"""
+elif mime_type not in ("image/gif", "image/jpeg", "image/png"):
-try:
+if mime_type == "image/x-png":
-type_ = unicode(photo_elt.elements(NS_VCARD, 'TYPE').next())
+# XXX: this old MIME type is still used by some clients
+mime_type = "image/png"
+else:
+# TODO: handle other image formats (svg?)
+log.warning(u"following avatar image format is not handled: {type} [{jid}]".format(
+type=mime_type, jid=entity_jid.full()))
+raise Failure(exceptions.DataError())
+ext = mimetypes.guess_extension(mime_type, strict=False)
+assert ext is not None
+log.debug(u'photo of type {type} with extension {ext} found [{jid}]'.format(
+type=mime_type, ext=ext, jid=entity_jid.full()))
+try:
+buf = str(photo_elt.elements(NS_VCARD, 'BINVAL').next())
 except StopIteration:
-type_ = None
+log.warning(u"BINVAL element not found")
-else:
+raise Failure(exceptions.NotFound())
-if type_ and type_ not in ("image/gif", "image/jpeg", "image/png"):
-# TODO: handle other image formats (svg?)
-log.warning(u"following avatar image format is not handled: {type} [{jid}]".format(
-type=type_, jid=target.full()))
-return
-log.debug(u'Photo of type {type} found [{jid}]'.format(
-type=type_, jid=target.full()))
-try:
-bin_elt = photo_elt.elements(NS_VCARD, 'BINVAL').next()
-except StopIteration:
-return
-buf = str(bin_elt)
 if not buf:
-log.warning(u"empty avatar for {jid}".format(jid=target.full()))
+log.warning(u"empty avatar for {jid}".format(jid=entity_jid.full()))
-return
+raise Failure(exceptions.NotFound())
 log.debug(_(u'Decoding binary'))
 decoded = b64decode(buf)
+del buf
 image_hash = sha1(decoded).hexdigest()
-self.saveAvatarFile(decoded, image_hash)
+with client.cache.cacheData(
+PLUGIN_INFO['import_name'],
+image_hash,
+mime_type,
+# we keep in cache for 1 year
+MAX_AGE
+) as f:
+f.write(decoded)
 return image_hash
 @defer.inlineCallbacks
-def vCard2Dict(self, client, vcard, target):
+def vCard2Dict(self, client, vcard, entity_jid):
 """Convert a VCard to a dict, and save binaries"""
-log.debug(_("parsing vcard"))
+log.debug((u"parsing vcard"))
-dictionary = {}
+vcard_dict = {}
 for elem in vcard.elements():
 if elem.name == 'FN':
-dictionary['fullname'] = unicode(elem)
+vcard_dict['fullname'] = unicode(elem)
 elif elem.name == 'NICKNAME':
-dictionary['nick'] = unicode(elem)
+vcard_dict['nick'] = unicode(elem)
-self.updateCache(client, target, 'nick', dictionary['nick'])
+self.updateCache(client, entity_jid, 'nick', vcard_dict['nick'])
 elif elem.name == 'URL':
-dictionary['website'] = unicode(elem)
+vcard_dict['website'] = unicode(elem)
 elif elem.name == 'EMAIL':
-dictionary['email'] = unicode(elem)
+vcard_dict['email'] = unicode(elem)
 elif elem.name == 'BDAY':
-dictionary['birthday'] = unicode(elem)
+vcard_dict['birthday'] = unicode(elem)
 elif elem.name == 'PHOTO':
 # TODO: handle EXTVAL
-avatar_hash = yield threads.deferToThread(self.savePhoto, elem, target)
+try:
-if avatar_hash is None: # can happen e.g. in case of empty photo elem
+avatar_hash = yield threads.deferToThread(
-continue
+self.savePhoto, client, elem, entity_jid)
-dictionary['avatar'] = avatar_hash
+except (exceptions.DataError, exceptions.NotFound) as e:
-self.updateCache(client, target, 'avatar', dictionary['avatar'])
+avatar_hash = ''
+vcard_dict['avatar'] = avatar_hash
+except Exception as e:
+log.error(u"avatar saving error: {}".format(e))
+avatar_hash = None
+else:
+vcard_dict['avatar'] = avatar_hash
+self.updateCache(client, entity_jid, 'avatar', avatar_hash)
 else:
-log.debug(_('FIXME: [%s] VCard tag is not managed yet') % elem.name)
+log.debug(u'FIXME: [{}] VCard tag is not managed yet'.format(elem.name))
-# if a data in cache doesn't exist anymore, we need to reset it
+# if a data in cache doesn't exist anymore, we need to delete it
-# so we check CACHED_DATA no gotten (i.e. not in dictionary keys)
+# so we check CACHED_DATA no gotten (i.e. not in vcard_dict keys)
 # and we reset them
-for datum in CACHED_DATA.difference(dictionary.keys()):
+for datum in CACHED_DATA.difference(vcard_dict.keys()):
-log.debug(u"reseting vcard datum [{datum}] for {entity}".format(datum=datum, entity=target.full()))
+log.debug(u"reseting vcard datum [{datum}] for {entity}".format(datum=datum, entity=entity_jid.full()))
-self.updateCache(client, target, datum, '')
+self.updateCache(client, entity_jid, datum, None)
-defer.returnValue(dictionary)
+defer.returnValue(vcard_dict)
-def _getCardCb(self, iq_elt, to_jid, client):
+def _vCardCb(self, iq_elt, to_jid, client):
 """Called after the first get IQ"""
 log.debug(_("VCard found"))
 try:
 vcard_elt = iq_elt.elements(NS_VCARD, "vCard").next()
 except KeyError:
 from_jid = client.jid.userhostJID()
 d = self.vCard2Dict(client, vcard_elt, from_jid)
 return d
-def _getCardEb(self, failure_, to_jid, client):
+def _vCardEb(self, failure_, to_jid, client):
 """Called when something is wrong with registration"""
 log.warning(u"Can't get vCard for {jid}: {failure}".format(jid=to_jid.full, failure=failure_))
-self.updateCache(client, to_jid, "avatar", '')
+self.updateCache(client, to_jid, "avatar", None)
-def _getCard(self, target_s, profile_key=C.PROF_KEY_NONE):
+def getCard(self, client, entity_jid):
-client = self.host.getClient(profile_key)
-return self.getCard(client, jid.JID(target_s))
-def getCard(self, client, target):
 """Ask server for VCard
-@param target(jid.JID): jid from which we want the VCard
+@param entity_jid(jid.JID): jid from which we want the VCard
 @result: id to retrieve the profile
 """
-target_bare = target.userhostJID()
+entity_jid = self.getBareOrFull(client, entity_jid)
-to_jid = target if self.isRoom(client, target_bare) else target_bare
+log.debug(u"Asking for {}'s VCard".format(entity_jid.full()))
-log.debug(_(u"Asking for %s's VCard") % to_jid.userhost())
 reg_request = client.IQ('get')
 reg_request["from"] = client.jid.full()
-reg_request["to"] = to_jid.full()
+reg_request["to"] = entity_jid.full()
 reg_request.addElement('vCard', NS_VCARD)
-d = reg_request.send(to_jid.full()).addCallbacks(self._getCardCb, self._getCardEb, callbackArgs=[to_jid, client], errbackArgs=[to_jid, client])
+d = reg_request.send(entity_jid.full()).addCallbacks(self._vCardCb, self._vCardEb, callbackArgs=[entity_jid, client], errbackArgs=[entity_jid, client])
 return d
-def getAvatarFile(self, avatar_hash):
+def _getCardCb(self, dummy, client, entity):
-"""Give the full path of avatar from hash
+try:
-@param avatar_hash(unicode): SHA1 hash
+return client._cache_0054[entity.full()]['avatar']
-@return(unicode): full_path or empty string if avatar_hash is empty
+except KeyError:
-or if avatar is not found in cache
+raise Failure(exceptions.NotFound())
-"""
-if not avatar_hash:
+def _getAvatar(self, entity, cache_only, hash_only, profile):
-return ""
-filename = self.avatar_path + '/' + avatar_hash
-if not os.path.exists(filename):
-log.error(_(u"Asking for an uncached avatar [%s]") % avatar_hash)
-return ""
-return filename
-def _getAvatar(self, entity, profile):
 client = self.host.getClient(profile)
-return self.getAvatar(client, jid.JID(entity))
+d = self.getAvatar(client, jid.JID(entity))
+d.addErrback(lambda dummy: '')
-def _getAvatarGotCard(self, dummy, client, entity):
-try:
+return d
-self.cache[client.profile][entity.full()]['avatar']
+def getAvatar(self, client, entity, cache_only=True, hash_only=False):
+"""get avatar full path or hash
+if avatar is not in local cache, it will be requested to the server
+@param entity(jid.JID): entity to get avatar from
+@param cache_only(bool): if False, will request vCard if avatar is
+not in cache
+@param hash_only(bool): if True only return hash, not full path
+@raise exceptions.NotFound: no avatar found
+"""
+entity = self.getBareOrFull(client, entity)
+full_path = None
+try:
+# we first check if we have avatar in cache
+avatar_hash = client._cache_0054[entity.full()]['avatar']
+if avatar_hash:
+# avatar is known and exists
+full_path = client.cache.getFilePath(avatar_hash)
+if full_path is None:
+# cache file is not available (probably expired)
+raise KeyError
+else:
+# avatar has already been checked but it is not set
+full_path = u''
 except KeyError:
-return ""
+# avatar is not in cache
+if cache_only:
-def getAvatar(self, client, entity):
+return defer.fail(Failure(exceptions.NotFound()))
-try:
+# we request vCard to get avatar
-avatar_hash = self.cache[client.profile][entity.full()]['avatar']
-except KeyError:
 d = self.getCard(client, entity)
-d.addCallback(self._getAvatarGotCard, client, entity)
+d.addCallback(self._getCardCb, client, entity)
 else:
+# avatar is in cache, we can return hash
 d = defer.succeed(avatar_hash)
-d.addCallback(self.getAvatarFile)
+if not hash_only:
+# full path is requested
+if full_path is None:
+d.addCallback(client.cache.getFilePath)
+else:
+d.addCallback(lambda dummy: full_path)
 return d
-def _buildSetAvatar(self, vcard_set, filepath):
+def _buildSetAvatar(self, client, vcard_set, file_path):
-try:
+# XXX: this method is executed in a separate thread
-img = Image.open(filepath)
+try:
+img = Image.open(file_path)
 except IOError:
-return Failure(exceptions.DataError("Can't open image"))
+return Failure(exceptions.DataError(u"Can't open image"))
 if img.size != AVATAR_DIM:
 img.thumbnail(AVATAR_DIM, Image.ANTIALIAS)
 if img.size[0] != img.size[1]:  # we need to crop first
 left, upper = (0, 0)
 vcard_elt = vcard_set.addElement('vCard', NS_VCARD)
 photo_elt = vcard_elt.addElement('PHOTO')
 photo_elt.addElement('TYPE', content='image/png')
 photo_elt.addElement('BINVAL', content=b64encode(img_buf.getvalue()))
-img_hash = sha1(img_buf.getvalue()).hexdigest()
+image_hash = sha1(img_buf.getvalue()).hexdigest()
-self.saveAvatarFile(img_buf.getvalue(), img_hash)
+with client.cache.cacheData(
-return (vcard_set, img_hash)
+PLUGIN_INFO['import_name'],
+image_hash,
-def setAvatar(self, filepath, profile_key=C.PROF_KEY_NONE):
+"image/png",
+MAX_AGE
+) as f:
+f.write(img_buf.getvalue())
+return vcard_set, image_hash
+def _setAvatar(self, file_path, profile_key=C.PROF_KEY_NONE):
+client = self.host.getClient(profile_key)
+return self.setAvatar(client, file_path)
+def setAvatar(self, client, file_path):
 """Set avatar of the profile
-@param filepath: path of the image of the avatar"""
+@param file_path: path of the image of the avatar
+"""
 #TODO: This is a temporary way of setting the avatar, as other VCard information is not managed.
 #      A proper full VCard management should be done (and more generaly a public/private profile)
-client = self.host.getClient(profile_key)
+vcard_set = client.IQ()
+d = threads.deferToThread(self._buildSetAvatar, client, vcard_set, file_path)
-vcard_set = IQ(client.xmlstream, 'set')
-d = threads.deferToThread(self._buildSetAvatar, vcard_set, filepath)
 def elementBuilt(result):
 """Called once the image is at the right size/format, and the vcard set element is build"""
-set_avatar_elt, img_hash = result
+set_avatar_elt, image_hash = result
-self.updateCache(client, client.jid.userhostJID(), 'avatar', img_hash)
+self.updateCache(client, client.jid.userhostJID(), 'avatar', image_hash)
 return set_avatar_elt.send().addCallback(lambda ignore: client.presence.available()) # FIXME: should send the current presence, not always "available" !
 d.addCallback(elementBuilt)
 return d
 return [disco.DiscoFeature(NS_VCARD)]
 def getDiscoItems(self, requestor, target, nodeIdentifier=''):
 return []
+def _checkAvatarHash(self, dummy, client, entity, given_hash):
+"""check that hash in cash (i.e. computed hash) is the same as given one"""
+# XXX: if they differ, the avater will be requested on each connection
+# TODO: try to avoid re-requesting avatar in this case
+computed_hash = self.plugin_parent.getCache(client, entity, 'avatar')
+if computed_hash != given_hash:
+log.warning(u"computed hash differs from given hash for {entity}:\n"
+"computed: {computed}\ngiven: {given}".format(
+entity=entity, computed=computed_hash, given=given_hash))
 def update(self, presence):
 """Called on <presence/> stanza with vcard data
 Check for avatar information, and get VCard if needed
 @param presend(domish.Element): <presence/> stanza
 """
-from_jid = jid.JID(presence['from'])
+client = self.parent
-if from_jid.resource and not self.plugin_parent.isRoom(self.parent, from_jid):
+entity_jid = self.plugin_parent.getBareOrFull(client, jid.JID(presence['from']))
-from_jid = from_jid.userhostJID()
 #FIXME: wokkel's data_form should be used here
 try:
 x_elt = presence.elements(NS_VCARD_UPDATE, 'x').next()
 except StopIteration:
 return
 try:
 photo_elt = x_elt.elements(NS_VCARD_UPDATE, 'photo').next()
 except StopIteration:
 return
-hash_ = str(photo_elt)
+hash_ = unicode(photo_elt).strip()
+if hash_ == C.HASH_SHA1_EMPTY:
+hash_ = u''
+old_avatar = self.plugin_parent.getCache(client, entity_jid, 'avatar')
+if old_avatar == hash_:
+# no change, we can return...
+if hash_:
+# ...but we double check that avatar is in cache
+file_path = client.cache.getFilePath(hash_)
+if file_path is None:
+log.error(u"Avatar for [{}] should be in cache but it is not! We get it".format(entity_jid.full()))
+self.plugin_parent.getCard(client, entity_jid)
+else:
+log.debug(u"avatar for {} already in cache".format(entity_jid.full()))
+return
 if not hash_:
+# the avatar has been removed
+# XXX: we use empty string instead of None to indicate that we took avatar
+#      but it is empty on purpose
+self.plugin_parent.updateCache(client, entity_jid, 'avatar', '')
 return
-old_avatar = self.plugin_parent.getCache(self.parent, from_jid, 'avatar')
-filename = self.plugin_parent._getFilename(hash_)
+file_path = client.cache.getFilePath(hash_)
-if not old_avatar or old_avatar != hash_:
+if file_path is not None:
-if os.path.exists(filename):
+log.debug(u"New avatar found for [{}], it's already in cache, we use it".format(entity_jid.full()))
-log.debug(u"New avatar found for [{}], it's already in cache, we use it".format(from_jid.full()))
+self.plugin_parent.updateCache(client, entity_jid, 'avatar', hash_)
-self.plugin_parent.updateCache(self.parent, from_jid, 'avatar', hash_)
-else:
-log.debug(u'New avatar found for [{}], requesting vcard'.format(from_jid.full()))
-self.plugin_parent.getCard(self.parent, from_jid)
 else:
-if os.path.exists(filename):
+log.debug(u'New avatar found for [{}], requesting vcard'.format(entity_jid.full()))
-log.debug(u"avatar for {} already in cache".format(from_jid.full()))
+d = self.plugin_parent.getCard(client, entity_jid)
-else:
+d.addCallback(self._checkAvatarHash, client, entity_jid, hash_)
-log.error(u"Avatar for [{}] should be in cache but it is not ! We get it".format(from_jid.full()))
-self.plugin_parent.getCard(self.parent, from_jid)

Mercurial > libervia-backend

comparison src/plugins/plugin_xep_0054.py @ 2123:c42aab22c2c0