Reformatted code base using black.
This commit is contained in:
parent
56319cbad3
commit
53fdaa9d09
1 changed files with 12604 additions and 8966 deletions
|
|
@ -70,11 +70,12 @@ Extra = namedtuple("Extra", ("rsm_request", "extra"))
|
|||
TIMEOUT = 30
|
||||
# minimum features that a pubsub service must have to be selectable as default
|
||||
DEFAULT_PUBSUB_MIN_FEAT = {
|
||||
'http://jabber.org/protocol/pubsub#persistent-items',
|
||||
'http://jabber.org/protocol/pubsub#publish',
|
||||
'http://jabber.org/protocol/pubsub#retract-items',
|
||||
"http://jabber.org/protocol/pubsub#persistent-items",
|
||||
"http://jabber.org/protocol/pubsub#publish",
|
||||
"http://jabber.org/protocol/pubsub#retract-items",
|
||||
}
|
||||
|
||||
|
||||
class XEP_0060(object):
|
||||
OPT_ACCESS_MODEL = "pubsub#access_model"
|
||||
OPT_PERSIST_ITEMS = "pubsub#persist_items"
|
||||
|
|
@ -109,7 +110,9 @@ class XEP_0060(object):
|
|||
self.host = host
|
||||
self._rsm = host.plugins.get("XEP-0059")
|
||||
self._mam = host.plugins.get("XEP-0313")
|
||||
self._node_cb = {} # dictionnary of callbacks for node (key: node, value: list of callbacks)
|
||||
self._node_cb = (
|
||||
{}
|
||||
) # dictionnary of callbacks for node (key: node, value: list of callbacks)
|
||||
self.rt_sessions = sat_defer.RTDeferredSessions()
|
||||
host.bridge.add_method(
|
||||
"ps_node_create",
|
||||
|
|
@ -376,9 +379,11 @@ class XEP_0060(object):
|
|||
return {}
|
||||
try:
|
||||
return {
|
||||
"service": client.pubsub_service.full()
|
||||
if client.pubsub_service is not None
|
||||
else ""
|
||||
"service": (
|
||||
client.pubsub_service.full()
|
||||
if client.pubsub_service is not None
|
||||
else ""
|
||||
)
|
||||
}
|
||||
except AttributeError:
|
||||
if self.host.is_connected(profile):
|
||||
|
|
@ -423,12 +428,7 @@ class XEP_0060(object):
|
|||
|
||||
return Extra(rsm_request, extra)
|
||||
|
||||
def add_managed_node(
|
||||
self,
|
||||
node: str,
|
||||
priority: int = 0,
|
||||
**kwargs: Callable
|
||||
):
|
||||
def add_managed_node(self, node: str, priority: int = 0, **kwargs: Callable):
|
||||
"""Add a handler for a node
|
||||
|
||||
@param node: node to monitor
|
||||
|
|
@ -514,31 +514,40 @@ class XEP_0060(object):
|
|||
# d.addCallback(lambda subs: [sub.getAttribute('node') for sub in subs if sub.getAttribute('subscription') == filter_])
|
||||
# return d
|
||||
|
||||
def _send_item(self, service, nodeIdentifier, payload, item_id=None, extra_ser="",
|
||||
profile_key=C.PROF_KEY_NONE):
|
||||
def _send_item(
|
||||
self,
|
||||
service,
|
||||
nodeIdentifier,
|
||||
payload,
|
||||
item_id=None,
|
||||
extra_ser="",
|
||||
profile_key=C.PROF_KEY_NONE,
|
||||
):
|
||||
client = self.host.get_client(profile_key)
|
||||
service = None if not service else jid.JID(service)
|
||||
payload = xml_tools.parse(payload)
|
||||
extra = data_format.deserialise(extra_ser)
|
||||
d = defer.ensureDeferred(self.send_item(
|
||||
client, service, nodeIdentifier, payload, item_id or None, extra
|
||||
))
|
||||
d = defer.ensureDeferred(
|
||||
self.send_item(
|
||||
client, service, nodeIdentifier, payload, item_id or None, extra
|
||||
)
|
||||
)
|
||||
d.addCallback(lambda ret: ret or "")
|
||||
return d
|
||||
|
||||
def _send_items(self, service, nodeIdentifier, items, extra_ser=None,
|
||||
profile_key=C.PROF_KEY_NONE):
|
||||
def _send_items(
|
||||
self, service, nodeIdentifier, items, extra_ser=None, profile_key=C.PROF_KEY_NONE
|
||||
):
|
||||
client = self.host.get_client(profile_key)
|
||||
service = None if not service else jid.JID(service)
|
||||
try:
|
||||
items = [xml_tools.parse(item) for item in items]
|
||||
except Exception as e:
|
||||
raise exceptions.DataError(_("Can't parse items: {msg}").format(
|
||||
msg=e))
|
||||
raise exceptions.DataError(_("Can't parse items: {msg}").format(msg=e))
|
||||
extra = data_format.deserialise(extra_ser)
|
||||
return defer.ensureDeferred(self.send_items(
|
||||
client, service, nodeIdentifier, items, extra=extra
|
||||
))
|
||||
return defer.ensureDeferred(
|
||||
self.send_items(client, service, nodeIdentifier, items, extra=extra)
|
||||
)
|
||||
|
||||
async def send_item(
|
||||
self,
|
||||
|
|
@ -547,7 +556,7 @@ class XEP_0060(object):
|
|||
nodeIdentifier: str,
|
||||
payload: domish.Element,
|
||||
item_id: Optional[str] = None,
|
||||
extra: Optional[Dict[str, Any]] = None
|
||||
extra: Optional[Dict[str, Any]] = None,
|
||||
) -> Optional[str]:
|
||||
"""High level method to send one item
|
||||
|
||||
|
|
@ -559,16 +568,12 @@ class XEP_0060(object):
|
|||
@return: id of the created item
|
||||
"""
|
||||
assert isinstance(payload, domish.Element)
|
||||
item_elt = domish.Element((pubsub.NS_PUBSUB, 'item'))
|
||||
item_elt = domish.Element((pubsub.NS_PUBSUB, "item"))
|
||||
if item_id is not None:
|
||||
item_elt['id'] = item_id
|
||||
item_elt["id"] = item_id
|
||||
item_elt.addChild(payload)
|
||||
published_ids = await self.send_items(
|
||||
client,
|
||||
service,
|
||||
nodeIdentifier,
|
||||
[item_elt],
|
||||
extra=extra
|
||||
client, service, nodeIdentifier, [item_elt], extra=extra
|
||||
)
|
||||
try:
|
||||
return published_ids[0]
|
||||
|
|
@ -582,7 +587,7 @@ class XEP_0060(object):
|
|||
nodeIdentifier: str,
|
||||
items: List[domish.Element],
|
||||
sender: Optional[jid.JID] = None,
|
||||
extra: Optional[Dict[str, Any]] = None
|
||||
extra: Optional[Dict[str, Any]] = None,
|
||||
) -> List[str]:
|
||||
"""High level method to send several items at once
|
||||
|
||||
|
|
@ -608,36 +613,47 @@ class XEP_0060(object):
|
|||
service = client.jid.userhostJID()
|
||||
parsed_items = []
|
||||
for item in items:
|
||||
if item.name != 'item':
|
||||
if item.name != "item":
|
||||
raise exceptions.DataError(_("Invalid item: {xml}").format(item.toXml()))
|
||||
item_id = item.getAttribute("id")
|
||||
parsed_items.append(pubsub.Item(id=item_id, payload=item.firstChildElement()))
|
||||
publish_options = extra.get(self.EXTRA_PUBLISH_OPTIONS)
|
||||
try:
|
||||
iq_result = await self.publish(
|
||||
client, service, nodeIdentifier, parsed_items, options=publish_options,
|
||||
sender=sender
|
||||
client,
|
||||
service,
|
||||
nodeIdentifier,
|
||||
parsed_items,
|
||||
options=publish_options,
|
||||
sender=sender,
|
||||
)
|
||||
except error.StanzaError as e:
|
||||
if ((e.condition == 'conflict' and e.appCondition
|
||||
and e.appCondition.name == 'precondition-not-met'
|
||||
and publish_options is not None)):
|
||||
if (
|
||||
e.condition == "conflict"
|
||||
and e.appCondition
|
||||
and e.appCondition.name == "precondition-not-met"
|
||||
and publish_options is not None
|
||||
):
|
||||
# this usually happens when publish-options can't be set
|
||||
policy = extra.get(self.EXTRA_ON_PRECOND_NOT_MET, 'raise')
|
||||
if policy == 'raise':
|
||||
policy = extra.get(self.EXTRA_ON_PRECOND_NOT_MET, "raise")
|
||||
if policy == "raise":
|
||||
raise e
|
||||
elif policy == 'publish_without_options':
|
||||
log.warning(_(
|
||||
"Can't use publish-options ({options}) on node {node}, "
|
||||
"re-publishing without them: {reason}").format(
|
||||
options=', '.join(f'{k} = {v}'
|
||||
for k,v in publish_options.items()),
|
||||
elif policy == "publish_without_options":
|
||||
log.warning(
|
||||
_(
|
||||
"Can't use publish-options ({options}) on node {node}, "
|
||||
"re-publishing without them: {reason}"
|
||||
).format(
|
||||
options=", ".join(
|
||||
f"{k} = {v}" for k, v in publish_options.items()
|
||||
),
|
||||
node=nodeIdentifier,
|
||||
reason=e,
|
||||
)
|
||||
)
|
||||
iq_result = await self.publish(
|
||||
client, service, nodeIdentifier, parsed_items)
|
||||
client, service, nodeIdentifier, parsed_items
|
||||
)
|
||||
else:
|
||||
raise exceptions.InternalError(
|
||||
f"Invalid policy in extra's {self.EXTRA_ON_PRECOND_NOT_MET!r}: "
|
||||
|
|
@ -647,8 +663,8 @@ class XEP_0060(object):
|
|||
raise e
|
||||
try:
|
||||
return [
|
||||
item['id']
|
||||
for item in iq_result.pubsub.publish.elements(pubsub.NS_PUBSUB, 'item')
|
||||
item["id"]
|
||||
for item in iq_result.pubsub.publish.elements(pubsub.NS_PUBSUB, "item")
|
||||
]
|
||||
except AttributeError:
|
||||
return []
|
||||
|
|
@ -661,7 +677,7 @@ class XEP_0060(object):
|
|||
items: Optional[List[domish.Element]] = None,
|
||||
options: Optional[dict] = None,
|
||||
sender: Optional[jid.JID] = None,
|
||||
extra: Optional[Dict[str, Any]] = None
|
||||
extra: Optional[Dict[str, Any]] = None,
|
||||
) -> domish.Element:
|
||||
"""Publish pubsub items
|
||||
|
||||
|
|
@ -679,13 +695,18 @@ class XEP_0060(object):
|
|||
if extra is None:
|
||||
extra = {}
|
||||
if not await self.host.trigger.async_point(
|
||||
"XEP-0060_publish", client, service, nodeIdentifier, items, options, sender,
|
||||
extra
|
||||
"XEP-0060_publish",
|
||||
client,
|
||||
service,
|
||||
nodeIdentifier,
|
||||
items,
|
||||
options,
|
||||
sender,
|
||||
extra,
|
||||
):
|
||||
return extra["iq_result_elt"]
|
||||
iq_result_elt = await client.pubsub_client.publish(
|
||||
service, nodeIdentifier, items, sender,
|
||||
options=options
|
||||
service, nodeIdentifier, items, sender, options=options
|
||||
)
|
||||
return iq_result_elt
|
||||
|
||||
|
|
@ -693,25 +714,35 @@ class XEP_0060(object):
|
|||
try:
|
||||
item_elt = reduce(
|
||||
lambda elt, ns_name: next(elt.elements(*ns_name)),
|
||||
(message_elt,
|
||||
(mam.NS_MAM, "result"),
|
||||
(C.NS_FORWARD, "forwarded"),
|
||||
(C.NS_CLIENT, "message"),
|
||||
("http://jabber.org/protocol/pubsub#event", "event"),
|
||||
("http://jabber.org/protocol/pubsub#event", "items"),
|
||||
("http://jabber.org/protocol/pubsub#event", "item"),
|
||||
))
|
||||
(
|
||||
message_elt,
|
||||
(mam.NS_MAM, "result"),
|
||||
(C.NS_FORWARD, "forwarded"),
|
||||
(C.NS_CLIENT, "message"),
|
||||
("http://jabber.org/protocol/pubsub#event", "event"),
|
||||
("http://jabber.org/protocol/pubsub#event", "items"),
|
||||
("http://jabber.org/protocol/pubsub#event", "item"),
|
||||
),
|
||||
)
|
||||
except StopIteration:
|
||||
raise exceptions.DataError("Can't find Item in MAM message element")
|
||||
return item_elt
|
||||
|
||||
def serialise_items(self, items_data):
|
||||
items, metadata = items_data
|
||||
metadata['items'] = items
|
||||
metadata["items"] = items
|
||||
return data_format.serialise(metadata)
|
||||
|
||||
def _get_items(self, service="", node="", max_items=10, item_ids=None, sub_id=None,
|
||||
extra="", profile_key=C.PROF_KEY_NONE):
|
||||
def _get_items(
|
||||
self,
|
||||
service="",
|
||||
node="",
|
||||
max_items=10,
|
||||
item_ids=None,
|
||||
sub_id=None,
|
||||
extra="",
|
||||
profile_key=C.PROF_KEY_NONE,
|
||||
):
|
||||
"""Get items from pubsub node
|
||||
|
||||
@param max_items(int): maximum number of item to get, C.NO_LIMIT for no limit
|
||||
|
|
@ -720,16 +751,18 @@ class XEP_0060(object):
|
|||
service = jid.JID(service) if service else None
|
||||
max_items = None if max_items == C.NO_LIMIT else max_items
|
||||
extra = self.parse_extra(data_format.deserialise(extra))
|
||||
d = defer.ensureDeferred(self.get_items(
|
||||
client,
|
||||
service,
|
||||
node,
|
||||
max_items,
|
||||
item_ids,
|
||||
sub_id or None,
|
||||
extra.rsm_request,
|
||||
extra.extra,
|
||||
))
|
||||
d = defer.ensureDeferred(
|
||||
self.get_items(
|
||||
client,
|
||||
service,
|
||||
node,
|
||||
max_items,
|
||||
item_ids,
|
||||
sub_id or None,
|
||||
extra.rsm_request,
|
||||
extra.extra,
|
||||
)
|
||||
)
|
||||
d.addCallback(self.trans_items_data)
|
||||
d.addCallback(self.serialise_items)
|
||||
return d
|
||||
|
|
@ -743,7 +776,7 @@ class XEP_0060(object):
|
|||
item_ids: Optional[List[str]] = None,
|
||||
sub_id: Optional[str] = None,
|
||||
rsm_request: Optional[rsm.RSMRequest] = None,
|
||||
extra: Optional[dict] = None
|
||||
extra: Optional[dict] = None,
|
||||
) -> Tuple[List[domish.Element], dict]:
|
||||
"""Retrieve pubsub items from a node.
|
||||
|
||||
|
|
@ -770,25 +803,34 @@ class XEP_0060(object):
|
|||
if extra is None:
|
||||
extra = {}
|
||||
cont, ret = await self.host.trigger.async_return_point(
|
||||
"XEP-0060_getItems", client, service, node, max_items, item_ids, sub_id,
|
||||
rsm_request, extra
|
||||
"XEP-0060_getItems",
|
||||
client,
|
||||
service,
|
||||
node,
|
||||
max_items,
|
||||
item_ids,
|
||||
sub_id,
|
||||
rsm_request,
|
||||
extra,
|
||||
)
|
||||
if not cont:
|
||||
return ret
|
||||
try:
|
||||
mam_query = extra["mam"]
|
||||
except KeyError:
|
||||
d = defer.ensureDeferred(client.pubsub_client.items(
|
||||
service = service,
|
||||
nodeIdentifier = node,
|
||||
maxItems = max_items,
|
||||
subscriptionIdentifier = sub_id,
|
||||
sender = None,
|
||||
itemIdentifiers = item_ids,
|
||||
orderBy = extra.get(C.KEY_ORDER_BY),
|
||||
rsm_request = rsm_request,
|
||||
extra = extra
|
||||
))
|
||||
d = defer.ensureDeferred(
|
||||
client.pubsub_client.items(
|
||||
service=service,
|
||||
nodeIdentifier=node,
|
||||
maxItems=max_items,
|
||||
subscriptionIdentifier=sub_id,
|
||||
sender=None,
|
||||
itemIdentifiers=item_ids,
|
||||
orderBy=extra.get(C.KEY_ORDER_BY),
|
||||
rsm_request=rsm_request,
|
||||
extra=extra,
|
||||
)
|
||||
)
|
||||
# we have no MAM data here, so we add None
|
||||
d.addErrback(sat_defer.stanza_2_not_found)
|
||||
d.addTimeout(TIMEOUT, reactor)
|
||||
|
|
@ -844,7 +886,7 @@ class XEP_0060(object):
|
|||
# we can put them directly in metadata
|
||||
metadata.update(mam_response)
|
||||
if rsm_request is not None and rsm_response is not None:
|
||||
metadata['rsm'] = rsm_response.toDict()
|
||||
metadata["rsm"] = rsm_response.toDict()
|
||||
if mam_response is None:
|
||||
index = rsm_response.index
|
||||
count = rsm_response.count
|
||||
|
|
@ -887,15 +929,28 @@ class XEP_0060(object):
|
|||
# d_dict[publisher] = self.get_items(service, node, max_items, None, sub_id, rsm, client.profile)
|
||||
# defer.returnValue(d_dict)
|
||||
|
||||
def getOptions(self, service, nodeIdentifier, subscriber, subscriptionIdentifier=None,
|
||||
profile_key=C.PROF_KEY_NONE):
|
||||
def getOptions(
|
||||
self,
|
||||
service,
|
||||
nodeIdentifier,
|
||||
subscriber,
|
||||
subscriptionIdentifier=None,
|
||||
profile_key=C.PROF_KEY_NONE,
|
||||
):
|
||||
client = self.host.get_client(profile_key)
|
||||
return client.pubsub_client.getOptions(
|
||||
service, nodeIdentifier, subscriber, subscriptionIdentifier
|
||||
)
|
||||
|
||||
def setOptions(self, service, nodeIdentifier, subscriber, options,
|
||||
subscriptionIdentifier=None, profile_key=C.PROF_KEY_NONE):
|
||||
def setOptions(
|
||||
self,
|
||||
service,
|
||||
nodeIdentifier,
|
||||
subscriber,
|
||||
options,
|
||||
subscriptionIdentifier=None,
|
||||
profile_key=C.PROF_KEY_NONE,
|
||||
):
|
||||
client = self.host.get_client(profile_key)
|
||||
return client.pubsub_client.setOptions(
|
||||
service, nodeIdentifier, subscriber, options, subscriptionIdentifier
|
||||
|
|
@ -912,7 +967,7 @@ class XEP_0060(object):
|
|||
client: SatXMPPClient,
|
||||
service: jid.JID,
|
||||
nodeIdentifier: Optional[str] = None,
|
||||
options: Optional[Dict[str, str]] = None
|
||||
options: Optional[Dict[str, str]] = None,
|
||||
) -> str:
|
||||
"""Create a new node
|
||||
|
||||
|
|
@ -1038,9 +1093,7 @@ class XEP_0060(object):
|
|||
d = self.get_node_affiliations(
|
||||
client, jid.JID(service_s) if service_s else None, nodeIdentifier
|
||||
)
|
||||
d.addCallback(
|
||||
lambda affiliations: {j.full(): a for j, a in affiliations.items()}
|
||||
)
|
||||
d.addCallback(lambda affiliations: {j.full(): a for j, a in affiliations.items()})
|
||||
return d
|
||||
|
||||
def get_node_affiliations(self, client, service, nodeIdentifier):
|
||||
|
|
@ -1122,10 +1175,7 @@ class XEP_0060(object):
|
|||
)
|
||||
|
||||
def deleteNode(
|
||||
self,
|
||||
client: SatXMPPClient,
|
||||
service: jid.JID,
|
||||
nodeIdentifier: str
|
||||
self, client: SatXMPPClient, service: jid.JID, nodeIdentifier: str
|
||||
) -> defer.Deferred:
|
||||
return client.pubsub_client.deleteNode(service, nodeIdentifier)
|
||||
|
||||
|
|
@ -1188,9 +1238,9 @@ class XEP_0060(object):
|
|||
):
|
||||
client = self.host.get_client(profile_key)
|
||||
service = jid.JID(service) if service else None
|
||||
return defer.ensureDeferred(self.rename_item(
|
||||
client, service, node, item_id, new_id
|
||||
))
|
||||
return defer.ensureDeferred(
|
||||
self.rename_item(client, service, node, item_id, new_id)
|
||||
)
|
||||
|
||||
async def rename_item(
|
||||
self,
|
||||
|
|
@ -1198,7 +1248,7 @@ class XEP_0060(object):
|
|||
service: Optional[jid.JID],
|
||||
node: str,
|
||||
item_id: str,
|
||||
new_id: str
|
||||
new_id: str,
|
||||
) -> None:
|
||||
"""Rename an item by recreating it then deleting it
|
||||
|
||||
|
|
@ -1218,10 +1268,7 @@ class XEP_0060(object):
|
|||
service = None if not service else jid.JID(service)
|
||||
d = defer.ensureDeferred(
|
||||
self.subscribe(
|
||||
client,
|
||||
service,
|
||||
nodeIdentifier,
|
||||
options=data_format.deserialise(options)
|
||||
client, service, nodeIdentifier, options=data_format.deserialise(options)
|
||||
)
|
||||
)
|
||||
d.addCallback(lambda subscription: subscription.subscriptionIdentifier or "")
|
||||
|
|
@ -1233,23 +1280,31 @@ class XEP_0060(object):
|
|||
service: Optional[jid.JID],
|
||||
nodeIdentifier: str,
|
||||
sub_jid: Optional[jid.JID] = None,
|
||||
options: Optional[dict] = None
|
||||
options: Optional[dict] = None,
|
||||
) -> pubsub.Subscription:
|
||||
# TODO: reimplement a subscribtion cache, checking that we have not subscription before trying to subscribe
|
||||
if service is None:
|
||||
service = client.jid.userhostJID()
|
||||
cont, trigger_sub = await self.host.trigger.async_return_point(
|
||||
"XEP-0060_subscribe", client, service, nodeIdentifier, sub_jid, options,
|
||||
"XEP-0060_subscribe",
|
||||
client,
|
||||
service,
|
||||
nodeIdentifier,
|
||||
sub_jid,
|
||||
options,
|
||||
)
|
||||
if not cont:
|
||||
return trigger_sub
|
||||
try:
|
||||
subscription = await client.pubsub_client.subscribe(
|
||||
service, nodeIdentifier, sub_jid or client.jid.userhostJID(),
|
||||
options=options, sender=client.jid.userhostJID()
|
||||
service,
|
||||
nodeIdentifier,
|
||||
sub_jid or client.jid.userhostJID(),
|
||||
options=options,
|
||||
sender=client.jid.userhostJID(),
|
||||
)
|
||||
except error.StanzaError as e:
|
||||
if e.condition == 'item-not-found':
|
||||
if e.condition == "item-not-found":
|
||||
raise exceptions.NotFound(e.text or e.condition)
|
||||
else:
|
||||
raise e
|
||||
|
|
@ -1270,18 +1325,23 @@ class XEP_0060(object):
|
|||
sender: Optional[jid.JID] = None,
|
||||
) -> None:
|
||||
if not await self.host.trigger.async_point(
|
||||
"XEP-0060_unsubscribe", client, service, nodeIdentifier, sub_jid,
|
||||
subscriptionIdentifier, sender
|
||||
"XEP-0060_unsubscribe",
|
||||
client,
|
||||
service,
|
||||
nodeIdentifier,
|
||||
sub_jid,
|
||||
subscriptionIdentifier,
|
||||
sender,
|
||||
):
|
||||
return
|
||||
try:
|
||||
await client.pubsub_client.unsubscribe(
|
||||
service,
|
||||
nodeIdentifier,
|
||||
sub_jid or client.jid.userhostJID(),
|
||||
subscriptionIdentifier,
|
||||
sender,
|
||||
)
|
||||
service,
|
||||
nodeIdentifier,
|
||||
sub_jid or client.jid.userhostJID(),
|
||||
subscriptionIdentifier,
|
||||
sender,
|
||||
)
|
||||
except error.StanzaError as e:
|
||||
try:
|
||||
next(e.getElement().elements(pubsub.NS_PUBSUB_ERRORS, "not-subscribed"))
|
||||
|
|
@ -1295,10 +1355,7 @@ class XEP_0060(object):
|
|||
|
||||
@utils.ensure_deferred
|
||||
async def _subscriptions(
|
||||
self,
|
||||
service="",
|
||||
nodeIdentifier="",
|
||||
profile_key=C.PROF_KEY_NONE
|
||||
self, service="", nodeIdentifier="", profile_key=C.PROF_KEY_NONE
|
||||
) -> str:
|
||||
client = self.host.get_client(profile_key)
|
||||
service = None if not service else jid.JID(service)
|
||||
|
|
@ -1309,7 +1366,7 @@ class XEP_0060(object):
|
|||
self,
|
||||
client: SatXMPPEntity,
|
||||
service: Optional[jid.JID] = None,
|
||||
node: Optional[str] = None
|
||||
node: Optional[str] = None,
|
||||
) -> List[Dict[str, Union[str, bool]]]:
|
||||
"""Retrieve subscriptions from a service
|
||||
|
||||
|
|
@ -1399,10 +1456,9 @@ class XEP_0060(object):
|
|||
log.warning(f"Error while parsing item: {failure_.value}")
|
||||
|
||||
d = defer.gatherResults([item_cb(item).addErrback(eb) for item in items])
|
||||
d.addCallback(lambda parsed_items: (
|
||||
[i for i in parsed_items if i is not None],
|
||||
metadata
|
||||
))
|
||||
d.addCallback(
|
||||
lambda parsed_items: ([i for i in parsed_items if i is not None], metadata)
|
||||
)
|
||||
return d
|
||||
|
||||
def ser_d_list(self, results, failure_result=None):
|
||||
|
|
@ -1418,9 +1474,11 @@ class XEP_0060(object):
|
|||
if failure_result is None:
|
||||
failure_result = ()
|
||||
return [
|
||||
("", result)
|
||||
if success
|
||||
else (str(result.result) or UNSPECIFIED, failure_result)
|
||||
(
|
||||
("", result)
|
||||
if success
|
||||
else (str(result.result) or UNSPECIFIED, failure_result)
|
||||
)
|
||||
for success, result in results
|
||||
]
|
||||
|
||||
|
|
@ -1428,10 +1486,7 @@ class XEP_0060(object):
|
|||
|
||||
@utils.ensure_deferred
|
||||
async def _get_node_subscriptions(
|
||||
self,
|
||||
service: str,
|
||||
node: str,
|
||||
profile_key: str
|
||||
self, service: str, node: str, profile_key: str
|
||||
) -> Dict[str, str]:
|
||||
client = self.host.get_client(profile_key)
|
||||
subs = await self.get_node_subscriptions(
|
||||
|
|
@ -1440,10 +1495,7 @@ class XEP_0060(object):
|
|||
return {j.full(): a for j, a in subs.items()}
|
||||
|
||||
async def get_node_subscriptions(
|
||||
self,
|
||||
client: SatXMPPEntity,
|
||||
service: Optional[jid.JID],
|
||||
nodeIdentifier: str
|
||||
self, client: SatXMPPEntity, service: Optional[jid.JID], nodeIdentifier: str
|
||||
) -> Dict[jid.JID, str]:
|
||||
"""Retrieve subscriptions to a node
|
||||
|
||||
|
|
@ -1471,15 +1523,11 @@ class XEP_0060(object):
|
|||
try:
|
||||
return {
|
||||
jid.JID(s["jid"]): s["subscription"]
|
||||
for s in subscriptions_elt.elements(
|
||||
(pubsub.NS_PUBSUB, "subscription")
|
||||
)
|
||||
for s in subscriptions_elt.elements((pubsub.NS_PUBSUB, "subscription"))
|
||||
}
|
||||
except KeyError:
|
||||
raise ValueError(
|
||||
_("Invalid result: bad <subscription> element: {}").format(
|
||||
iq_elt.toXml
|
||||
)
|
||||
_("Invalid result: bad <subscription> element: {}").format(iq_elt.toXml)
|
||||
)
|
||||
|
||||
def _set_node_subscriptions(
|
||||
|
|
@ -1487,8 +1535,7 @@ class XEP_0060(object):
|
|||
):
|
||||
client = self.host.get_client(profile_key)
|
||||
subscriptions = {
|
||||
jid.JID(jid_): subscription
|
||||
for jid_, subscription in subscriptions.items()
|
||||
jid.JID(jid_): subscription for jid_, subscription in subscriptions.items()
|
||||
}
|
||||
d = self.set_node_subscriptions(
|
||||
client,
|
||||
|
|
@ -1572,9 +1619,7 @@ class XEP_0060(object):
|
|||
deferreds = {}
|
||||
for service, node in node_data:
|
||||
deferreds[(service, node)] = defer.ensureDeferred(
|
||||
client.pubsub_client.subscribe(
|
||||
service, node, subscriber, options=options
|
||||
)
|
||||
client.pubsub_client.subscribe(service, node, subscriber, options=options)
|
||||
)
|
||||
return self.rt_sessions.new_session(deferreds, client.profile)
|
||||
# found_nodes = yield self.listNodes(service, profile=client.profile)
|
||||
|
|
@ -1639,8 +1684,14 @@ class XEP_0060(object):
|
|||
profile_key,
|
||||
)
|
||||
|
||||
def get_from_many(self, node_data, max_item=None, rsm_request=None, extra=None,
|
||||
profile_key=C.PROF_KEY_NONE):
|
||||
def get_from_many(
|
||||
self,
|
||||
node_data,
|
||||
max_item=None,
|
||||
rsm_request=None,
|
||||
extra=None,
|
||||
profile_key=C.PROF_KEY_NONE,
|
||||
):
|
||||
"""Get items from many nodes at once
|
||||
|
||||
@param node_data (iterable[tuple]): iterable of tuple (service, node) where:
|
||||
|
|
@ -1654,9 +1705,11 @@ class XEP_0060(object):
|
|||
client = self.host.get_client(profile_key)
|
||||
deferreds = {}
|
||||
for service, node in node_data:
|
||||
deferreds[(service, node)] = defer.ensureDeferred(self.get_items(
|
||||
client, service, node, max_item, rsm_request=rsm_request, extra=extra
|
||||
))
|
||||
deferreds[(service, node)] = defer.ensureDeferred(
|
||||
self.get_items(
|
||||
client, service, node, max_item, rsm_request=rsm_request, extra=extra
|
||||
)
|
||||
)
|
||||
return self.rt_sessions.new_session(deferreds, client.profile)
|
||||
|
||||
|
||||
|
|
@ -1686,14 +1739,25 @@ class SatPubSubClient(rsm.PubSubClient):
|
|||
if extra is None:
|
||||
extra = {}
|
||||
items, rsm_response = await super().items(
|
||||
service, nodeIdentifier, maxItems, subscriptionIdentifier, sender,
|
||||
itemIdentifiers, orderBy, rsm_request
|
||||
service,
|
||||
nodeIdentifier,
|
||||
maxItems,
|
||||
subscriptionIdentifier,
|
||||
sender,
|
||||
itemIdentifiers,
|
||||
orderBy,
|
||||
rsm_request,
|
||||
)
|
||||
# items must be returned, thus this async point can't stop the workflow (but it
|
||||
# can modify returned items)
|
||||
await self.host.trigger.async_point(
|
||||
"XEP-0060_items", self.parent, service, nodeIdentifier, items, rsm_response,
|
||||
extra
|
||||
"XEP-0060_items",
|
||||
self.parent,
|
||||
service,
|
||||
nodeIdentifier,
|
||||
items,
|
||||
rsm_response,
|
||||
extra,
|
||||
)
|
||||
return items, rsm_response
|
||||
|
||||
|
|
@ -1725,9 +1789,7 @@ class SatPubSubClient(rsm.PubSubClient):
|
|||
try:
|
||||
await utils.as_deferred(callback, client, event)
|
||||
except Exception as e:
|
||||
log.error(
|
||||
f"Error while running items event callback {callback}: {e}"
|
||||
)
|
||||
log.error(f"Error while running items event callback {callback}: {e}")
|
||||
|
||||
def itemsReceived(self, event):
|
||||
log.debug("Pubsub items received")
|
||||
|
|
@ -1747,9 +1809,11 @@ class SatPubSubClient(rsm.PubSubClient):
|
|||
log.debug(("Publish node deleted"))
|
||||
for callback in self._get_node_callbacks(event.nodeIdentifier, C.PS_DELETE):
|
||||
d = utils.as_deferred(callback, self.parent, event)
|
||||
d.addErrback(lambda f: log.error(
|
||||
f"Error while running delete event callback {callback}: {f}"
|
||||
))
|
||||
d.addErrback(
|
||||
lambda f: log.error(
|
||||
f"Error while running delete event callback {callback}: {f}"
|
||||
)
|
||||
)
|
||||
client = self.parent
|
||||
if (event.sender, event.nodeIdentifier) in client.pubsub_watching:
|
||||
self.host.bridge.ps_event_raw(
|
||||
|
|
@ -1760,9 +1824,11 @@ class SatPubSubClient(rsm.PubSubClient):
|
|||
log.debug(("Publish node purged"))
|
||||
for callback in self._get_node_callbacks(event.nodeIdentifier, C.PS_PURGE):
|
||||
d = utils.as_deferred(callback, self.parent, event)
|
||||
d.addErrback(lambda f: log.error(
|
||||
f"Error while running purge event callback {callback}: {f}"
|
||||
))
|
||||
d.addErrback(
|
||||
lambda f: log.error(
|
||||
f"Error while running purge event callback {callback}: {f}"
|
||||
)
|
||||
)
|
||||
client = self.parent
|
||||
if (event.sender, event.nodeIdentifier) in client.pubsub_watching:
|
||||
self.host.bridge.ps_event_raw(
|
||||
|
|
@ -1808,7 +1874,7 @@ class SatPubSubClient(rsm.PubSubClient):
|
|||
@param NodeIdentifier(unicode): PubSub node to use
|
||||
"""
|
||||
# TODO: propose this upstream and remove it once merged
|
||||
request = pubsub.PubSubRequest('purge')
|
||||
request = pubsub.PubSubRequest("purge")
|
||||
request.recipient = service
|
||||
request.nodeIdentifier = nodeIdentifier
|
||||
return request.send(self.xmlstream)
|
||||
|
|
|
|||
Loading…
Reference in a new issue