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

core (disco): use of “profile” instead of “profile_key” in several disco methods

Browse source
This commit is contained in:
Goffi 2015-11-02 22:02:41 +01:00
commit 341143445b
7 changed files with 50 additions and 48 deletions
Download patch file Download diff file Expand all files Collapse all files

59
src/memory/disco.py
View file

@ -64,57 +64,57 @@ class Discovery(object):
# TODO: save hashes in databse, remove legacy hashes
@defer.inlineCallbacks
def hasFeature(self, feature, jid_=None, profile_key=C.PROF_KEY_NONE):
def hasFeature(self, feature, jid_=None, profile=C.PROF_KEY_NONE):
"""Tell if an entity has the required feature
@param feature: feature namespace
@param jid_: jid of the target, or None for profile's server
@param profile_key: %(doc_profile_key)s
@param profile: %(doc_profile)s
@return: a Deferred which fire a boolean (True if feature is available)
"""
disco_infos = yield self.getInfos(jid_, profile_key)
disco_infos = yield self.getInfos(jid_, profile)
defer.returnValue(feature in disco_infos.features)
@defer.inlineCallbacks
def checkFeature(self, feature, jid_=None, profile_key=C.PROF_KEY_NONE):
def checkFeature(self, feature, jid_=None, profile=C.PROF_KEY_NONE):
"""Like hasFeature, but raise an exception is feature is not Found
@param feature: feature namespace
@param jid_: jid of the target, or None for profile's server
@param profile_key: %(doc_profile_key)s
@param profile: %(doc_profile)s
@raise: exceptions.FeatureNotFound
"""
disco_infos = yield self.getInfos(jid_, profile_key)
disco_infos = yield self.getInfos(jid_, profile)
if not feature in disco_infos.features:
raise failure.Failure(exceptions.FeatureNotFound)
@defer.inlineCallbacks
def checkFeatures(self, features, jid_=None, identity=None, profile_key=C.PROF_KEY_NONE):
def checkFeatures(self, features, jid_=None, identity=None, profile=C.PROF_KEY_NONE):
"""Like checkFeature, but check several features at once, and check also identity
@param features(iterable[unicode]): features to check
@param jid_(jid.JID): jid of the target, or None for profile's server
@param identity(None, tuple(unicode, unicode): if not None, the entity must have an identity with this (category, type) tuple
@param profile_key: %(doc_profile_key)s
@param profile: %(doc_profile)s
@raise: exceptions.FeatureNotFound
"""
disco_infos = yield self.getInfos(jid_, profile_key)
disco_infos = yield self.getInfos(jid_, profile)
if not set(features).issubset(disco_infos.features):
raise failure.Failure(exceptions.FeatureNotFound())
if identity is not None and identity not in disco_infos.identities:
raise failure.Failure(exceptions.FeatureNotFound())
def getInfos(self, jid_=None, profile_key=C.PROF_KEY_NONE):
def getInfos(self, jid_=None, profile=C.PROF_KEY_NONE):
"""get disco infos from jid_, filling capability hash if needed
@param jid_: jid of the target, or None for profile's server
@param profile_key: %(doc_profile_key)s
@param profile: %(doc_profile)s
@return: a Deferred which fire disco.DiscoInfo
"""
client = self.host.getClient(profile_key)
client = self.host.getClient(profile)
if jid_ is None:
jid_ = jid.JID(client.jid.host)
try:
@ -134,15 +134,15 @@ class Discovery(object):
return defer.succeed(disco_infos)
@defer.inlineCallbacks
def getItems(self, jid_=None, nodeIdentifier='', profile_key=C.PROF_KEY_NONE):
def getItems(self, jid_=None, nodeIdentifier='', profile=C.PROF_KEY_NONE):
"""get disco items from jid_, cache them for our own server
@param jid_ (jid.JID): jid of the target, or None for profile's server
@param nodeIdentifier (str): optional node identifier
@param profile_key: %(doc_profile_key)s
@param profile: %(doc_profile)s
@return: a Deferred which fire disco.DiscoItems
"""
client = self.host.getClient(profile_key)
client = self.host.getClient(profile)
if jid_ is None:
jid_ = jid.JID(client.jid.host)
# we cache items only for our own server
@ -164,13 +164,13 @@ class Discovery(object):
log.warning(_(u"Error while requesting [%(jid)s]: %(error)s") % {'jid': entity_jid.full(),
'error': failure_.getErrorMessage()})
def findServiceEntities(self, category, type_, jid_=None, profile_key=C.PROF_KEY_NONE):
def findServiceEntities(self, category, type_, jid_=None, profile=C.PROF_KEY_NONE):
"""Return all available items of an entity which correspond to (category, type_)
@param category: identity's category
@param type_: identitiy's type
@param jid_: the jid of the target server (None for profile's server)
@param profile_key: %(doc_profile_key)s
@param profile: %(doc_profile)s
@return: a set of found entities
@raise CancelError: the request timed out
"""
@ -183,27 +183,27 @@ class Discovery(object):
def gotItems(items):
defers_list = []
for item in items:
info_d = self.getInfos(item.entity, profile_key)
info_d = self.getInfos(item.entity, profile)
info_d.addCallbacks(infosCb, self._infosEb, [item.entity], None, [item.entity])
defers_list.append(info_d)
return defer.DeferredList(defers_list)
d = self.getItems(jid_, profile_key=profile_key)
d = self.getItems(jid_, profile=profile)
d.addCallback(gotItems)
d.addCallback(lambda dummy: found_entities)
reactor.callLater(TIMEOUT, d.cancel) # FIXME: one bad service make a general timeout
return d
def findFeaturesSet(self, features, identity=None, jid_=None, profile_key=C.PROF_KEY_NONE):
def findFeaturesSet(self, features, identity=None, jid_=None, profile=C.PROF_KEY_NONE):
"""Return entities (including jid_ and its items) offering features
@param features: iterable of features which must be present
@param identity(None, tuple(unicode, unicode)): if not None, accept only this (category/type) identity
@param jid_: the jid of the target server (None for profile's server)
@param profile_key: %(doc_profile_key)s
@param profile: %(doc_profile)s
@return: a set of found entities
"""
client = self.host.getClient(profile_key)
client = self.host.getClient(profile)
if jid_ is None:
jid_ = jid.JID(client.jid.host)
features = set(features)
@ -218,12 +218,12 @@ class Discovery(object):
def gotItems(items):
defer_list = []
for entity in [jid_] + [item.entity for item in items]:
infos_d = self.getInfos(entity, profile_key)
infos_d = self.getInfos(entity, profile)
infos_d.addCallbacks(infosCb, self._infosEb, [entity], None, [entity])
defer_list.append(infos_d)
return defer.DeferredList(defer_list)
d = self.getItems(jid_, profile_key=profile_key)
d = self.getItems(jid_, profile=profile)
d.addCallback(gotItems)
d.addCallback(lambda dummy: found_entities)
reactor.callLater(TIMEOUT, d.cancel) # FIXME: one bad service make a general timeout
@ -259,9 +259,11 @@ class Discovery(object):
""" Discovery method for the bridge
@param entity_jid_s: entity we want to discover
@return: list of tu"""
@return: list of tuples
"""
profile = self.host.memory.getProfileName(profile_key)
entity = jid.JID(entity_jid_s)
disco_infos = yield self.getInfos(entity, profile_key)
disco_infos = yield self.getInfos(entity, profile)
extensions = {}
for form_type, form in disco_infos.extensions.items():
fields = []
@ -286,7 +288,8 @@ class Discovery(object):
""" Discovery method for the bridge
@param entity_jid_s: entity we want to discover
@return: list of tu"""
@return: list of tuples"""
profile = self.host.memory.getProfileName(profile_key)
entity = jid.JID(entity_jid_s)
disco_items = yield self.getItems(entity, profile_key=profile_key)
disco_items = yield self.getItems(entity, profile=profile)
defer.returnValue([(item.entity.full(), item.nodeIdentifier or '', item.name or '') for item in disco_items])

6
src/plugins/plugin_misc_groupblog.py
View file

@ -23,7 +23,7 @@ from sat.core.log import getLogger
log = getLogger(__name__)
from twisted.internet import defer
from twisted.words.protocols.jabber import jid
from twisted.words.xish.domish import Element, generateElementsNamed
from twisted.words.xish.domish import generateElementsNamed
from sat.core import exceptions
from wokkel import disco, data_form, iwokkel
from wokkel import rsm
@ -140,7 +140,7 @@ class GroupBlog(object):
def profileConnected(self, profile):
client = self.host.getClient(profile)
try:
yield self.host.checkFeatures((NS_PUBSUB_GROUPBLOG, NS_PUBSUB_AUTO_CREATE), profile_key=profile)
yield self.host.checkFeatures((NS_PUBSUB_GROUPBLOG, NS_PUBSUB_AUTO_CREATE), profile=profile)
except exceptions.FeatureNotFound:
client.server_groupblog_available = False
log.warning(_(u"Server is not able to manage item-access pubsub, we can't use group blog"))
@ -177,7 +177,7 @@ class GroupBlog(object):
if not hasattr(client, "item_access_pubsub"):
log.debug(_('Looking for item-access powered pubsub server'))
#we don't have any pubsub server featuring item access yet
item_access_pubsubs = yield self.host.findFeaturesSet((NS_PUBSUB_AUTO_CREATE, NS_PUBSUB_CREATOR_JID_CHECK), "pubsub", "service", profile_key=profile)
item_access_pubsubs = yield self.host.findFeaturesSet((NS_PUBSUB_AUTO_CREATE, NS_PUBSUB_CREATOR_JID_CHECK), "pubsub", "service", profile=profile)
# item_access_pubsubs = yield self.host.findFeaturesSet((NS_PUBSUB_ITEM_ACCESS, NS_PUBSUB_AUTO_CREATE, NS_PUBSUB_CREATOR_JID_CHECK), "pubsub", "service", profile_key=profile)
try:
client.item_access_pubsub = item_access_pubsubs.pop()

4
src/plugins/plugin_xep_0033.py
View file

@ -99,7 +99,7 @@ class XEP_0033(object):
self.sendAndStoreMessage(mess_data, entries, profile)
log.debug("XEP-0033 took over")
raise failure.Failure(exceptions.CancelError())
d = self.host.findFeaturesSet([NS_ADDRESS], profile_key=profile)
d = self.host.findFeaturesSet([NS_ADDRESS], profile=profile)
d.addCallbacks(discoCallback, lambda dummy: discoCallback(None))
return d
@ -154,7 +154,7 @@ class XEP_0033(object):
defer_list = []
for type_, jid_ in entries:
d = defer.Deferred()
d.addCallback(self.host.findFeaturesSet, jid_=JID(JID(jid_).host), profile_key=profile)
d.addCallback(self.host.findFeaturesSet, jid_=JID(JID(jid_).host), profile=profile)
d.addCallbacks(discoCallback, errback, callbackArgs=[jid_], errbackArgs=[jid_])
d.callback([NS_ADDRESS])
defer_list.append(d)

8
src/plugins/plugin_xep_0045.py
View file

@ -100,7 +100,7 @@ class XEP_0045(object):
def assign_service(service):
client = self.host.getClient(profile)
client.muc_service = service
return self.getMUCService(profile_key=profile).addCallback(assign_service)
return self.getMUCService(profile=profile).addCallback(assign_service)
def checkClient(self, profile):
"""Check if the profile is connected and has used the MUC feature.
@ -304,14 +304,14 @@ class XEP_0045(object):
return self.clients[profile].rec_subjects.values()
@defer.inlineCallbacks
def getMUCService(self, jid_=None, profile_key=C.PROF_KEY_NONE):
def getMUCService(self, jid_=None, profile=C.PROF_KEY_NONE):
"""Return first found MUC service of an entity
@param jid_: entity which may have a MUC service, or None for our own server
@param profile_key: %(doc_profile_key)s
@param profile: %(doc_profile)s
"""
muc_service = None
services = yield self.host.findServiceEntities("conference", "text", jid_, profile_key=profile_key)
services = yield self.host.findServiceEntities("conference", "text", jid_, profile=profile)
for service in services:
if ".irc." not in service.userhost():
# FIXME:

17
src/plugins/plugin_xep_0055.py
View file

@ -27,7 +27,6 @@ from twisted.internet import defer
from wokkel import data_form
from sat.core.constants import Const as C
from sat.core.exceptions import DataError
from sat.memory.memory import Sessions
from sat.tools import xml_tools
from wokkel import disco, iwokkel
@ -84,11 +83,11 @@ class XEP_0055(object):
def _getHostServices(self, profile):
"""Return the jabber search services associated to the user host.
@param profile (unicode): %(doc_profile)s
@return: list[jid.JID]
"""
d = self.host.findFeaturesSet([NS_SEARCH], profile_key=profile)
d = self.host.findFeaturesSet([NS_SEARCH], profile=profile)
return d.addCallback(lambda set_: list(set_))
@ -125,7 +124,7 @@ class XEP_0055(object):
def _addSimpleSearchUI(self, services, main_ui, data, profile):
"""Add to the main UI a tab for the simple search.
Display a single input field and search on the main service (it actually does one search per search field and then compile the results).
@param services (list[jid.JID]): search services offered by the user server
@ -143,7 +142,7 @@ class XEP_0055(object):
sub_cont = main_ui.main_container.addTab("simple_search", label=_("Simple search"), container=xml_tools.VerticalContainer)
main_ui.changeContainer(sub_cont.append(xml_tools.PairsContainer(main_ui)))
xml_tools.dataForm2Widgets(main_ui, form)
# FIXME: add colspan attribute to divider? (we are in a PairsContainer)
main_ui.addDivider('blank')
main_ui.addDivider('blank') # here we added a blank line before the button
@ -243,7 +242,7 @@ class XEP_0055(object):
name = widget.getAttribute("name")
if adv_data.get(name):
widget.setAttribute("value", adv_data[name])
# FIXME: add colspan attribute to divider? (we are in a PairsContainer)
main_ui.addDivider('blank')
main_ui.addDivider('blank') # here we added a blank line before the button
@ -267,11 +266,11 @@ class XEP_0055(object):
def _displaySearchResult(self, main_ui, elt):
"""Display the search results.
@param main_ui (XMLUI): the main XMLUI instance
@param elt (domish.Element): form result element
"""
if [child for child in elt.children if child.name == "item"]:
if [child for child in elt.children if child.name == "item"]:
headers, xmlui_data = xml_tools.dataFormResult2XMLUIData(elt)
if "jid" in headers: # use XMLUI JidsListWidget to display the results
values = {}
@ -458,7 +457,7 @@ class XEP_0055(object):
@return: a deferred dict{unicode: unicode}
"""
d = self._getHostServices(profile)
def got_services(services):
service_jid = services[0]
d = self.host.plugins["XEP-0050"].requestCommandsList(service_jid, profile)

2
src/plugins/plugin_xep_0060.py
View file

@ -96,7 +96,7 @@ class XEP_0060(object):
@defer.inlineCallbacks
def profileConnected(self, profile):
client = self.host.getClient(profile)
pubsub_services = yield self.host.findServiceEntities("pubsub", "service", profile_key = profile)
pubsub_services = yield self.host.findServiceEntities("pubsub", "service", profile=profile)
if pubsub_services:
# we use one of the found services as our default pubsub service
client.pubsub_service = pubsub_services.pop()

2
src/plugins/plugin_xep_0115.py
View file

@ -66,7 +66,7 @@ class XEP_0115(object):
client.caps_optimize = None
if XEP_0115.cap_hash is None:
disco_d.addCallback(lambda dummy: self.host.hasFeature(NS_CAPS_OPTIMIZE, profile_key=profile))
disco_d.addCallback(lambda dummy: self.host.hasFeature(NS_CAPS_OPTIMIZE, profile=profile))
def updateOptimize(optimize):
client.caps_optimize = optimize
if optimize: