709366fe13
- Avatar disabling was not correctly handled for all cases, this should now be fixed. - Avatar retrieval is now down only on PEP events, no directly anymore. `get_avatar` only returns cached version.
299 lines
11 KiB
Python
299 lines
11 KiB
Python
#!/usr/bin/env python3
|
|
|
|
# Libervia plugin for XEP-0084
|
|
# Copyright (C) 2009-2026 Jérôme Poisson (goffi@goffi.org)
|
|
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU Affero General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU Affero General Public License for more details.
|
|
|
|
# You should have received a copy of the GNU Affero General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
from typing import Any, Dict
|
|
|
|
from base64 import b64decode
|
|
from pathlib import Path
|
|
|
|
from twisted.internet import defer
|
|
from twisted.words.protocols.jabber.xmlstream import XMPPHandler
|
|
from twisted.words.protocols.jabber import jid, error
|
|
from twisted.words.xish import domish
|
|
from zope.interface import implementer
|
|
from tx_xmpp import disco, itx_xmpp, pubsub
|
|
|
|
from libervia.backend.core.constants import Const as C
|
|
from libervia.backend.core.i18n import _
|
|
from libervia.backend.core.log import getLogger
|
|
from libervia.backend.core.core_types import SatXMPPEntity
|
|
from libervia.backend.core import exceptions
|
|
|
|
log = getLogger(__name__)
|
|
|
|
IMPORT_NAME = "XEP-0084"
|
|
|
|
PLUGIN_INFO = {
|
|
C.PI_NAME: "User Avatar",
|
|
C.PI_IMPORT_NAME: IMPORT_NAME,
|
|
C.PI_TYPE: C.PLUG_TYPE_XEP,
|
|
C.PI_MODES: C.PLUG_MODE_BOTH,
|
|
C.PI_PROTOCOLS: ["XEP-0084"],
|
|
C.PI_DEPENDENCIES: ["IDENTITY", "XEP-0060", "XEP-0163"],
|
|
C.PI_MAIN: "XEP_0084",
|
|
C.PI_HANDLER: "yes",
|
|
C.PI_DESCRIPTION: _("""XEP-0084 (User Avatar) implementation"""),
|
|
}
|
|
|
|
NS_AVATAR = "urn:xmpp:avatar"
|
|
NS_AVATAR_METADATA = f"{NS_AVATAR}:metadata"
|
|
NS_AVATAR_DATA = f"{NS_AVATAR}:data"
|
|
|
|
|
|
class XEP_0084:
|
|
namespace_metadata = NS_AVATAR_METADATA
|
|
namespace_data = NS_AVATAR_DATA
|
|
|
|
def __init__(self, host):
|
|
log.info(_("XEP-0084 (User Avatar) plugin initialization"))
|
|
host.register_namespace("avatar_metadata", NS_AVATAR_METADATA)
|
|
host.register_namespace("avatar_data", NS_AVATAR_DATA)
|
|
self.host = host
|
|
self._p = host.plugins["XEP-0060"]
|
|
self._i = host.plugins["IDENTITY"]
|
|
self._i.register(
|
|
IMPORT_NAME, "avatar", self.get_avatar, self.set_avatar, priority=2000
|
|
)
|
|
host.plugins["XEP-0163"].add_pep_event(
|
|
None, NS_AVATAR_METADATA, self._on_metadata_update
|
|
)
|
|
|
|
def get_handler(self, client):
|
|
return XEP_0084_Handler()
|
|
|
|
def _on_metadata_update(self, itemsEvent, profile):
|
|
client = self.host.get_client(profile)
|
|
defer.ensureDeferred(self.on_metadata_update(client, itemsEvent))
|
|
|
|
async def on_metadata_update(
|
|
self, client: SatXMPPEntity, itemsEvent: pubsub.ItemsEvent
|
|
) -> None:
|
|
"""Handle PEP avatar metadata update event.
|
|
|
|
Parse metadata, fetch data if not cached, and update identity cache.
|
|
"""
|
|
entity = itemsEvent.sender
|
|
service = entity.userhostJID()
|
|
|
|
items = itemsEvent.items
|
|
if not items:
|
|
return
|
|
|
|
if items[0].name == "retract":
|
|
log.debug(f"Avatar retracted for {entity.full()}")
|
|
await self._i.update(client, IMPORT_NAME, "avatar", None, entity)
|
|
return
|
|
|
|
item_elt = items[0]
|
|
try:
|
|
metadata_elt = next(item_elt.elements(NS_AVATAR_METADATA, "metadata"))
|
|
except StopIteration:
|
|
log.warning(f"missing metadata element: {item_elt.toXml()}")
|
|
return
|
|
|
|
for info_elt in metadata_elt.elements(NS_AVATAR_METADATA, "info"):
|
|
try:
|
|
metadata = {
|
|
"id": str(info_elt["id"]),
|
|
"size": int(info_elt["bytes"]),
|
|
"media_type": str(info_elt["type"]),
|
|
}
|
|
avatar_id = metadata["id"]
|
|
if not avatar_id:
|
|
raise ValueError
|
|
except (KeyError, ValueError):
|
|
log.warning(f"invalid <info> element: {item_elt.toXml()}")
|
|
return None
|
|
# FIXME: to simplify, we only handle image/png for now
|
|
if metadata["media_type"] == "image/png":
|
|
break
|
|
else:
|
|
# mandatory image/png is missing, or avatar is disabled
|
|
# (https://xmpp.org/extensions/xep-0084.html#pub-disable)
|
|
log.debug(f"Avatar disabled for {entity.full()}")
|
|
await self._i.update(client, IMPORT_NAME, "avatar", None, entity)
|
|
return
|
|
|
|
# Check if avatar is already cached
|
|
try:
|
|
cached = self.host.memory.get_entity_datum(client, entity, "avatar")
|
|
except (KeyError, exceptions.UnknownEntityError):
|
|
cached = None
|
|
|
|
if cached is not None:
|
|
cached_uid = cached.get("cache_uid") if isinstance(cached, dict) else None
|
|
if cached_uid == avatar_id:
|
|
log.debug(f"Avatar already cached for {entity.full()} (id={avatar_id})")
|
|
return
|
|
log.debug(
|
|
f"Avatar changed for {entity.full()} (old={cached_uid}, new={avatar_id})"
|
|
)
|
|
|
|
# Fetch avatar data if not already cached
|
|
cache_data = self.host.common_cache.get_metadata(avatar_id)
|
|
if not cache_data:
|
|
cache_data = await self._fetch_avatar_data(
|
|
client, service, avatar_id, metadata["media_type"]
|
|
)
|
|
if cache_data is None:
|
|
log.warning(f"Failed to fetch avatar data for {entity.full()}")
|
|
return
|
|
|
|
log.debug(f"Avatar updated for {entity.full()} (id={avatar_id})")
|
|
avatar_metadata = self._i.avatar_build_metadata(
|
|
cache_data["path"], cache_data["mime_type"], avatar_id
|
|
)
|
|
await self._i.update(client, IMPORT_NAME, "avatar", avatar_metadata, entity)
|
|
|
|
async def _fetch_avatar_data(
|
|
self,
|
|
client: SatXMPPEntity,
|
|
service: jid.JID,
|
|
avatar_id: str,
|
|
media_type: str,
|
|
) -> dict | None:
|
|
"""Fetch avatar data from PEP data node and cache it.
|
|
|
|
@return: Cache data dict with path and mime_type, or None on failure.
|
|
"""
|
|
try:
|
|
data_items, __ = await self._p.get_items(
|
|
client, service, NS_AVATAR_DATA, item_ids=[avatar_id]
|
|
)
|
|
data_item_elt = data_items[0]
|
|
except (error.StanzaError, IndexError) as e:
|
|
log.warning(
|
|
f"Can't retrieve avatar of {service.full()} with ID {avatar_id!r}: "
|
|
f"{e}"
|
|
)
|
|
return None
|
|
|
|
try:
|
|
avatar_buf = b64decode(
|
|
str(next(data_item_elt.elements(NS_AVATAR_DATA, "data")))
|
|
)
|
|
except Exception as e:
|
|
log.warning(
|
|
f"invalid data element for {service.full()} with avatar ID "
|
|
f"{avatar_id!r}: {e}\n{data_item_elt.toXml()}"
|
|
)
|
|
return None
|
|
|
|
with self.host.common_cache.cache_data(IMPORT_NAME, avatar_id, media_type) as f:
|
|
f.write(avatar_buf)
|
|
return {"path": Path(f.name), "mime_type": media_type}
|
|
|
|
async def get_avatar(self, client: SatXMPPEntity, entity_jid: jid.JID) -> dict | None:
|
|
"""Get avatar data from cache."""
|
|
try:
|
|
cached = self.host.memory.get_entity_datum(client, entity_jid, "avatar")
|
|
except (KeyError, exceptions.UnknownEntityError):
|
|
return None
|
|
|
|
if not cached:
|
|
return None
|
|
|
|
cache_uid = cached.get("cache_uid")
|
|
filename = cached.get("filename")
|
|
if not cache_uid or not filename:
|
|
return None
|
|
|
|
try:
|
|
self.host.common_cache.get_metadata(cache_uid)
|
|
except Exception:
|
|
return None
|
|
|
|
return cached
|
|
|
|
def build_item_data_elt(self, avatar_data: Dict[str, Any]) -> domish.Element:
|
|
"""Generate the item for the data node
|
|
|
|
@param avatar_data: data as build by identity plugin (need to be filled with
|
|
"cache_uid" and "base64" keys)
|
|
"""
|
|
data_elt = domish.Element((NS_AVATAR_DATA, "data"))
|
|
data_elt.addContent(avatar_data["base64"])
|
|
return pubsub.Item(id=avatar_data["cache_uid"], payload=data_elt)
|
|
|
|
def build_item_metadata_elt(self, avatar_data: Dict[str, Any]) -> domish.Element:
|
|
"""Generate the item for the metadata node
|
|
|
|
@param avatar_data: data as build by identity plugin (need to be filled with
|
|
"cache_uid", "path", and "media_type" keys)
|
|
"""
|
|
metadata_elt = domish.Element((NS_AVATAR_METADATA, "metadata"))
|
|
info_elt = metadata_elt.addElement("info")
|
|
# FIXME: we only fill required elements for now (see
|
|
# https://xmpp.org/extensions/xep-0084.html#table-1)
|
|
info_elt["id"] = avatar_data["cache_uid"]
|
|
info_elt["type"] = avatar_data["media_type"]
|
|
info_elt["bytes"] = str(avatar_data["path"].stat().st_size)
|
|
return pubsub.Item(id=self._p.ID_SINGLETON, payload=metadata_elt)
|
|
|
|
async def set_avatar(
|
|
self, client: SatXMPPEntity, avatar_data: Dict[str, Any], entity: jid.JID
|
|
) -> None:
|
|
"""Set avatar of the profile
|
|
|
|
@param avatar_data(dict): data of the image to use as avatar, as built by
|
|
IDENTITY plugin.
|
|
@param entity(jid.JID): entity whose avatar must be changed
|
|
"""
|
|
service = entity.userhostJID()
|
|
|
|
# Data
|
|
await self._p.create_if_new_node(
|
|
client,
|
|
service,
|
|
NS_AVATAR_DATA,
|
|
options={
|
|
self._p.OPT_ACCESS_MODEL: self._p.ACCESS_OPEN,
|
|
self._p.OPT_PERSIST_ITEMS: 1,
|
|
self._p.OPT_MAX_ITEMS: 1,
|
|
},
|
|
)
|
|
item_data_elt = self.build_item_data_elt(avatar_data)
|
|
await self._p.send_items(client, service, NS_AVATAR_DATA, [item_data_elt])
|
|
|
|
# Metadata
|
|
await self._p.create_if_new_node(
|
|
client,
|
|
service,
|
|
NS_AVATAR_METADATA,
|
|
options={
|
|
self._p.OPT_ACCESS_MODEL: self._p.ACCESS_OPEN,
|
|
self._p.OPT_PERSIST_ITEMS: 1,
|
|
self._p.OPT_MAX_ITEMS: 1,
|
|
},
|
|
)
|
|
item_metadata_elt = self.build_item_metadata_elt(avatar_data)
|
|
await self._p.send_items(client, service, NS_AVATAR_METADATA, [item_metadata_elt])
|
|
|
|
|
|
@implementer(itx_xmpp.IDisco)
|
|
class XEP_0084_Handler(XMPPHandler):
|
|
|
|
def getDiscoInfo(self, requestor, service, nodeIdentifier=""):
|
|
# NS_AVATAR_METADATA is already advertised by ``add_pep_event``.
|
|
# Only NS_AVATAR_DATA needs to be advertised here.
|
|
return [
|
|
disco.DiscoFeature(NS_AVATAR_DATA),
|
|
]
|
|
|
|
def getDiscoItems(self, requestor, service, nodeIdentifier=""):
|
|
return []
|