libervia-pubsub: sat_pubsub/backend.py comparison

comparison sat_pubsub/backend.py @ 419:794593086517

backend: publish-options implementation: - removed some old code - new ConstraintFailed exception - publishing options implementation, following XEP-0060 §7.1.5 - first use of async/await syntax, used to simplify "publish" method

author	Goffi <goffi@goffi.org>
date	Sat, 28 Dec 2019 19:56:47 +0100
parents	4179ed660a85
children	c21f31355ab9

comparison

equal deleted inserted replaced

-:89736353f6be
+:794593086517
 #!/usr/bin/env python3
-#-*- coding: utf-8 -*-
 #
 # Copyright (c) 2012-2019 Jérôme Poisson
 # Copyright (c) 2013-2016 Adrien Cossa
 # Copyright (c) 2003-2011 Ralph Meijer
 from twisted.application import service
 from twisted.python import components, log
 from twisted.internet import defer, reactor
 from twisted.words.protocols.jabber.error import StanzaError
-# from twisted.words.protocols.jabber.jid import JID, InvalidFormat
 from twisted.words.xish import domish, utility
 from wokkel import disco
 from wokkel import data_form
 from wokkel import rsm
 """Return True if an entity is an administrator"""
 return entity_jid.userhostJID() in self.admins
 def supportsPublishOptions(self):
 return True
 def supportsPublisherAffiliation(self):
 return True
 def supportsGroupBlog(self):
 return True
 def checkSubscription(subscribed):
 if not subscribed:
 raise error.Forbidden()
 return (affiliation, node)
-d.addCallback(lambda ignore: node.isSubscribed(requestor))
+d.addCallback(lambda __: node.isSubscribed(requestor))
 d.addCallback(checkSubscription)
 elif publish_model != const.VAL_PMODEL_OPEN:
-raise ValueError('Unexpected value') # publish_model must be publishers (default), subscribers or open.
+# publish_model must be publishers (default), subscribers or open.
+raise ValueError('Unexpected value')
 return d
 d = node.getAffiliation(requestor)
 d.addCallback(check)
 d = node.getItemsPublishers(itemIdentifiers)
 d.addCallback(doCheck)
 return d
-def publish(self, nodeIdentifier, items, requestor, pep, recipient):
+async def publish(self, nodeIdentifier, items, requestor, options, pep, recipient):
-d = self.storage.getNode(nodeIdentifier, pep, recipient)
+node = await self.storage.getNode(nodeIdentifier, pep, recipient)
-d.addCallback(self._checkAuth, requestor)
+affiliation, node = await self._checkAuth(node, requestor)
-#FIXME: owner and publisher are not necessarly the same. So far we use only owner to get roster.
-#FIXME: in addition, there can be several owners: that is not managed yet
-d.addCallback(self._doPublish, items, requestor, pep, recipient)
-return d
-@defer.inlineCallbacks
-def _doPublish(self, result, items, requestor, pep, recipient):
-affiliation, node = result
 if node.nodeType == 'collection':
 raise error.NoPublishing()
 configuration = node.getConfiguration()
 persistItems = configuration[const.OPT_PERSIST_ITEMS]
 deliverPayloads = configuration[const.OPT_DELIVER_PAYLOADS]
+# we check that publish-options are satisfied
+for field, value in options.items():
+try:
+current_value = configuration[field]
+except KeyError:
+raise error.ConstraintFailed(
+f"publish-options {field!r} doesn't exist in node configuration"
+)
+if current_value != value:
+raise error.ConstraintFailed(
+f"configuration field {field!r} has a value of {current_value!r} "
+f"which doesn't fit publish-options expected {value!r}"
+)
 if items and not persistItems and not deliverPayloads:
 raise error.ItemForbidden()
 elif not items and (persistItems or deliverPayloads):
 raise error.ItemRequired()
 item['publisher'] = requestor.full()
 if persistItems or deliverPayloads:
 item.uri = None
 item.defaultUri = None
 if not item.getAttribute("id"):
-item["id"] = yield node.getNextId()
+item["id"] = await node.getNextId()
 new_item = True
 if ret_payload is None:
 ret_pubsub_elt = domish.Element((pubsub.NS_PUBSUB, 'pubsub'))
 ret_publish_elt = ret_pubsub_elt.addElement('publish')
 ret_publish_elt['node'] = node.nodeIdentifier
 itemIdentifiers = [item['id'] for item in items
 if item.getAttribute('id')]
 if affiliation == 'owner' or self.isAdmin(requestor):
 if configuration[const.OPT_CONSISTENT_PUBLISHER]:
-pub_map = yield node.getItemsPublishers(itemIdentifiers)
+pub_map = await node.getItemsPublishers(itemIdentifiers)
 if pub_map:
 # if we have existing items, we replace publishers with
 # original one to stay consistent
 publishers = set(pub_map.values())
 if len(publishers) != 1:
 for item in items:
 item['publisher'] = requestor.full()
 else:
 # we don't want a publisher to overwrite the item
 # of an other publisher
-yield self._checkOverwrite(node, itemIdentifiers, requestor)
+await self._checkOverwrite(node, itemIdentifiers, requestor)
 # TODO: check conflict and recalculate max id if serial_ids is set
-yield node.storeItems(items_data, requestor)
+await node.storeItems(items_data, requestor)
-yield self._doNotify(node, items_data, deliverPayloads, pep, recipient)
+self._doNotify(node, items_data, deliverPayloads, pep, recipient)
-defer.returnValue(ret_payload)
+return ret_payload
 def _doNotify(self, node, items_data, deliverPayloads, pep, recipient):
 if items_data and not deliverPayloads:
 for item_data in items_data:
 item_data.item.children = []
 return self.storage.getSubscriptions(requestor, nodeIdentifier, pep, recipient)
 def supportsAutoCreate(self):
 return True
-def supportsCreatorCheck(self):
-return True
 def supportsInstantNodes(self):
 return True
-def createNode(self, nodeIdentifier, requestor, options = None, pep=False, recipient=None):
+def createNode(self, nodeIdentifier, requestor, options=None, pep=False, recipient=None):
 if not nodeIdentifier:
 nodeIdentifier = 'generic/%s' % uuid.uuid4()
 if not options:
 options = {}
-# if self.supportsCreatorCheck():
-#     groupblog = nodeIdentifier.startswith(const.NS_GROUPBLOG_PREFIX)
-#     try:
-#         nodeIdentifierJID = JID(nodeIdentifier[len(const.NS_GROUPBLOG_PREFIX):] if groupblog else nodeIdentifier)
-#     except InvalidFormat:
-#         is_user_jid = False
-#     else:
-#         is_user_jid = bool(nodeIdentifierJID.user)
-#     if is_user_jid and nodeIdentifierJID.userhostJID() != requestor.userhostJID():
-#         #we have an user jid node, but not created by the owner of this jid
-#         print "Wrong creator"
-#         raise error.Forbidden()
 nodeType = 'leaf'
 config = self.storage.getDefaultConfiguration(nodeType)
 config['pubsub#node_type'] = nodeType
 config.update(options)
 'unsupported',
 'collections'),
 error.NoPublishing: ('feature-not-implemented',
 'unsupported',
 'publish'),
+error.ConstraintFailed: ('conflict', 'precondition-not-met', None),
 }
 def __init__(self, backend):
 pubsub.PubSubResource.__init__(self)
 self.backend.registerPublishNotifier(self._notifyPublish)
 self.backend.registerRetractNotifier(self._notifyRetract)
 self.backend.registerPreDelete(self._preDelete)
-# FIXME: to be removed, it's not useful anymore as PEP is now used
-# if self.backend.supportsCreatorCheck():
-#     self.features.append("creator-jid-check")  #SàT custom feature: Check that a node (which correspond to
-#                    a jid in this server) is created by the right jid
 if self.backend.supportsAutoCreate():
 self.features.append("auto-create")
 if self.backend.supportsPublishOptions():
 self.features.append("publish-options")
 self.features.append("publisher-affiliation")
 if self.backend.supportsGroupBlog():
 self.features.append("groupblog")
+# XXX: this feature is not really described in XEP-0060, we just can see it in
-# if self.backend.supportsPublishModel():       #XXX: this feature is not really described in XEP-0060, we just can see it in examples
+#      examples but it's necessary for microblogging comments (see XEP-0277)
-#     self.features.append("publish_model")     #     but it's necessary for microblogging comments (see XEP-0277)
+if self.backend.supportsPublishModel():
+self.features.append("publish_model")
 def getFullItem(self, item_data):
 """ Attach item configuration to this item
 Used to give item configuration back to node's owner (and *only* to owner)
 def _publish_errb(self, failure, request):
 if failure.type == error.NodeNotFound and self.backend.supportsAutoCreate():
 print("Auto-creating node %s" % (request.nodeIdentifier,))
 d = self.backend.createNode(request.nodeIdentifier,
 request.sender,
+request.options,
 pep=self._isPep(request),
 recipient=request.recipient)
-d.addCallback(lambda ignore,
+d.addCallback(
-request: self.backend.publish(request.nodeIdentifier,
+lambda __, request: defer.ensureDeferred(self.backend.publish(
-request.items,
+request.nodeIdentifier,
-request.sender,
+request.items,
-self._isPep(request),
+request.sender,
-request.recipient,
+request.options,
-),
+self._isPep(request),
-request)
+request.recipient,
+)),
+request,
+)
 return d
 return failure
 def _isPep(self, request):
 return request.delegated
 except AttributeError:
 return False
 def publish(self, request):
-d = self.backend.publish(request.nodeIdentifier,
+d = defer.ensureDeferred(self.backend.publish(
-request.items,
+request.nodeIdentifier,
-request.sender,
+request.items,
-self._isPep(request),
+request.sender,
-request.recipient)
+request.options,
+self._isPep(request),
+request.recipient
+))
 d.addErrback(self._publish_errb, request)
 return d.addErrback(self._mapErrors)
 def subscribe(self, request):
 d = self.backend.subscribe(request.nodeIdentifier,

Mercurial > libervia-pubsub

comparison sat_pubsub/backend.py @ 419:794593086517