erebion/libervia-backend
Watch
1
0
Fork
You've already forked libervia-backend
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

plugin XEP-0059: first draft, pubsub and jabber search do not exploit it yet

Browse source
This commit is contained in:
souliane 2014-09-22 22:25:44 +02:00
commit 20c94f1fbc
3 changed files with 219 additions and 2 deletions
Download patch file Download diff file Expand all files Collapse all files

3
src/plugins/plugin_xep_0055.py
View file

@ -35,6 +35,8 @@ PLUGIN_INFO = {
"import_name": "XEP-0055",
"type": "XEP",
"protocols": ["XEP-0055"],
"dependencies": [],
"recommendations": ["XEP-0059"],
"main": "XEP_0055",
"handler": "no",
"description": _("""Implementation of Jabber Search""")
@ -156,6 +158,7 @@ class XEP_0055(object):
x_form = data_form.Form('submit', formNamespace = NS_SEARCH)
x_form.makeFields(search_dict)
query_elt.addChild(x_form.toElement())
# TODO: XEP-0059 could be used here (with the needed new method attributes)
d = search_request.send(to_jid.full())
d.addCallbacks(self._searchOk, self._searchErr, callbackArgs=[client.profile], errbackArgs=[client.profile])
return d

149
src/plugins/plugin_xep_0059.py Normal file
View file

@ -0,0 +1,149 @@
#!/usr/bin/python
# -*- coding: utf-8 -*-
# SAT plugin for Result Set Management (XEP-0059)
# Copyright (C) 2009, 2010, 2011, 2012, 2013, 2014 Jérôme Poisson (goffi@goffi.org)
# Copyright (C) 2013, 2014 Adrien Cossa (souliane@mailoo.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 sat.core.i18n import _
from sat.core.log import getLogger
log = getLogger(__name__)
from twisted.words.xish import domish
from wokkel import disco, iwokkel
try:
from twisted.words.protocols.xmlstream import XMPPHandler
except ImportError:
from wokkel.subprotocols import XMPPHandler
from zope.interface import implements
NS_RSM = 'http://jabber.org/protocol/rsm'
PLUGIN_INFO = {
"name": "Result Set Management",
"import_name": "XEP-0059",
"type": "XEP",
"protocols": ["XEP-0059"],
"main": "XEP_0059",
"handler": "no",
"description": _("""Implementation of Result Set Management""")
}
class XEP_0059(object):
def __init__(self, host):
log.info(_("Result Set Management plugin initialization"))
self.host = host
def requestPage(self, stanza, limit=10, index=None, after=None, before=None):
"""Embed a RSM page request in the given stanza.
@param stanza (domish.Element): any stanza to which RSM applies
@param limit (int): the maximum number of items in the page
@param index (int): the starting index of the requested page
@param after (str, int): the element immediately preceding the page
@param before (str, int): the element immediately following the page
"""
main_elt = None
try:
main_elt = domish.generateElementsNamed(stanza.elements(), name="query").next()
except StopIteration:
try:
main_elt = domish.generateElementsNamed(stanza.elements(), name="pubsub").next()
except StopIteration:
log.warning("Injection of a RSM element only applies to query or pubsub stanzas")
return
limit = str(int(limit))
# in case the service doesn't support RSM, do this at least
main_elt.items.attributes['max_items'] = limit
set_elt = main_elt.addElement('set', NS_RSM)
set_elt.addElement('max').addContent(limit)
if index:
assert(after is None and before is None)
set_elt.addElement('index').addContent(str(int(index)))
if after:
assert(before is None) # could not specify both at the same time
set_elt.addElement('after').addContent(str(after))
if before is not None:
if before == '': # request the last page, according to http://xmpp.org/extensions/xep-0059.html#last
set_elt.addElement('before')
else:
set_elt.addElement('before').addContent(str(before))
def countItems(self, stanza):
"""Count the items without retrieving any of them.
@param stanza (domish.Element): any stanza to which RSM applies
"""
self.requestPage(stanza, limit=0)
def extractMetadata(self, stanza):
"""Extract the RSM metadata from the given stanza.
@param stanza (domish.Element, wokkel.pubsub.PubSubRequest):
any stanza to which RSM applies. When used by XEP-0060,
wokkel's PubSubRequest instance is also accepted.
@return: dict containing the page metadata
"""
try:
main_elt = domish.generateElementsNamed(stanza.elements(), name="query").next()
except StopIteration:
try:
main_elt = domish.generateElementsNamed(stanza.elements(), name="pubsub").next()
except StopIteration:
log.warning("Extracting data from a RSM element only applies to query or pubsub stanzas")
return {}
try:
set_elt = domish.generateElementsQNamed(main_elt.elements(), name="set", uri=NS_RSM).next()
except StopIteration:
log.debug("There's no RSM element in the stanza")
return {}
data = {}
elts = set_elt.elements()
try:
elt = elts.next()
if elt.name == "first":
data["first"] = "".join(elt.children)
data["first_index"] = int(elt.getAttribute("index"))
elif elt.name == "last":
data["last"] = "".join(elt.children)
elif elt.name == "count":
data["count"] = int("".join(elt.children))
except StopIteration:
pass
if "count" not in data:
log.warning("There's no 'count' element in the RSM element!")
return data
class XEP_0059_handler(XMPPHandler):
implements(iwokkel.IDisco)
def __init__(self, plugin_parent, profile):
self.plugin_parent = plugin_parent
self.host = plugin_parent.host
self.profile = profile
def getDiscoInfo(self, requestor, target, nodeIdentifier=''):
return [disco.DiscoFeature(NS_RSM)]
def getDiscoItems(self, requestor, target, nodeIdentifier=''):
return []

69
src/plugins/plugin_xep_0060.py
View file

@ -23,6 +23,7 @@ from sat.core.log import getLogger
log = getLogger(__name__)
from sat.memory.memory import Sessions
from wokkel.compat import IQ
from wokkel import disco, pubsub
from wokkel.pubsub import PubSubRequest, NS_PUBSUB
from zope.interface import implements
@ -35,6 +36,7 @@ PLUGIN_INFO = {
"type": "XEP",
"protocols": ["XEP-0060"],
"dependencies": [],
"recommendations": ["XEP-0059"],
"main": "XEP_0060",
"handler": "yes",
"description": _("""Implementation of PubSub Protocol""")
@ -232,7 +234,7 @@ class SatPubSubClient(pubsub.PubSubClient):
# FIXME: we have to temporary override this method here just
# to set the attributes itemIdentifiers which is not used
# in pubsub.PubSubClient.items
# in pubsub.PubSubClient.items + use the XEP-0059
def items(self, service, nodeIdentifier, maxItems=None, itemIdentifiers=None,
subscriptionIdentifier=None, sender=None):
"""
@ -255,7 +257,8 @@ class SatPubSubClient(pubsub.PubSubClient):
the results to the specific subscription.
@type subscriptionIdentifier: C{unicode}
"""
request = PubSubRequest('items')
# TODO: add method attributes for RSM: before, after, index
request = PubSubRequest('items', self.host, {'limit': maxItems} if maxItems else {})
request.recipient = service
request.nodeIdentifier = nodeIdentifier
if maxItems:
@ -269,6 +272,7 @@ class SatPubSubClient(pubsub.PubSubClient):
for element in iq.pubsub.items.elements():
if element.uri == NS_PUBSUB and element.name == 'item':
items.append(element)
# TODO: return (items, self.host.plugins['XEP-0059'].extractMetadata(iq)) ??
return items
d = request.send(self.xmlstream)
@ -331,3 +335,64 @@ class SatPubSubClient(pubsub.PubSubClient):
def getDiscoItems(self, requestor, service, nodeIdentifier=''):
return self.host.getDiscoItems(service, nodeIdentifier, self.parent.profile)
class PubSubRequest(pubsub.PubSubRequest):
def __init__(self, verb=None, host=None, page_attrs=None):
"""
@param verb (str): the type of pubsub request
@param host (SAT): the SAT instance
@param page_attrs (dict): options for RSM paging:
- limit (int): the maximum number of items in the page
- index (int): the starting index of the requested page
- after (str, int): the element immediately preceding the page
- before (str, int): the element immediately following the page
"""
self.verb = verb
self.host = host
self.page_attrs = page_attrs
# FIXME: the redefinition of this wokkel method is the easiest way I found
# to handle RSM. We should find a proper solution, maybe just add in wokkel an
# empty method postProcessMessage, call it before sending and overwrite it here
# instead of overwriting the whole send method.
def send(self, xs):
"""
Send this request to its recipient.
This renders all of the relevant parameters for this specific
requests into an L{IQ}, and invoke its C{send} method.
This returns a deferred that fires upon reception of a response. See
L{IQ} for details.
@param xs: The XML stream to send the request on.
@type xs: L{twisted.words.protocols.jabber.xmlstream.XmlStream}
@rtype: L{defer.Deferred}.
"""
try:
(self.stanzaType,
childURI,
childName) = self._verbRequestMap[self.verb]
except KeyError:
raise NotImplementedError()
iq = IQ(xs, self.stanzaType)
iq.addElement((childURI, 'pubsub'))
verbElement = iq.pubsub.addElement(childName)
if self.sender:
iq['from'] = self.sender.full()
if self.recipient:
iq['to'] = self.recipient.full()
for parameter in self._parameters[self.verb]:
getattr(self, '_render_%s' % parameter)(verbElement)
# This lines have been added for RSM
if self.host and 'XEP-0059' in self.host.plugins and self.page_attrs:
self.page_attrs['stanza'] = iq
self.host.plugins['XEP-0059'].requestPage(**self.page_attrs)
return iq.send()