def getDiscoInfo(self, requestor, target, node):
info = set()
if node:
info.add(disco.DiscoIdentity('automation', 'command-node'))
info.add(disco.DiscoFeature('http://jabber.org/protocol/commands'))
else:
info.add(disco.DiscoFeature(NS_CMD))
return defer.succeed(info)
def getDiscoInfo(self, requestor, target, nodeIdentifier=''):
def toInfo(nodeInfo):
if not nodeInfo:
return
(nodeType, metaData) = nodeInfo['type'], nodeInfo['meta-data']
info.append(disco.DiscoIdentity('pubsub', nodeType))
if metaData:
form = data_form.Form(formType="result",
formNamespace=NS_PUBSUB_META_DATA)
form.addField(
data_form.Field(
var='pubsub#node_type',
value=nodeType,
label='The type of node (collection or leaf)'))
for metaDatum in metaData:
form.addField(data_form.Field.fromDict(metaDatum))
info.append(form)
return
info = []
request = PubSubRequest('discoInfo')
if self.resource is not None:
resource = self.resource.locateResource(request)
identity = resource.discoIdentity
features = resource.features
getInfo = resource.getInfo
else:
category = self.discoIdentity['category']
idType = self.discoIdentity['type']
name = self.discoIdentity['name']
identity = disco.DiscoIdentity(category, idType, name)
features = self.pubSubFeatures
getInfo = self.getNodeInfo
if not nodeIdentifier:
info.append(identity)
info.append(disco.DiscoFeature(disco.NS_DISCO_ITEMS))
info.extend([
disco.DiscoFeature("%s#%s" % (NS_PUBSUB, feature))
for feature in features
])
d = defer.maybeDeferred(getInfo, requestor, target, nodeIdentifier
or '')
d.addCallback(toInfo)
d.addErrback(log.err)
d.addCallback(lambda _: info)
return d
def getDiscoInfo(self, requestor, target, node):
info = set()
if not node:
info.add(disco.DiscoFeature(NS_PING))
return defer.succeed(info)
def test_infoNotDeferred(self):
"""
C{info} should gather disco info from sibling handlers.
"""
discoItems = [
disco.DiscoIdentity('dummy', 'generic', 'Generic Dummy Entity'),
disco.DiscoFeature('jabber:iq:version')
]
class DiscoResponder(XMPPHandler):
implements(disco.IDisco)
def getDiscoInfo(self, requestor, target, nodeIdentifier):
if not nodeIdentifier:
return discoItems
else:
return []
def cb(result):
self.assertEquals(discoItems, result)
self.service.parent = [self.service, DiscoResponder()]
d = self.service.info(JID('*****@*****.**'), JID('example.com'), '')
d.addCallback(cb)
return d
def test_discoServerSupport(self):
"""Disco support from client to server.
"""
test_srv = 'shakespeare.lit'
def cb(query):
# check namespace
self.failUnless(query.uri == disco.NS_INFO, 'Wrong namespace')
d = self.protocol.disco(test_srv)
d.addCallback(cb)
iq = self.stub.output[-1]
# send back a response
response = toResponse(iq, 'result')
response.addElement('query', disco.NS_INFO)
# need to add information to response
response.query.addChild(disco.DiscoFeature(muc.NS_MUC))
response.query.addChild(
disco.DiscoIdentity(category='conference',
name='Macbeth Chat Service',
type='text'))
self.stub.send(response)
return d
def getDiscoInfo(self, requestor, target, node):
info = set()
if not node:
from wokkel import disco
info.add(disco.DiscoFeature(NS_VERSION))
return defer.succeed(info)
def info(requestor, target, nodeIdentifier):
self.assertEqual(JID('*****@*****.**'), requestor)
return defer.succeed([
disco.DiscoIdentity('dummy', 'generic',
'Generic Dummy Entity'),
disco.DiscoFeature('jabber:iq:version')
])
def getDiscoInfo(self, requestor, target, nodeIdentifier):
if not nodeIdentifier:
return defer.succeed([
disco.DiscoIdentity('dummy', 'generic', 'Generic Dummy Entity'),
disco.DiscoFeature('jabber:iq:version')
])
else:
return defer.succeed([])
def getDiscoInfo(self, requestor, target, nodeIdentifier=''):
"""
Get identity and features from this entity, node.
This handler supports Collaborative Editing, but only without a
nodeIdentifier specified.
"""
if not nodeIdentifier:
return [disco.DiscoFeature(NS_CE)]
else:
return []
def test_toElement(self):
"""
Test proper rendering to a DOM representation.
The returned element should be properly named and have a C{var}
attribute that holds the feature namespace URI.
"""
feature = disco.DiscoFeature(u'testns')
element = feature.toElement()
self.assertEqual(NS_DISCO_INFO, element.uri)
self.assertEqual(u'feature', element.name)
self.assertTrue(element.hasAttribute(u'var'))
self.assertEqual(u'testns', element[u'var'])
def getDiscoInfo(self, requestor, target, nodeIdentifier):
info = []
if not nodeIdentifier:
info.append(disco.DiscoIdentity(**self.discoIdentity))
info.append(disco.DiscoFeature(disco.NS_ITEMS))
info.extend([disco.DiscoFeature("%s#%s" % (NS_PUBSUB, feature))
for feature in self.pubSubFeatures])
def toInfo(nodeInfo):
if not nodeInfo:
return
(nodeType, metaData) = nodeInfo['type'], nodeInfo['meta-data']
info.append(disco.DiscoIdentity('pubsub', nodeType))
if metaData:
form = data_form.Form(formType="result",
formNamespace=NS_PUBSUB_META_DATA)
form.addField(
data_form.Field(
var='pubsub#node_type',
value=nodeType,
label='The type of node (collection or leaf)'
)
)
for metaDatum in metaData:
form.addField(data_form.Field.fromDict(metaDatum))
info.append(form.toElement())
d = self.getNodeInfo(requestor, target, nodeIdentifier or '')
d.addCallback(toInfo)
d.addBoth(lambda result: info)
return d
def getDiscoInfo(self, requestor, target, nodeIdentifier):
if not nodeIdentifier:
return defer.succeed([
disco.DiscoIdentity('sms', 'generic', 'SMS77.de Gateway'),
disco.DiscoFeature('jabber:iq:version'),
disco.DiscoFeature('jabber:iq:register'),
#disco.DiscoFeature('jabber:iq:search'),
disco.DiscoFeature('jabber:iq:gateway'),
disco.DiscoFeature('vcard-temp'),
disco.DiscoFeature('http://jabber.org/protocol/disco#info'),
disco.DiscoFeature('http://jabber.org/protocol/disco#items')
])
else:
return defer.succeed([])
def test_toElementChildren(self):
"""
Test C{toElement} creates a DOM with proper childs.
"""
info = disco.DiscoInfo()
info.append(disco.DiscoFeature(u'jabber:iq:register'))
info.append(disco.DiscoIdentity(u'conference', u'text'))
info.append(data_form.Form(u'result'))
element = info.toElement()
featureElements = domish.generateElementsQNamed(
element.children, u'feature', NS_DISCO_INFO)
self.assertEqual(1, len(list(featureElements)))
identityElements = domish.generateElementsQNamed(
element.children, u'identity', NS_DISCO_INFO)
self.assertEqual(1, len(list(identityElements)))
extensionElements = domish.generateElementsQNamed(
element.children, u'x', data_form.NS_X_DATA)
self.assertEqual(1, len(list(extensionElements)))
def items(requestor, target, nodeIdentifier):
self.assertEqual('test', nodeIdentifier)
return defer.succeed([disco.DiscoFeature('jabber:iq:version')])
def test_init(self):
"""
Test initialization with a with feature namespace URI.
"""
feature = disco.DiscoFeature(u'testns')
self.assertEqual(u'testns', feature)
def info(self, requestor, target, nodeIdentifier):
"""
Gather data for a disco info request.
@param requestor: The entity that sent the request.
@type requestor: L{JID<twisted.words.protocols.jabber.jid.JID>}
@param target: The entity the request was sent to.
@type target: L{JID<twisted.words.protocols.jabber.jid.JID>}
@param nodeIdentifier: The optional node being queried, or C{''}.
@type nodeIdentifier: C{unicode}
@return: Deferred with the gathered results from sibling handlers.
@rtype: L{defer.Deferred}
"""
xmpp_manager = self.parent.manager
if target.host not in xmpp_manager.domains | xmpp_manager.muc_domains:
return defer.fail(StanzaError('service-unavailable'))
elements = [
disco.DiscoFeature(disco.NS_DISCO_INFO),
disco.DiscoFeature(disco.NS_DISCO_ITEMS),
disco.DiscoFeature('http://sylkserver.com')
]
if target.host in xmpp_manager.muc_domains:
elements.append(
disco.DiscoIdentity('conference', 'text',
'SylkServer Chat Service'))
elements.append(
disco.DiscoFeature('http://jabber.org/protocol/muc'))
elements.append(disco.DiscoFeature('urn:ietf:rfc:3264'))
elements.append(disco.DiscoFeature('urn:xmpp:coin'))
elements.append(disco.DiscoFeature(jingle.NS_JINGLE))
elements.append(disco.DiscoFeature(jingle.NS_JINGLE_APPS_RTP))
elements.append(disco.DiscoFeature(
jingle.NS_JINGLE_APPS_RTP_AUDIO))
#elements.append(disco.DiscoFeature(jingle.NS_JINGLE_APPS_RTP_VIDEO))
elements.append(
disco.DiscoFeature(jingle.NS_JINGLE_ICE_UDP_TRANSPORT))
elements.append(
disco.DiscoFeature(jingle.NS_JINGLE_RAW_UDP_TRANSPORT))
if target.user:
# We can't say much more here, because the actual conference may end up on a different server
elements.append(disco.DiscoFeature('muc_temporary'))
elements.append(disco.DiscoFeature('muc_unmoderated'))
else:
elements.append(disco.DiscoFeature(ping.NS_PING))
if not target.user:
elements.append(
disco.DiscoIdentity('gateway', 'simple', 'SylkServer'))
elements.append(
disco.DiscoIdentity('server', 'im', 'SylkServer'))
else:
elements.append(disco.DiscoIdentity('client', 'pc'))
elements.append(
disco.DiscoFeature('http://jabber.org/protocol/caps'))
elements.append(
disco.DiscoFeature(
'http://jabber.org/protocol/chatstates'))
elements.append(disco.DiscoFeature('urn:ietf:rfc:3264'))
elements.append(disco.DiscoFeature('urn:xmpp:coin'))
elements.append(disco.DiscoFeature(jingle.NS_JINGLE))
elements.append(disco.DiscoFeature(jingle.NS_JINGLE_APPS_RTP))
elements.append(
disco.DiscoFeature(jingle.NS_JINGLE_APPS_RTP_AUDIO))
#elements.append(disco.DiscoFeature(jingle.NS_JINGLE_APPS_RTP_VIDEO))
elements.append(
disco.DiscoFeature(jingle.NS_JINGLE_ICE_UDP_TRANSPORT))
elements.append(
disco.DiscoFeature(jingle.NS_JINGLE_RAW_UDP_TRANSPORT))
return defer.succeed(elements)
