libervia-backend: sat/plugins/plugin_xep

comparison sat/plugins/plugin_xep_0060.py @ 3758:b7cef1b24f83

plugins XEP-0060, XEP-0376, XEP-0465, CLI: PAM + PSS implementation: - update psSubscriptionsGet to use serialised return value - implement XEP-0376 Pubsub Account Management - implement XEP-0465 Public Pubsub Subscriptions - CLI `pubsub` commands updated accordingly, and added `--public` flags to `subscribe`, `Subscriptions` and `node Subscriptions get` ⚠ `XEP-0465` is speculative, the XEP has been accepted by council but not published yet. As is should be the next one, and current latest one is `XEP-0464`, `XEP-0465` has been anticipated. rel 365

author	Goffi <goffi@goffi.org>
date	Fri, 13 May 2022 18:38:05 +0200
parents	5bda9d2e8b35
children	c61233f51b86

comparison

equal deleted inserted replaced

-:5bda9d2e8b35
+:b7cef1b24f83
 )
 host.bridge.addMethod(
 "psSubscriptionsGet",
 ".plugin",
 in_sign="sss",
-out_sign="aa{ss}",
+out_sign="s",
 method=self._subscriptions,
 async_=True,
 )
 host.bridge.addMethod(
 "psSubscribeToMany",
 sub_jid or client.jid.userhostJID(),
 subscriptionIdentifier,
 sender,
 )
-def _subscriptions(self, service, nodeIdentifier="", profile_key=C.PROF_KEY_NONE):
+@utils.ensure_deferred
+async def _subscriptions(
+self,
+service="",
+nodeIdentifier="",
+profile_key=C.PROF_KEY_NONE
+) -> str:
 client = self.host.getClient(profile_key)
 service = None if not service else jid.JID(service)
+subs = await self.subscriptions(client, service, nodeIdentifier or None)
-def gotSubscriptions(subscriptions):
+return data_format.serialise(subs)
-# we replace pubsub.Subscription instance by dict that we can serialize
-for idx, sub in enumerate(subscriptions):
+async def subscriptions(
-sub_dict = {
+self,
-"node": sub.nodeIdentifier,
+client: SatXMPPEntity,
-"subscriber": sub.subscriber.full(),
+service: Optional[jid.JID] = None,
-"state": sub.state,
+node: Optional[str] = None
-}
+) -> List[Dict[str, Union[str, bool]]]:
-if sub.subscriptionIdentifier is not None:
+"""Retrieve subscriptions from a service
-sub_dict["id"] = sub.subscriptionIdentifier
-subscriptions[idx] = sub_dict
-return subscriptions
-d = self.subscriptions(client, service, nodeIdentifier or None)
-d.addCallback(gotSubscriptions)
-return d
-def subscriptions(self, client, service, nodeIdentifier=None):
-"""retrieve subscriptions from a service
 @param service(jid.JID): PubSub service
 @param nodeIdentifier(unicode, None): node to check
 None to get all subscriptions
 """
-return client.pubsub_client.subscriptions(service, nodeIdentifier)
+cont, ret = await self.host.trigger.asyncReturnPoint(
+"XEP-0060_subscriptions", client, service, node
+)
+if not cont:
+return ret
+subs = await client.pubsub_client.subscriptions(service, node)
+ret = []
+for sub in subs:
+sub_dict = {
+"service": service.host if service else client.jid.host,
+"node": sub.nodeIdentifier,
+"subscriber": sub.subscriber.full(),
+"state": sub.state,
+}
+if sub.subscriptionIdentifier is not None:
+sub_dict["id"] = sub.subscriptionIdentifier
+ret.append(sub_dict)
+return ret
 ## misc tools ##
 def getNodeURI(self, service, node, item=None):
 """Return XMPP URI of a PubSub node
 for success, result in results
 ]
 # subscribe #
-def _getNodeSubscriptions(self, service_s, nodeIdentifier, profile_key):
+@utils.ensure_deferred
-client = self.host.getClient(profile_key)
+async def _getNodeSubscriptions(
-d = self.getNodeSubscriptions(
+self,
-client, jid.JID(service_s) if service_s else None, nodeIdentifier
+service: str,
-)
+node: str,
-d.addCallback(
+profile_key: str
-lambda subscriptions: {j.full(): a for j, a in subscriptions.items()}
+) -> Dict[str, str]:
-)
+client = self.host.getClient(profile_key)
-return d
+subs = await self.getNodeSubscriptions(
+client, jid.JID(service) if service else None, node
-def getNodeSubscriptions(self, client, service, nodeIdentifier):
+)
+return {j.full(): a for j, a in subs.items()}
+async def getNodeSubscriptions(
+self,
+client: SatXMPPEntity,
+service: Optional[jid.JID],
+nodeIdentifier: str
+) -> Dict[jid.JID, str]:
 """Retrieve subscriptions to a node
 @param nodeIdentifier(unicode): node to get subscriptions from
 """
 if not nodeIdentifier:
 raise exceptions.DataError("node identifier can't be empty")
 request = pubsub.PubSubRequest("subscriptionsGet")
 request.recipient = service
 request.nodeIdentifier = nodeIdentifier
-def cb(iq_elt):
+iq_elt = await request.send(client.xmlstream)
 try:
 subscriptions_elt = next(
 iq_elt.pubsub.elements((pubsub.NS_PUBSUB, "subscriptions"))
+)
+except StopIteration:
+raise ValueError(
+_("Invalid result: missing <subscriptions> element: {}").format(
+iq_elt.toXml
 )
-except StopIteration:
+)
-raise ValueError(
+except AttributeError as e:
-_("Invalid result: missing <subscriptions> element: {}").format(
+raise ValueError(_("Invalid result: {}").format(e))
-iq_elt.toXml
+try:
-)
+return {
+jid.JID(s["jid"]): s["subscription"]
+for s in subscriptions_elt.elements(
+(pubsub.NS_PUBSUB, "subscription")
 )
-except AttributeError as e:
+}
-raise ValueError(_("Invalid result: {}").format(e))
+except KeyError:
-try:
+raise ValueError(
-return {
+_("Invalid result: bad <subscription> element: {}").format(
-jid.JID(s["jid"]): s["subscription"]
+iq_elt.toXml
-for s in subscriptions_elt.elements(
-(pubsub.NS_PUBSUB, "subscription")
-)
-}
-except KeyError:
-raise ValueError(
-_("Invalid result: bad <subscription> element: {}").format(
-iq_elt.toXml
-)
 )
+)
-d = request.send(client.xmlstream)
-d.addCallback(cb)
-return d
 def _setNodeSubscriptions(
 self, service_s, nodeIdentifier, subscriptions, profile_key=C.PROF_KEY_NONE
 ):
 client = self.host.getClient(profile_key)

Mercurial > libervia-backend

comparison sat/plugins/plugin_xep_0060.py @ 3758:b7cef1b24f83