libervia-pubsub: sat_pubsub/backend.py comparison

comparison sat_pubsub/backend.py @ 318:d13526c0eb32

RSM improvments/refactoring: - a warning message is displayed if maxItems == 0 in getItems, and an empty list is returned in this case - use the new container.ItemData instead of doing tuple (un)packing - the list of ItemData => list of domish.Element conversion is done at the end of the workflow - rsm request is checked in self._items_rsm directly - better handling of Response.index in _items_rsm - itemsIdentifiers can't be used with RSM (the later will be ignored if this happen) - don't do approximative unpacking anymore in _items_rsm - countItems and getIndex have been refactored and renamed getItemsCount and getItemsIndex, don't use query duplications anymore - cleaned query handling in getItems - /!\ mam module is temporarly broken

author	Goffi <goffi@goffi.org>
date	Sun, 03 Jan 2016 18:33:22 +0100
parents	34adc4a8aa64
children	29c2553ef863

comparison

equal deleted inserted replaced

-:34adc4a8aa64
+:d13526c0eb32
 return {}
 def _doGetItems(self, result, requestor, maxItems, itemIdentifiers,
 ext_data):
 node, affiliation = result
+if maxItems == 0:
+log.msg("WARNING: maxItems=0 on items retrieval")
+return []
 def append_item_config(items_data):
-ret = []
+"""Add item config data form to items with roster access model"""
 for item_data in items_data:
-item, access_model, access_list = item_data.item, item_data.access_model, item_data.config
+if item_data.access_model == const.VAL_AMODEL_OPEN:
-if access_model == const.VAL_AMODEL_OPEN:
 pass
-elif access_model == const.VAL_AMODEL_ROSTER:
+elif item_data.access_model == const.VAL_AMODEL_ROSTER:
 form = data_form.Form('submit', formNamespace=const.NS_ITEM_CONFIG)
 access = data_form.Field(None, const.OPT_ACCESS_MODEL, value=const.VAL_AMODEL_ROSTER)
-allowed = data_form.Field(None, const.OPT_ROSTER_GROUPS_ALLOWED, values=access_list[const.OPT_ROSTER_GROUPS_ALLOWED])
+allowed = data_form.Field(None, const.OPT_ROSTER_GROUPS_ALLOWED, values=item_data.config[const.OPT_ROSTER_GROUPS_ALLOWED])
 form.addField(access)
 form.addField(allowed)
-item.addChild(form.toElement())
+item_data.item.addChild(form.toElement())
 elif access_model == const.VAL_AMODEL_JID:
 #FIXME: manage jid
 raise NotImplementedError
 else:
 raise error.BadAccessTypeError(access_model)
+return items_data
-ret.append(item)
-return ret
 def access_checked(access_data):
 authorized, roster = access_data
 if not authorized:
 raise error.NotAuthorized()
 roster_item = roster.get(requestor.userhostJID())
 authorized_groups = tuple(roster_item.groups) if roster_item else tuple()
-unrestricted = affiliation == 'owner'
+owner = affiliation == 'owner'
 if itemIdentifiers:
-d = node.getItemsById(authorized_groups, unrestricted, itemIdentifiers)
+d = node.getItemsById(authorized_groups, owner, itemIdentifiers)
 else:
-d = node.getItems(authorized_groups, unrestricted, maxItems, ext_data)
+d = node.getItems(authorized_groups, owner, maxItems, ext_data)
-if unrestricted:
+if owner:
 d.addCallback(append_item_config)
-try:
+d.addCallback(self._items_rsm, node, authorized_groups,
-rsm_data = ext_data['rsm']
+owner, itemIdentifiers,
-except KeyError:
+ext_data)
-pass
-else:
-if rsm_data is not None:
-d.addCallback(self._items_rsm, node, authorized_groups,
-unrestricted, maxItems, itemIdentifiers,
-rsm_data)
 return d
 if not iidavoll.ILeafNode.providedBy(node):
 return []
 elif access_model == const.VAL_AMODEL_ROSTER:
 d.addCallback(self._getNodeGroups, node.nodeIdentifier, ext_data.get('pep', False))
 d.addCallback(self.checkGroup, requestor)
 d.addCallback(access_checked)
+d.addCallback(lambda items_data: [item_data.item for item_data in items_data])
 return d
 def _setCount(self, value, response):
 response.count = value
-def _setIndex(self, value, response):
+def _setIndex(self, value, response, adjust):
-response.index = value
+"""Set index in RSM response
-def _items_rsm(self, elts, node, authorized_groups, unrestricted, maxItems,
+@param value(int): value of the reference index (i.e. before or after item)
-itemIdentifiers, request):
+@param response(RSMResponse): response instance to fill
-# FIXME: move this to a separate module ?
+@param adjust(int): adjustement term (i.e. difference between reference index and first item of the result)
+"""
+response.index = value + adjust
+def _items_rsm(self, items_data, node, authorized_groups, owner,
+itemIdentifiers, ext_data):
+# FIXME: move this to a separate module
+# TODO: Index can be optimized by keeping a cache of the last RSM request
+#       An other optimisation would be to look for index first and use it as offset
+try:
+rsm_request = ext_data['rsm']
+except KeyError:
+# No RSM in this request, nothing to do
+return items_data
+if itemIdentifiers:
+log.msg("WARNING, itemIdentifiers used with RSM, ignoring the RSM part")
+return items_data
 response = rsm.RSMResponse()
-d_count = node.countItems(authorized_groups, unrestricted)
+d_count = node.getItemsCount(authorized_groups, owner, ext_data)
 d_count.addCallback(self._setCount, response)
 d_list = [d_count]
-if request.index is not None:
+if items_data:
-response.index = request.index
+response.first = items_data[0].item['id']
-elif request.before is not None:
+response.last = items_data[-1].item['id']
-if request.before != '':
-# XXX: getIndex starts with index 1, RSM starts with 0
+# index handling
-d_index = node.getIndex(authorized_groups, unrestricted, request.before)
+if rsm_request.index is not None:
-d_index.addCallback(lambda index: max(index - request.max - 1, 0))
+response.index = rsm_request.index
-d_index.addCallback(self._setIndex, response)
+elif rsm_request.before:
+# The last page case (before == '') is managed in render method
+d_index = node.getItemsIndex(rsm_request.before, authorized_groups, owner, ext_data)
+d_index.addCallback(self._setIndex, response, -len(items_data))
 d_list.append(d_index)
-elif request.after is not None:
+elif rsm_request.after is not None:
-d_index = node.getIndex(authorized_groups, unrestricted, request.after)
+d_index = node.getItemsIndex(rsm_request.after, authorized_groups, owner, ext_data)
-d_index.addCallback(self._setIndex, response)
+d_index.addCallback(self._setIndex, response, 1)
 d_list.append(d_index)
-elif itemIdentifiers:
+else:
-d_index = node.getIndex(authorized_groups, unrestricted, itemIdentifiers[0])
+# the first page was requested
-d_index.addCallback(lambda index: index - 1)
+response.index = 0
-d_index.addCallback(self._setIndex, response)
-d_list.append(d_index)
 def render(result):
-try:
+if rsm_request.before == '':
-items = [elt for elt in elts if elt.name == 'item']
+# the last page was requested
-except AttributeError:
+response.index = response.count - len(items_data)
-# XXX: see sat_pubsub.pgsql_storage.LeafNode.getItemsById return value
+items_data.append(container.ItemData(response.toElement()))
-items = [elt[0] for elt in elts if elt[0].name == 'item']
+return items_data
-if len(items) > 0:
-if response.index is None:
-if request.before == '': # last page
-response.index = response.count - request.max
-else:  # first page
-response.index = 0
-response.first = items[0]['id']
-response.last = items[len(items) - 1]['id']
-if request.before is not None:
-response.first, response.last = response.last, response.first
-else:
-response.index = None
-elts.append(response.toElement())
-return elts
 return defer.DeferredList(d_list).addCallback(render)
 def retractItem(self, nodeIdentifier, itemIdentifiers, requestor, notify, pep, recipient):
 d = self.storage.getNode(nodeIdentifier, pep, recipient)

Mercurial > libervia-pubsub

comparison sat_pubsub/backend.py @ 318:d13526c0eb32