wokkel-0.7.1/ 0000775 0001750 0001750 00000000000 12074346436 013616 5 ustar ralphm ralphm 0000000 0000000 wokkel-0.7.1/wokkel.egg-info/ 0000775 0001750 0001750 00000000000 12074346436 016604 5 ustar ralphm ralphm 0000000 0000000 wokkel-0.7.1/wokkel.egg-info/SOURCES.txt 0000664 0001750 0001750 00000002437 12074346436 020476 0 ustar ralphm ralphm 0000000 0000000 LICENSE
MANIFEST.in
NEWS
README
setup.py
doc/examples/echo_server.tac
doc/examples/muc_client.tac
doc/examples/ping_component.tac
doc/examples/ping_s2s.tac
doc/examples/ping_server.tac
doc/examples/pinger.py
doc/examples/pinger_client.tac
doc/examples/pinger_component.tac
doc/examples/pinger_s2s.tac
doc/examples/router.tac
twisted/plugins/server.py
wokkel/__init__.py
wokkel/client.py
wokkel/compat.py
wokkel/component.py
wokkel/componentservertap.py
wokkel/data_form.py
wokkel/delay.py
wokkel/disco.py
wokkel/formats.py
wokkel/generic.py
wokkel/iwokkel.py
wokkel/muc.py
wokkel/ping.py
wokkel/pubsub.py
wokkel/server.py
wokkel/shim.py
wokkel/subprotocols.py
wokkel/xmppim.py
wokkel.egg-info/PKG-INFO
wokkel.egg-info/SOURCES.txt
wokkel.egg-info/dependency_links.txt
wokkel.egg-info/not-zip-safe
wokkel.egg-info/requires.txt
wokkel.egg-info/top_level.txt
wokkel/test/__init__.py
wokkel/test/helpers.py
wokkel/test/test_client.py
wokkel/test/test_compat.py
wokkel/test/test_component.py
wokkel/test/test_data_form.py
wokkel/test/test_delay.py
wokkel/test/test_disco.py
wokkel/test/test_generic.py
wokkel/test/test_iwokkel.py
wokkel/test/test_muc.py
wokkel/test/test_ping.py
wokkel/test/test_pubsub.py
wokkel/test/test_server.py
wokkel/test/test_shim.py
wokkel/test/test_subprotocols.py
wokkel/test/test_xmppim.py wokkel-0.7.1/wokkel.egg-info/requires.txt 0000664 0001750 0001750 00000000041 12074346436 021177 0 ustar ralphm ralphm 0000000 0000000 Twisted >= 10.0.0
python-dateutil wokkel-0.7.1/wokkel.egg-info/not-zip-safe 0000664 0001750 0001750 00000000001 11754447235 021035 0 ustar ralphm ralphm 0000000 0000000
wokkel-0.7.1/wokkel.egg-info/PKG-INFO 0000664 0001750 0001750 00000000332 12074346436 017677 0 ustar ralphm ralphm 0000000 0000000 Metadata-Version: 1.0
Name: wokkel
Version: 0.7.1
Summary: Twisted Jabber support library
Home-page: http://wokkel.ik.nu/
Author: Ralph Meijer
Author-email: ralphm@ik.nu
License: MIT
Description: UNKNOWN
Platform: any
wokkel-0.7.1/wokkel.egg-info/top_level.txt 0000664 0001750 0001750 00000000007 12074346436 021333 0 ustar ralphm ralphm 0000000 0000000 wokkel
wokkel-0.7.1/wokkel.egg-info/dependency_links.txt 0000664 0001750 0001750 00000000001 12074346436 022652 0 ustar ralphm ralphm 0000000 0000000
wokkel-0.7.1/twisted/ 0000775 0001750 0001750 00000000000 12074346436 015301 5 ustar ralphm ralphm 0000000 0000000 wokkel-0.7.1/twisted/plugins/ 0000775 0001750 0001750 00000000000 12074346436 016762 5 ustar ralphm ralphm 0000000 0000000 wokkel-0.7.1/twisted/plugins/server.py 0000775 0001750 0001750 00000000427 11653744106 020646 0 ustar ralphm ralphm 0000000 0000000 # Copyright (c) Ralph Meijer.
# See LICENSE for details.
from twisted.application.service import ServiceMaker
WokkelXMPPComponentServer = ServiceMaker(
"XMPP Component Server",
"wokkel.componentservertap",
"An XMPP Component Server",
"wokkel-component-server")
wokkel-0.7.1/setup.py 0000775 0001750 0001750 00000002515 12074331563 015331 0 ustar ralphm ralphm 0000000 0000000 #!/usr/bin/env python
# Copyright (c) Ralph Meijer.
# See LICENSE for details.
from setuptools import setup
# Make sure 'twisted' doesn't appear in top_level.txt
try:
from setuptools.command import egg_info
egg_info.write_toplevel_names
except (ImportError, AttributeError):
pass
else:
def _top_level_package(name):
return name.split('.', 1)[0]
def _hacked_write_toplevel_names(cmd, basename, filename):
pkgs = dict.fromkeys(
[_top_level_package(k)
for k in cmd.distribution.iter_distribution_names()
if _top_level_package(k) != "twisted"
]
)
cmd.write_file("top-level names", filename, '\n'.join(pkgs) + '\n')
egg_info.write_toplevel_names = _hacked_write_toplevel_names
setup(name='wokkel',
version='0.7.1',
description='Twisted Jabber support library',
author='Ralph Meijer',
author_email='ralphm@ik.nu',
maintainer_email='ralphm@ik.nu',
url='http://wokkel.ik.nu/',
license='MIT',
platforms='any',
packages=[
'wokkel',
'wokkel.test',
'twisted.plugins',
],
package_data={'twisted.plugins': ['twisted/plugins/server.py']},
zip_safe=False,
install_requires=[
'Twisted >= 10.0.0',
'python-dateutil',
],
)
wokkel-0.7.1/MANIFEST.in 0000664 0001750 0001750 00000000122 11707274572 015352 0 ustar ralphm ralphm 0000000 0000000 include NEWS
include LICENSE
include doc/examples/*.py
include doc/examples/*.tac
wokkel-0.7.1/setup.cfg 0000664 0001750 0001750 00000000073 12074346436 015437 0 ustar ralphm ralphm 0000000 0000000 [egg_info]
tag_build =
tag_date = 0
tag_svn_revision = 0
wokkel-0.7.1/PKG-INFO 0000664 0001750 0001750 00000000332 12074346436 014711 0 ustar ralphm ralphm 0000000 0000000 Metadata-Version: 1.0
Name: wokkel
Version: 0.7.1
Summary: Twisted Jabber support library
Home-page: http://wokkel.ik.nu/
Author: Ralph Meijer
Author-email: ralphm@ik.nu
License: MIT
Description: UNKNOWN
Platform: any
wokkel-0.7.1/doc/ 0000775 0001750 0001750 00000000000 12074346436 014363 5 ustar ralphm ralphm 0000000 0000000 wokkel-0.7.1/doc/examples/ 0000775 0001750 0001750 00000000000 12074346436 016201 5 ustar ralphm ralphm 0000000 0000000 wokkel-0.7.1/doc/examples/pinger_s2s.tac 0000664 0001750 0001750 00000002341 12025346064 020736 0 ustar ralphm ralphm 0000000 0000000 """
An XMPP Ping client as a standalone server via s2s.
This ping client accepts and initiates server-to-server connections using
dialback and listens on C{127.0.1.1} with the domain set to the default
hostname of this machine.
"""
import socket
from twisted.application import service, strports
from twisted.words.protocols.jabber.jid import JID
from wokkel import component, server
from pinger import Pinger
# Configuration parameters
S2S_PORT = 'tcp:5269:interface=127.0.1.1'
SECRET = 'secret'
DOMAIN = socket.gethostname()
OTHER_DOMAIN = 'localhost'
LOG_TRAFFIC = True
# Set up the Twisted application
application = service.Application("Pinger Server")
router = component.Router()
serverService = server.ServerService(router, domain=DOMAIN, secret=SECRET)
serverService.logTraffic = LOG_TRAFFIC
s2sFactory = server.XMPPS2SServerFactory(serverService)
s2sFactory.logTraffic = LOG_TRAFFIC
s2sService = strports.service(S2S_PORT, s2sFactory)
s2sService.setServiceParent(application)
pingerComponent = component.InternalComponent(router, DOMAIN)
pingerComponent.logTraffic = LOG_TRAFFIC
pingerComponent.setServiceParent(application)
pingerHandler = Pinger(JID(OTHER_DOMAIN), JID(DOMAIN))
pingerHandler.setHandlerParent(pingerComponent)
wokkel-0.7.1/doc/examples/pinger_client.tac 0000644 0001750 0001750 00000001343 11322111274 021474 0 ustar ralphm ralphm 0000000 0000000 """
An XMPP Ping client as an XMPP client.
This pinger client logs in as C{pinger@example.org}.
"""
from twisted.application import service
from twisted.words.protocols.jabber.jid import JID
from wokkel import client
from pinger import Pinger
# Configuration parameters
THIS_JID = JID('pinger@example.org')
OTHER_JID = JID('ping.example.com')
SECRET = 'secret'
LOG_TRAFFIC = True
# Set up the Twisted application
application = service.Application("Pinger Component")
pingerClient = client.XMPPClient(THIS_JID, SECRET)
pingerClient.logTraffic = LOG_TRAFFIC
pingerClient.setServiceParent(application)
pingerClient.send('') # Hello, OpenFire!
pingerHandler = Pinger(OTHER_JID)
pingerHandler.setHandlerParent(pingerClient)
wokkel-0.7.1/doc/examples/pinger_component.tac 0000644 0001750 0001750 00000001430 11322111274 022215 0 ustar ralphm ralphm 0000000 0000000 """
An XMPP Ping client as an external server-side component.
This pinger client assumes the domain C{pinger}.
"""
from twisted.application import service
from twisted.words.protocols.jabber.jid import JID
from wokkel import component
from pinger import Pinger
# Configuration parameters
EXT_HOST = 'localhost'
EXT_PORT = 5347
SECRET = 'secret'
DOMAIN = 'pinger'
OTHER_DOMAIN = 'ping'
LOG_TRAFFIC = True
# Set up the Twisted application
application = service.Application("Pinger Component")
router = component.Router()
pingerComponent = component.Component(EXT_HOST, EXT_PORT, DOMAIN, SECRET)
pingerComponent.logTraffic = LOG_TRAFFIC
pingerComponent.setServiceParent(application)
pingerHandler = Pinger(JID(OTHER_DOMAIN), JID(DOMAIN))
pingerHandler.setHandlerParent(pingerComponent)
wokkel-0.7.1/doc/examples/ping_component.tac 0000644 0001750 0001750 00000001256 11322111274 021674 0 ustar ralphm ralphm 0000000 0000000 """
An XMPP Ping server as an external server-side component.
This ping server assumes the domain C{'ping'}.
"""
from twisted.application import service
from wokkel import component
from wokkel.ping import PingHandler
# Configuration parameters
EXT_HOST = 'localhost'
EXT_PORT = 5347
SECRET = 'secret'
DOMAIN = 'ping'
LOG_TRAFFIC = True
# Set up the Twisted application
application = service.Application("Ping Component")
router = component.Router()
pingComponent = component.Component(EXT_HOST, EXT_PORT, DOMAIN, SECRET)
pingComponent.logTraffic = LOG_TRAFFIC
pingComponent.setServiceParent(application)
pingHandler = PingHandler()
pingHandler.setHandlerParent(pingComponent)
wokkel-0.7.1/doc/examples/ping_s2s.tac 0000664 0001750 0001750 00000002102 12013012404 020363 0 ustar ralphm ralphm 0000000 0000000 """
An XMPP Ping server as a standalone server via s2s.
This ping responder accepts and initiates server-to-server connections using
dialback and listens on C{127.0.0.1} with the domain C{localhost}.
"""
from twisted.application import service, strports
from wokkel import component, server
from wokkel.ping import PingHandler
# Configuration parameters
S2S_PORT = 'tcp:5269:interface=127.0.0.1'
SECRET = 'secret'
DOMAIN = 'localhost'
LOG_TRAFFIC = True
# Set up the Twisted application
application = service.Application("Ping Server")
router = component.Router()
serverService = server.ServerService(router, domain=DOMAIN, secret=SECRET)
serverService.logTraffic = LOG_TRAFFIC
s2sFactory = server.XMPPS2SServerFactory(serverService)
s2sFactory.logTraffic = LOG_TRAFFIC
s2sService = strports.service(S2S_PORT, s2sFactory)
s2sService.setServiceParent(application)
pingComponent = component.InternalComponent(router, DOMAIN)
pingComponent.logTraffic = LOG_TRAFFIC
pingComponent.setServiceParent(application)
pingHandler = PingHandler()
pingHandler.setHandlerParent(pingComponent)
wokkel-0.7.1/doc/examples/router.tac 0000644 0001750 0001750 00000001077 11322111274 020176 0 ustar ralphm ralphm 0000000 0000000 """
A generic XMPP router.
This router accepts external server-side component connections on port 5347,
but only on 127.0.0.1.
"""
from twisted.application import service, strports
from wokkel import component
application = service.Application("XMPP router")
router = component.Router()
componentServerFactory = component.XMPPComponentServerFactory(router)
componentServerFactory.logTraffic = True
componentServer = strports.service('tcp:5347:interface=127.0.0.1',
componentServerFactory)
componentServer.setServiceParent(application)
wokkel-0.7.1/doc/examples/echo_server.tac 0000644 0001750 0001750 00000007167 11322111274 021170 0 ustar ralphm ralphm 0000000 0000000 """
An XMPP echo server as a standalone server via s2s.
This echo server accepts and initiates server-to-server connections using
dialback and listens on C{127.0.0.1} with the domain C{localhost}. It will
accept subscription requests for any potential entity at the domain and
send back messages sent to it.
"""
from twisted.application import service, strports
from twisted.words.protocols.jabber.xmlstream import toResponse
from wokkel import component, server, xmppim
# Configuration parameters
S2S_PORT = 'tcp:5269:interface=127.0.0.1'
SECRET = 'secret'
DOMAIN = 'localhost'
LOG_TRAFFIC = True
# Protocol handlers
class PresenceAcceptingHandler(xmppim.PresenceProtocol):
"""
Presence accepting XMPP subprotocol handler.
This handler blindly accepts incoming presence subscription requests,
confirms unsubscription requests and responds to presence probes.
Note that this handler does not remember any contacts, so it will not
send presence when starting.
"""
def subscribedReceived(self, presence):
"""
Subscription approval confirmation was received.
This is just a confirmation. Don't respond.
"""
pass
def unsubscribedReceived(self, presence):
"""
Unsubscription confirmation was received.
This is just a confirmation. Don't respond.
"""
pass
def subscribeReceived(self, presence):
"""
Subscription request was received.
Always grant permission to see our presence.
"""
self.subscribed(recipient=presence.sender,
sender=presence.recipient)
self.available(recipient=presence.sender,
status=u"I'm here",
sender=presence.recipient)
def unsubscribeReceived(self, presence):
"""
Unsubscription request was received.
Always confirm unsubscription requests.
"""
self.unsubscribed(recipient=presence.sender,
sender=presence.recipient)
def probeReceived(self, presence):
"""
A presence probe was received.
Always send available presence to whoever is asking.
"""
self.available(recipient=presence.sender,
status=u"I'm here",
sender=presence.recipient)
class EchoHandler(xmppim.MessageProtocol):
"""
Message echoing XMPP subprotocol handler.
"""
def onMessage(self, message):
"""
Called when a message stanza was received.
"""
# Ignore error messages
if message.getAttribute('type') == 'error':
return
# Echo incoming messages, if they have a body.
if message.body and unicode(message.body):
response = toResponse(message, message.getAttribute('type'))
response.addElement('body', content=unicode(message.body))
self.send(response)
# Set up the Twisted application
application = service.Application("Ping Server")
router = component.Router()
serverService = server.ServerService(router, domain=DOMAIN, secret=SECRET)
serverService.logTraffic = LOG_TRAFFIC
s2sFactory = server.XMPPS2SServerFactory(serverService)
s2sFactory.logTraffic = LOG_TRAFFIC
s2sService = strports.service(S2S_PORT, s2sFactory)
s2sService.setServiceParent(application)
echoComponent = component.InternalComponent(router, DOMAIN)
echoComponent.logTraffic = LOG_TRAFFIC
echoComponent.setServiceParent(application)
presenceHandler = PresenceAcceptingHandler()
presenceHandler.setHandlerParent(echoComponent)
echoHandler = EchoHandler()
echoHandler.setHandlerParent(echoComponent)
wokkel-0.7.1/doc/examples/pinger.py 0000644 0001750 0001750 00000001017 11322111274 020015 0 ustar ralphm ralphm 0000000 0000000 """
An XMPP subprotocol handler that acts as an XMPP Ping pinger.
"""
from wokkel.ping import PingClientProtocol
class Pinger(PingClientProtocol):
"""
I send a ping as soon as I have a connection.
"""
def __init__(self, entity, sender=None):
self.entity = entity
self.sender = sender
def connectionInitialized(self):
def cb(response):
print "*** Pong ***"
print "*** Ping ***"
d = self.ping(self.entity, sender=self.sender)
d.addCallback(cb)
wokkel-0.7.1/doc/examples/ping_server.tac 0000644 0001750 0001750 00000002026 11322111274 021174 0 ustar ralphm ralphm 0000000 0000000 """
An XMPP Ping server as a standalone server with external component service.
This ping responder server uses the C{ping} domain, and also accepts External
Component connections on port C{5347}, but only on C{127.0.0.1}.
"""
from twisted.application import service, strports
from wokkel import component
from wokkel.ping import PingHandler
# Configuration parameters
EXT_PORT = 'tcp:5347:interface=127.0.0.1'
SECRET = 'secret'
DOMAIN = 'ping'
LOG_TRAFFIC = True
# Set up the Twisted application
application = service.Application("XMPP Ping Server")
router = component.Router()
componentServerFactory = component.XMPPComponentServerFactory(router, SECRET)
componentServerFactory.logTraffic = LOG_TRAFFIC
componentServer = strports.service(EXT_PORT, componentServerFactory)
componentServer.setServiceParent(application)
pingComponent = component.InternalComponent(router, DOMAIN)
pingComponent.logTraffic = LOG_TRAFFIC
pingComponent.setServiceParent(application)
pingHandler = PingHandler()
pingHandler.setHandlerParent(pingComponent)
wokkel-0.7.1/doc/examples/muc_client.tac 0000664 0001750 0001750 00000006074 11707004455 021015 0 ustar ralphm ralphm 0000000 0000000 """
An XMPP MUC client.
This XMPP Client logs in as C{user@example.org}, joins the room
C{'room@muc.example.org'} using the nick C{'greeter'} and responds to
greetings addressed to it. If another occupant writes C{'greeter: hello'}, it
will return the favor.
This example uses L{MUCClient} instead of the protocol-only
L{MUCClientProtocol} so that it can hook into
its C{receivedGroupChat}. L{MUCClient} implements C{groupChatReceived} and
makes a distinction between messages setting the subject, messages that a
part of the room's conversation history, and 'live' messages. In this case,
we only want to inspect and respond to the 'live' messages.
"""
from twisted.application import service
from twisted.python import log
from twisted.words.protocols.jabber.jid import JID
from wokkel.client import XMPPClient
from wokkel.muc import MUCClient
# Configuration parameters
THIS_JID = JID('user@example.org')
ROOM_JID = JID('room@muc.example.org')
NICK = u'greeter'
SECRET = 'secret'
LOG_TRAFFIC = True
class MUCGreeter(MUCClient):
"""
I join a room and respond to greetings.
"""
def __init__(self, roomJID, nick):
MUCClient.__init__(self)
self.roomJID = roomJID
self.nick = nick
def connectionInitialized(self):
"""
Once authorized, join the room.
If the join action causes a new room to be created, the room will be
locked until configured. Here we will just accept the default
configuration by submitting an empty form using L{configure}, which
usually results in a public non-persistent room.
Alternatively, you would use L{getConfiguration} to retrieve the
configuration form, and then submit the filled in form with the
required settings using L{configure}, possibly after presenting it to
an end-user.
"""
def joinedRoom(room):
if room.locked:
# Just accept the default configuration.
return self.configure(room.roomJID, {})
MUCClient.connectionInitialized(self)
d = self.join(self.roomJID, self.nick)
d.addCallback(joinedRoom)
d.addCallback(lambda _: log.msg("Joined room"))
d.addErrback(log.err, "Join failed")
def receivedGroupChat(self, room, user, message):
"""
Called when a groupchat message was received.
Check if the message was addressed to my nick and if it said
C{'hello'}. Respond by sending a message to the room addressed to
the sender.
"""
if message.body.startswith(self.nick + u":"):
nick, text = message.body.split(':', 1)
text = text.strip().lower()
if text == u'hello':
body = u"%s: Hi!" % (user.nick)
self.groupChat(self.roomJID, body)
# Set up the Twisted application
application = service.Application("MUC Client")
client = XMPPClient(THIS_JID, SECRET)
client.logTraffic = LOG_TRAFFIC
client.setServiceParent(application)
mucHandler = MUCGreeter(ROOM_JID, NICK)
mucHandler.setHandlerParent(client)
wokkel-0.7.1/NEWS 0000664 0001750 0001750 00000022240 12074331547 014312 0 ustar ralphm ralphm 0000000 0000000 0.7.1 (2013-01-12)
==================
Features
--------
- wokkel.generic.Request.parseRequest is a new convenience hook for parsing
the payload of incoming requests using fromElement.
- wokkel.xmppim.RosterItem can now represent item removals and has methods
for XML (de-)serialization (#71).
- wokkel.xmppim.RosterRequest is a new class to represent roster request
stanzas (#71).
- wokkel.xmppim.RosterClientProtocol.getRoster now returns the roster
indexed by JID (#71).
- wokkel.xmppim.RosterClientProtocol uses the new RosterRequest for sending
outgoing requests, using the new request semantics (#71).
- wokkel.xmppim.RosterClientProtocol uses the new RosterRequest to provide
access to addressing and roster version information in the new callbacks
for roster pushes (#71).
- wokkel.xmppim.RosterPushIgnored can be raised for unwanted roster pushes
(#71).
- wokkel.xmppim.RosterClientProtocol and RosterRequest now support roster
versioning.
- With the new wokkel.xmppim.RosterClientProtocol.setItem roster items can
be added or updated (#56).
Fixes
-----
- wokkel.component.Component now reconnects if first attempt failed (#75).
- wokkel.xmppim.RosterClientProtocol now properly checks sender addresses
for roster pushes (#71).
- Make sure twistd plugins are installed properly (#76).
- wokkel.component.Router.route now sends back an error if there is no known
route to the stanza's destination.
- Properly encode IDN domain names for establishing client and server
connections. This resolves an issue with Twisted 12.3.0 that made it
impossible to initiate any connection using Wokkel (#77).
Deprecations
------------
- wokkel.xmppim.RosterItem.jid is deprecated in favor of entity (#71).
- wokkel.xmppim.RosterItem.ask is deprecated in favor of pendingOut (#71).
- wokkel.xmppim.RosterClientProtocol.onRosterSet is deprecated in favor of
setReceived (#71).
- wokkel.xmppim.RosterClientProtocol.onRosterRemove is deprecated in favor
of removeReceived (#71).
0.7.0 (2012-01-23)
==================
Features
--------
- Added method wokkel.data_form.Form.typeCheck for type checking incoming Data
Forms submissions against field definitions.
- Added method wokkel.data_form.Form.makeFields to add fields from a
dictionary mapping field names to values.
- Added public function wokkel.data_form.findForm for extracting Data Forms
from stanzas.
- PubSubRequest.options is now a wokkel.data_form.Form.
- wokkel.data_form.Form can now be used as a read-only dictionary.
- Added support for configuration options in Publish-Subscribe node create
requests.
- Added support for subscription options in Publish-Subscribe subscribe
requests (#63).
- Added support for Publish Subscribe subscription identifiers.
- wokkel.pubsub.Item can now be used to send out notifications, too.
- Added a twistd plugin to set up a basic XMPP server that accepts component
connections and provides server-to-server (dialback) connectivity.
- Added support for managing affiliations of Publish-Subscribe nodes,
server-side.
- Added iq request (set/get) tracking to StreamManager and provide a new base
class for such requests: wokkel.generic.Request. Unlike
twisted.words.protocols.jabber.xmlstream.IQ, Such requests can be queued
until the connection is initialized, with timeouts running from the moment
`request` was called (instead of when it was sent over the wire).
- Added support for Delayed Delivery information formats.
- Added support for XMPP Multi-User Chat, client side (#24).
Fixes
-----
- XMPP Ping handler now marks incoming ping requests as handled, so the
FallbackHandler doesn't respond, too. (#66)
- Incorporate Twisted changes for component password hashes.
- Completed test coverage for Data Forms.
- Made sure Data Forms field labels don't get overwritten (#60).
- Service Discovery identity is now reported correctly for legacy
PubSubService use (#64).
- Various smaller Service Discovery fixes for PubSubService.
- Completed test coverage for Service Discovery support.
- Publish Subscribe events with stanza type error are now ignored (#69).
- Publish Subscribe requests with multiple 'verbs' are now properly parsed
(#72).
- Publish Subscribe requests that have no legacy support in PubSubService will
now result in a feature-not-implemented error (#70).
- Publish Subscribe subscription elements now have the correct namespace when
sent out.
- Incorporated Twisted changes for passing on a reason Failure upon stream
disconnect.
- Fixed race condition and nesting issues when adding subprotocol handlers to
their StreamManager (#48).
- Reimplemented Service Discovery requests using new Request class. By reusing
common code, this fixes a problem with requests without addressing (#73).
Deprecations
------------
- wokkel.compat.BootstrapMixin is deprecated in favor of
twisted.words.xish.xmlstream.BootstrapMixin (Twisted 8.2.0).
- wokkel.compat.XmlStreamServerFactory is deprecated in favor of
twisted.words.protocols.jabber.xmlstream.XmlStreamServerFactory (Twisted
8.2.0).
- wokkel.iwokkel.IXMPPHandler is deprecated in favor of
twisted.words.protocols.jabber.ijabber.IXMPPHandler (Twisted 8.1.0).
- wokkel.iwokkel.IXMPPHandlerCollection is deprecated in favor of
twisted.words.protocols.jabber.ijabber.IXMPPHandlerCollection (Twisted
8.1.0).
- wokkel.subprotocols.XMPPHandlerCollection is deprecated in favor of
twisted.words.protocols.jabber.xmlstream.XMPPHandlerCollection (Twisted
8.1.0).
0.6.3 (2009-08-20)
==================
Features
--------
- Add a jid attribute to XMPPClient (#18).
- Add a better presence protocol handler PresenceProtocol. This handler
is also useful for component or in-server use.
Fixes
-----
- Use fallback port 5222 for failed SRV lookups for clients (#26).
0.6.2 (2009-07-08)
==================
Features
--------
- Add support for XMPP Ping (XEP-0199), doubling as example protocol
handler (#55).
- Provide examples for setting up clients, components and servers (#55).
- Make Service Discovery support accept non-deferred results from getDiscoInfo
and getDiscoItems (#55).
0.6.1 (2009-07-06)
==================
Features
--------
- Add an optional sender parameter for Service Discovery requests (#52).
Fixes:
------
- Fix regression in DeferredClientFactory (#51).
- Make IQ timeouts work with InternalComponent (#53).
0.6.0 (2009-04-22)
==================
Features
--------
- Server-to-server support, based on the dialback protocol (#33).
- Enhancement to InternalProtocol to support multiple domains (#43).
- Publish-subscribe request abstraction (#45).
- Publish-subscribe abstraction to implement a node in code (#47).
- Enhancement to PubSubClient to send requests from a specific JID (#46).
Fixes
-----
- Remove type interpretation in Data Forms field parsing code (#44).
0.5.0 (2009-04-07)
==================
This release drops support for Twisted versions older than 8.0, including
Twisted 2.5 / Twisted Words 0.5.
Features
--------
- Support for sending and receiving Publish-Subscribe node delete
notifications with redirect.
- Service Discovery client support, including an overhaul of disco data
classes (#28).
- Initial support for building XMPP servers has been added:
- XmlStreamServerFactory has been backported from Twisted Words (#29).
- An XMPP router has been added (#30).
- A server-side component authenticator has been added (#30).
- A new server-side component service, that connects to a router within the
same process, was added (#31).
Fixes
-----
- Publish-Subscribe subscriptions requests work again (#22).
- Publish-Subscribe delete node requests now have the correct namespace (#27).
- NodeIDs in Service Discovery requests are now returned in responses (#7).
- The presence of stanzaType in toResponse is now checked correctly (#34).
- Data Form fields are now rendered depending on form type (#40).
- Data Form type checking issues were addressed (#41).
- Some compatibility fixes for Twisted 8.0 and 8.1.
- Various other fixes (#37, #42) and tracking changes to code already in
Twisted.
0.4.0 (2008-08-05)
==================
- Refactoring of Data Forms support (#13).
- Added support for Stanza Headers and Internet Metadata (SHIM) (#14).
- API change for PubSubClient's methods called upon event reception (#14).
- Added client-side support for removing roster items.
- Implement type checking for data forms (#15).
- Added support for publish-subscribe collections:
- Correct handling for the root node (empty node identifier).
- Send out SHIM 'Collection' header when appropriate.
- New Subscription class for working with subscriptions.
- API change for PubSubService:
- The subscribe method returns a deferred that fires a Subscription
- The subscriptions method returns a deferred that fires a list of
Subscriptions.
- notifyPublish's notifications parameter now expects a list of tuples
that includes a list of subscriptions.
- Added PubSubService.notifyDelete to allow sending out node deletion
notifications.
0.3.1 (2008-04-22)
==================
- Fix broken version request handler.
0.3.0 (2008-04-21)
==================
First release.
wokkel-0.7.1/LICENSE 0000664 0001750 0001750 00000002046 11707274572 014630 0 ustar ralphm ralphm 0000000 0000000 Copyright (c) 2003-2012 Ralph Meijer.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
wokkel-0.7.1/wokkel/ 0000775 0001750 0001750 00000000000 12074346436 015112 5 ustar ralphm ralphm 0000000 0000000 wokkel-0.7.1/wokkel/formats.py 0000775 0001750 0001750 00000006624 11707274572 017155 0 ustar ralphm ralphm 0000000 0000000 # Copyright (c) Ralph Meijer.
# See LICENSE for details.
NS_MOOD = 'http://jabber.org/protocol/mood'
NS_TUNE = 'http://jabber.org/protocol/tune'
class Mood:
"""
User mood.
This represents a user's mood, as defined in
U{XEP-0107}.
@ivar value: The mood value.
@ivar text: The optional natural-language description of, or reason
for the mood.
"""
def __init__(self, value, text=None):
self.value = value
self.text = text
def fromXml(self, element):
"""
Get a Mood instance from an XML representation.
This class method parses the given XML document into a L{Mood}
instances.
@param element: The XML mood document.
@type element: object providing
L{IElement}
@return: A L{Mood} instance or C{None} if C{element} was not a mood
document or if there was no mood value element.
"""
if element.uri != NS_MOOD or element.name != 'mood':
return None
value = None
text = None
for child in element.elements():
if child.uri != NS_MOOD:
continue
if child.name == 'text':
text = unicode(child)
else:
value = child.name
if value:
return Mood(value, text)
else:
return None
fromXml = classmethod(fromXml)
class Tune:
"""
User tune.
This represents a user's mood, as defined in
U{XEP-0118}.
@ivar artist: The artist or performer of the song or piece.
@type artist: C{unicode}
@ivar length: The duration of the song or piece in seconds.
@type length: C{int}
@ivar source: The collection (e.g. album) or other source.
@type source: C{unicode}
@ivar title: The title of the song or piece
@type title: C{unicode}
@ivar track: A unique identifier for the tune; e.g. the track number within
the collection or the specific URI for the object.
@type track: C{unicode}
@ivar uri: A URI pointing to information about the song, collection, or
artist.
@type uri: C{str}
"""
artist = None
length = None
source = None
title = None
track = None
uri = None
def fromXml(self, element):
"""
Get a Tune instance from an XML representation.
This class method parses the given XML document into a L{Tune}
instances.
@param element: The XML tune document.
@type element: object providing
L{IElement}
@return: A L{Tune} instance or C{None} if C{element} was not a tune
document.
"""
if element.uri != NS_TUNE or element.name != 'tune':
return None
tune = Tune()
for child in element.elements():
if child.uri != NS_TUNE:
continue
if child.name in ('artist', 'source', 'title', 'track', 'uri'):
setattr(tune, child.name, unicode(child))
elif child.name == 'length':
try:
tune.length = int(unicode(child))
except ValueError:
pass
return tune
fromXml = classmethod(fromXml)
wokkel-0.7.1/wokkel/delay.py 0000664 0001750 0001750 00000006256 11707265272 016573 0 ustar ralphm ralphm 0000000 0000000 # -*- test-case-name: wokkel.test.test_delay -*-
#
# Copyright (c) Ralph Meijer.
# See LICENSE for details.
"""
Delayed Delivery.
Support for comunicating Delayed Delivery information as specified by
U{XEP-0203} and its predecessor
U{XEP-0091}.
"""
from dateutil.parser import parse
from dateutil.tz import tzutc
from twisted.words.protocols.jabber.jid import InvalidFormat, JID
from twisted.words.xish import domish
NS_DELAY = 'urn:xmpp:delay'
NS_JABBER_DELAY = 'jabber:x:delay'
class Delay(object):
"""
Delayed Delivery information.
Instances of this class represent delayed delivery information that can be
parsed from and rendered into both XEP-0203 and legacy XEP-0091 formats.
@ivar stamp: The timestamp the stanza was originally sent.
@type stamp: L{datetime.datetime}
@ivar sender: The optional entity that originally sent the stanza or
delayed its delivery.
@type sender: L{JID}
"""
def __init__(self, stamp, sender=None):
self.stamp = stamp
self.sender = sender
def toElement(self, legacy=False):
"""
Render this instance into a domish Element.
@param legacy: If C{True}, use the legacy XEP-0091 format.
@type legacy: C{bool}
"""
if not self.stamp:
raise ValueError("stamp is required")
if self.stamp.tzinfo is None:
raise ValueError("stamp is not offset-aware")
if legacy:
element = domish.Element((NS_JABBER_DELAY, 'x'))
stampFormat = '%Y%m%dT%H:%M:%S'
else:
element = domish.Element((NS_DELAY, 'delay'))
stampFormat = '%Y-%m-%dT%H:%M:%SZ'
stamp = self.stamp.astimezone(tzutc())
element['stamp'] = stamp.strftime(stampFormat)
if self.sender:
element['from'] = self.sender.full()
return element
@staticmethod
def fromElement(element):
"""
Create an instance from a domish Element.
"""
try:
stamp = parse(element[u'stamp'])
# Assume UTC if no timezone was given
if stamp.tzinfo is None:
stamp = stamp.replace(tzinfo=tzutc())
except (KeyError, ValueError):
stamp = None
try:
sender = JID(element[u'from'])
except (KeyError, InvalidFormat):
sender = None
delay = Delay(stamp, sender)
return delay
class DelayMixin(object):
"""
Mixin for parsing delayed delivery information from stanzas.
This can be used as a mixin for subclasses of L{wokkel.generic.Stanza}
for parsing delayed delivery information. If both XEP-0203 and XEP-0091
formats are present, the former takes precedence.
"""
delay = None
childParsers = {
(NS_DELAY, 'delay'): '_childParser_delay',
(NS_JABBER_DELAY, 'x'): '_childParser_legacyDelay',
}
def _childParser_delay(self, element):
self.delay = Delay.fromElement(element)
def _childParser_legacyDelay(self, element):
if not self.delay:
self.delay = Delay.fromElement(element)
wokkel-0.7.1/wokkel/component.py 0000775 0001750 0001750 00000031512 12020400527 017452 0 ustar ralphm ralphm 0000000 0000000 # -*- test-case-name: wokkel.test.test_component -*-
#
# Copyright (c) Ralph Meijer.
# See LICENSE for details.
"""
XMPP External Component utilities.
"""
from twisted.application import service
from twisted.internet import reactor
from twisted.python import log
from twisted.words.protocols.jabber.jid import internJID as JID
from twisted.words.protocols.jabber import component, error, xmlstream
from twisted.words.xish import domish
from wokkel.generic import XmlPipe
from wokkel.subprotocols import StreamManager
NS_COMPONENT_ACCEPT = 'jabber:component:accept'
class Component(StreamManager, service.Service):
"""
XMPP External Component service.
This service is a XMPP stream manager that connects as an External
Component to an XMPP server, as described in
U{XEP-0114}.
"""
def __init__(self, host, port, jid, password):
self.host = host
self.port = port
factory = component.componentFactory(jid, password)
StreamManager.__init__(self, factory)
def _authd(self, xs):
"""
Called when stream initialization has completed.
This replaces the C{send} method of the C{XmlStream} instance
that represents the current connection so that outgoing stanzas
always have a from attribute set to the JID of the component.
"""
old_send = xs.send
def send(obj):
if domish.IElement.providedBy(obj) and \
not obj.getAttribute('from'):
obj['from'] = self.xmlstream.thisEntity.full()
old_send(obj)
xs.send = send
StreamManager._authd(self, xs)
def initializationFailed(self, reason):
"""
Called when stream initialization has failed.
Stop the service (thereby disconnecting the current stream) and
raise the exception.
"""
self.stopService()
reason.raiseException()
def startService(self):
"""
Start the service and connect to the server.
"""
service.Service.startService(self)
self._connection = self._getConnection()
def stopService(self):
"""
Stop the service, close the connection and prevent reconnects.
"""
service.Service.stopService(self)
self.factory.stopTrying()
self._connection.disconnect()
def _getConnection(self):
"""
Create a connector that connects to the server.
"""
return reactor.connectTCP(self.host, self.port, self.factory)
class InternalComponent(xmlstream.XMPPHandlerCollection, service.Service):
"""
Component service that connects directly to a router.
Instead of opening a socket to connect to a router, like L{Component},
components of this type connect to a router in the same process. This
allows for one-process XMPP servers.
@ivar domains: Domains (as C{str}) this component will handle traffic for.
@type domains: C{set}
"""
def __init__(self, router, domain=None):
xmlstream.XMPPHandlerCollection.__init__(self)
self._router = router
self.domains = set()
if domain:
self.domains.add(domain)
self.xmlstream = None
def startService(self):
"""
Create a XML pipe, connect to the router and setup handlers.
"""
service.Service.startService(self)
self._pipe = XmlPipe()
self.xmlstream = self._pipe.source
for domain in self.domains:
self._router.addRoute(domain, self._pipe.sink)
for e in self:
e.makeConnection(self.xmlstream)
e.connectionInitialized()
def stopService(self):
"""
Disconnect from the router and handlers.
"""
service.Service.stopService(self)
for domain in self.domains:
self._router.removeRoute(domain, self._pipe.sink)
self._pipe = None
self.xmlstream = None
for e in self:
e.connectionLost(None)
def addHandler(self, handler):
"""
Add a new handler and connect it to the stream.
"""
xmlstream.XMPPHandlerCollection.addHandler(self, handler)
if self.xmlstream:
handler.makeConnection(self.xmlstream)
handler.connectionInitialized()
def send(self, obj):
"""
Send data to the XML stream, so it ends up at the router.
"""
self.xmlstream.send(obj)
class ListenComponentAuthenticator(xmlstream.ListenAuthenticator):
"""
Authenticator for accepting components.
@ivar secret: The shared used to authorized incoming component connections.
@type secret: C{unicode}.
"""
namespace = NS_COMPONENT_ACCEPT
def __init__(self, secret):
self.secret = secret
xmlstream.ListenAuthenticator.__init__(self)
def associateWithStream(self, xs):
"""
Associate the authenticator with a stream.
This sets the stream's version to 0.0, because the XEP-0114 component
protocol was not designed for XMPP 1.0.
"""
xs.version = (0, 0)
xmlstream.ListenAuthenticator.associateWithStream(self, xs)
def streamStarted(self, rootElement):
"""
Called by the stream when it has started.
This examines the default namespace of the incoming stream and whether
there is a requested hostname for the component. Then it generates a
stream identifier, sends a response header and adds an observer for
the first incoming element, triggering L{onElement}.
"""
xmlstream.ListenAuthenticator.streamStarted(self, rootElement)
# Compatibility fix for pre-8.2 implementations of ListenAuthenticator
if not self.xmlstream.sid:
from twisted.python import randbytes
self.xmlstream.sid = randbytes.secureRandom(8).encode('hex')
if rootElement.defaultUri != self.namespace:
exc = error.StreamError('invalid-namespace')
self.xmlstream.sendStreamError(exc)
return
# self.xmlstream.thisEntity is set to the address the component
# wants to assume.
if not self.xmlstream.thisEntity:
exc = error.StreamError('improper-addressing')
self.xmlstream.sendStreamError(exc)
return
self.xmlstream.sendHeader()
self.xmlstream.addOnetimeObserver('/*', self.onElement)
def onElement(self, element):
"""
Called on incoming XML Stanzas.
The very first element received should be a request for handshake.
Otherwise, the stream is dropped with a 'not-authorized' error. If a
handshake request was received, the hash is extracted and passed to
L{onHandshake}.
"""
if (element.uri, element.name) == (self.namespace, 'handshake'):
self.onHandshake(unicode(element))
else:
exc = error.StreamError('not-authorized')
self.xmlstream.sendStreamError(exc)
def onHandshake(self, handshake):
"""
Called upon receiving the handshake request.
This checks that the given hash in C{handshake} is equal to a
calculated hash, responding with a handshake reply or a stream error.
If the handshake was ok, the stream is authorized, and XML Stanzas may
be exchanged.
"""
calculatedHash = xmlstream.hashPassword(self.xmlstream.sid,
unicode(self.secret))
if handshake != calculatedHash:
exc = error.StreamError('not-authorized', text='Invalid hash')
self.xmlstream.sendStreamError(exc)
else:
self.xmlstream.send('')
self.xmlstream.dispatch(self.xmlstream,
xmlstream.STREAM_AUTHD_EVENT)
class Router(object):
"""
XMPP Server's Router.
A router connects the different components of the XMPP service and routes
messages between them based on the given routing table.
Connected components are trusted to have correct addressing in the
stanzas they offer for routing.
A route destination of C{None} adds a default route. Traffic for which no
specific route exists, will be routed to this default route.
@ivar routes: Routes based on the host part of JIDs. Maps host names to the
L{EventDispatcher}s that
should receive the traffic. A key of C{None} means the default route.
@type routes: C{dict}
"""
def __init__(self):
self.routes = {}
def addRoute(self, destination, xs):
"""
Add a new route.
The passed XML Stream C{xs} will have an observer for all stanzas
added to route its outgoing traffic. In turn, traffic for
C{destination} will be passed to this stream.
@param destination: Destination of the route to be added as a host name
or C{None} for the default route.
@type destination: C{str} or C{NoneType}
@param xs: XML Stream to register the route for.
@type xs:
L{EventDispatcher}
"""
self.routes[destination] = xs
xs.addObserver('/*', self.route)
def removeRoute(self, destination, xs):
"""
Remove a route.
@param destination: Destination of the route that should be removed.
@type destination: C{str}.
@param xs: XML Stream to remove the route for.
@type xs:
L{EventDispatcher}
"""
xs.removeObserver('/*', self.route)
if (xs == self.routes[destination]):
del self.routes[destination]
def route(self, stanza):
"""
Route a stanza.
@param stanza: The stanza to be routed.
@type stanza: L{domish.Element}.
"""
destination = JID(stanza['to'])
if destination.host in self.routes:
log.msg("Routing to %s: %r" % (destination.full(),
stanza.toXml()))
self.routes[destination.host].send(stanza)
elif None in self.routes:
log.msg("Routing to %s (default route): %r" % (destination.full(),
stanza.toXml()))
self.routes[None].send(stanza)
else:
log.msg("No route to %s: %r" % (destination.full(),
stanza.toXml()))
if stanza.getAttribute('type') not in ('result', 'error'):
# No route, send back error
exc = error.StanzaError('remote-server-timeout', type='wait')
exc.code = '504'
response = exc.toResponse(stanza)
self.route(response)
class XMPPComponentServerFactory(xmlstream.XmlStreamServerFactory):
"""
XMPP Component Server factory.
This factory accepts XMPP external component connections and makes
the router service route traffic for a component's bound domain
to that component.
"""
logTraffic = False
def __init__(self, router, secret='secret'):
self.router = router
self.secret = secret
def authenticatorFactory():
return ListenComponentAuthenticator(self.secret)
xmlstream.XmlStreamServerFactory.__init__(self, authenticatorFactory)
self.addBootstrap(xmlstream.STREAM_CONNECTED_EVENT,
self.makeConnection)
self.addBootstrap(xmlstream.STREAM_AUTHD_EVENT,
self.connectionInitialized)
self.serial = 0
def makeConnection(self, xs):
"""
Called when a component connection was made.
This enables traffic debugging on incoming streams.
"""
xs.serial = self.serial
self.serial += 1
def logDataIn(buf):
log.msg("RECV (%d): %r" % (xs.serial, buf))
def logDataOut(buf):
log.msg("SEND (%d): %r" % (xs.serial, buf))
if self.logTraffic:
xs.rawDataInFn = logDataIn
xs.rawDataOutFn = logDataOut
xs.addObserver(xmlstream.STREAM_ERROR_EVENT, self.onError)
def connectionInitialized(self, xs):
"""
Called when a component has succesfully authenticated.
Add the component to the routing table and establish a handler
for a closed connection.
"""
destination = xs.thisEntity.host
self.router.addRoute(destination, xs)
xs.addObserver(xmlstream.STREAM_END_EVENT, self.connectionLost, 0,
destination, xs)
def onError(self, reason):
log.err(reason, "Stream Error")
def connectionLost(self, destination, xs, reason):
self.router.removeRoute(destination, xs)
wokkel-0.7.1/wokkel/componentservertap.py 0000775 0001750 0001750 00000004330 11707215356 021423 0 ustar ralphm ralphm 0000000 0000000 # Copyright (c) Ralph Meijer.
# See LICENSE for details.
"""
XMPP Component Service.
This provides an XMPP server that accepts External Components connections
and accepts and initiates server-to-server connections for the specified
domain(s).
"""
from twisted.application import service, strports
from twisted.python import usage
from twisted.words.protocols.jabber import component
from wokkel import server
class Options(usage.Options):
optParameters = [
('component-port', None, 'tcp:5347:interface=127.0.0.1',
'Port components connect to'),
('component-secret', None, 'secret',
'Secret components use to connect'),
('server-port', None, 'tcp:5269',
'Port other servers connect to'),
('server-secret', None, None,
'Shared secret for dialback verification'),
]
optFlags = [
('verbose', 'v', 'Log traffic'),
]
def __init__(self):
usage.Options.__init__(self)
self['domains'] = set()
def opt_domain(self, domain):
"""
Domain to accept server connections for. Repeat for more domains.
"""
self['domains'].add(domain)
def postOptions(self):
if not self['domains']:
raise usage.UsageError('Need at least one domain')
def makeService(config):
s = service.MultiService()
router = component.Router()
# Set up the XMPP server service
serverService = server.ServerService(router, secret=config['server-secret'])
serverService.domains = config['domains']
serverService.logTraffic = config['verbose']
# Hook up XMPP server-to-server service
s2sFactory = server.XMPPS2SServerFactory(serverService)
s2sFactory.logTraffic = config['verbose']
s2sService = strports.service(config['server-port'], s2sFactory)
s2sService.setServiceParent(s)
# Hook up XMPP external server-side component service
cFactory = component.XMPPComponentServerFactory(router,
config['component-secret'])
cFactory.logTraffic = config['verbose']
cServer = strports.service(config['component-port'], cFactory)
cServer.setServiceParent(s)
return s
wokkel-0.7.1/wokkel/server.py 0000775 0001750 0001750 00000056455 12074267765 017023 0 ustar ralphm ralphm 0000000 0000000 # -*- test-case-name: wokkel.test.test_server -*-
#
# Copyright (c) Ralph Meijer.
# See LICENSE for details.
"""
XMPP Server-to-Server protocol.
This module implements several aspects of XMPP server-to-server communications
as described in XMPP Core (RFC 3920). Refer to that document for the meaning
of the used terminology.
"""
# hashlib is new in Python 2.5, try that first.
try:
from hashlib import sha256
digestmod = sha256
except ImportError:
import Crypto.Hash.SHA256 as digestmod
sha256 = digestmod.new
import hmac
from zope.interface import implements
from twisted.internet import defer, reactor
from twisted.names.srvconnect import SRVConnector
from twisted.python import log, randbytes
from twisted.words.protocols.jabber import error, ijabber, jid, xmlstream
from twisted.words.xish import domish
from wokkel.generic import DeferredXmlStreamFactory, XmlPipe, prepareIDNName
NS_DIALBACK = 'jabber:server:dialback'
def generateKey(secret, receivingServer, originatingServer, streamID):
"""
Generate a dialback key for server-to-server XMPP Streams.
The dialback key is generated using the algorithm described in
U{XEP-0185}. The used
terminology for the parameters is described in RFC-3920.
@param secret: the shared secret known to the Originating Server and
Authoritive Server.
@type secret: C{str}
@param receivingServer: the Receiving Server host name.
@type receivingServer: C{str}
@param originatingServer: the Originating Server host name.
@type originatingServer: C{str}
@param streamID: the Stream ID as generated by the Receiving Server.
@type streamID: C{str}
@return: hexadecimal digest of the generated key.
@type: C{str}
"""
hashObject = sha256()
hashObject.update(secret)
hashedSecret = hashObject.hexdigest()
message = " ".join([receivingServer, originatingServer, streamID])
hash = hmac.HMAC(hashedSecret, message, digestmod=digestmod)
return hash.hexdigest()
def trapStreamError(xs, observer):
"""
Trap stream errors.
This wraps an observer to catch exceptions. In case of a
L{error.StreamError}, it is send over the given XML stream. All other
exceptions yield a C{'internal-server-error'} stream error, that is
sent over the stream, while the exception is logged.
@return: Wrapped observer
"""
def wrappedObserver(element):
try:
observer(element)
except error.StreamError, exc:
xs.sendStreamError(exc)
except:
log.err()
exc = error.StreamError('internal-server-error')
xs.sendStreamError(exc)
return wrappedObserver
class XMPPServerConnector(SRVConnector):
def __init__(self, reactor, domain, factory):
SRVConnector.__init__(self, reactor, 'xmpp-server', domain, factory)
def pickServer(self):
host, port = SRVConnector.pickServer(self)
if not self.servers and not self.orderedServers:
# no SRV record, fall back..
port = 5269
return host, port
class DialbackFailed(Exception):
pass
class OriginatingDialbackInitializer(object):
"""
Server Dialback Initializer for the Orginating Server.
"""
implements(ijabber.IInitiatingInitializer)
_deferred = None
def __init__(self, xs, thisHost, otherHost, secret):
self.xmlstream = xs
self.thisHost = thisHost
self.otherHost = otherHost
self.secret = secret
def initialize(self):
self._deferred = defer.Deferred()
self.xmlstream.addObserver(xmlstream.STREAM_ERROR_EVENT,
self.onStreamError)
self.xmlstream.addObserver("/result[@xmlns='%s']" % NS_DIALBACK,
self.onResult)
key = generateKey(self.secret, self.otherHost,
self.thisHost, self.xmlstream.sid)
result = domish.Element((NS_DIALBACK, 'result'))
result['from'] = self.thisHost
result['to'] = self.otherHost
result.addContent(key)
self.xmlstream.send(result)
return self._deferred
def onResult(self, result):
self.xmlstream.removeObserver(xmlstream.STREAM_ERROR_EVENT,
self.onStreamError)
if result['type'] == 'valid':
self.xmlstream.otherEntity = jid.internJID(self.otherHost)
self._deferred.callback(None)
else:
self._deferred.errback(DialbackFailed())
def onStreamError(self, failure):
self.xmlstream.removeObserver("/result[@xmlns='%s']" % NS_DIALBACK,
self.onResult)
self._deferred.errback(failure)
class ReceivingDialbackInitializer(object):
"""
Server Dialback Initializer for the Receiving Server.
"""
implements(ijabber.IInitiatingInitializer)
_deferred = None
def __init__(self, xs, thisHost, otherHost, originalStreamID, key):
self.xmlstream = xs
self.thisHost = thisHost
self.otherHost = otherHost
self.originalStreamID = originalStreamID
self.key = key
def initialize(self):
self._deferred = defer.Deferred()
self.xmlstream.addObserver(xmlstream.STREAM_ERROR_EVENT,
self.onStreamError)
self.xmlstream.addObserver("/verify[@xmlns='%s']" % NS_DIALBACK,
self.onVerify)
verify = domish.Element((NS_DIALBACK, 'verify'))
verify['from'] = self.thisHost
verify['to'] = self.otherHost
verify['id'] = self.originalStreamID
verify.addContent(self.key)
self.xmlstream.send(verify)
return self._deferred
def onVerify(self, verify):
self.xmlstream.removeObserver(xmlstream.STREAM_ERROR_EVENT,
self.onStreamError)
if verify['id'] != self.originalStreamID:
self.xmlstream.sendStreamError(error.StreamError('invalid-id'))
self._deferred.errback(DialbackFailed())
elif verify['to'] != self.thisHost:
self.xmlstream.sendStreamError(error.StreamError('host-unknown'))
self._deferred.errback(DialbackFailed())
elif verify['from'] != self.otherHost:
self.xmlstream.sendStreamError(error.StreamError('invalid-from'))
self._deferred.errback(DialbackFailed())
elif verify['type'] == 'valid':
self._deferred.callback(None)
else:
self._deferred.errback(DialbackFailed())
def onStreamError(self, failure):
self.xmlstream.removeObserver("/verify[@xmlns='%s']" % NS_DIALBACK,
self.onVerify)
self._deferred.errback(failure)
class XMPPServerConnectAuthenticator(xmlstream.ConnectAuthenticator):
"""
Authenticator for an outgoing XMPP server-to-server connection.
This authenticator connects to C{otherHost} (the Receiving Server) and then
initiates dialback as C{thisHost} (the Originating Server) using
L{OriginatingDialbackInitializer}.
@ivar thisHost: The domain this server connects from (the Originating
Server) .
@ivar otherHost: The domain of the server this server connects to (the
Receiving Server).
@ivar secret: The shared secret that is used for verifying the validity
of this new connection.
"""
namespace = 'jabber:server'
def __init__(self, thisHost, otherHost, secret):
self.thisHost = thisHost
self.otherHost = otherHost
self.secret = secret
xmlstream.ConnectAuthenticator.__init__(self, otherHost)
def connectionMade(self):
self.xmlstream.thisEntity = jid.internJID(self.thisHost)
self.xmlstream.prefixes = {xmlstream.NS_STREAMS: 'stream',
NS_DIALBACK: 'db'}
xmlstream.ConnectAuthenticator.connectionMade(self)
def associateWithStream(self, xs):
xmlstream.ConnectAuthenticator.associateWithStream(self, xs)
init = OriginatingDialbackInitializer(xs, self.thisHost,
self.otherHost, self.secret)
xs.initializers = [init]
class XMPPServerVerifyAuthenticator(xmlstream.ConnectAuthenticator):
"""
Authenticator for an outgoing connection to verify an incoming connection.
This authenticator connects to C{otherHost} (the Authoritative Server) and
then initiates dialback as C{thisHost} (the Receiving Server) using
L{ReceivingDialbackInitializer}.
@ivar thisHost: The domain this server connects from (the Receiving
Server) .
@ivar otherHost: The domain of the server this server connects to (the
Authoritative Server).
@ivar originalStreamID: The stream ID of the incoming connection that is
being verified.
@ivar key: The key provided by the Receving Server to be verified.
"""
namespace = 'jabber:server'
def __init__(self, thisHost, otherHost, originalStreamID, key):
self.thisHost = thisHost
self.otherHost = otherHost
self.originalStreamID = originalStreamID
self.key = key
xmlstream.ConnectAuthenticator.__init__(self, otherHost)
def connectionMade(self):
self.xmlstream.thisEntity = jid.internJID(self.thisHost)
self.xmlstream.prefixes = {xmlstream.NS_STREAMS: 'stream',
NS_DIALBACK: 'db'}
xmlstream.ConnectAuthenticator.connectionMade(self)
def associateWithStream(self, xs):
xmlstream.ConnectAuthenticator.associateWithStream(self, xs)
init = ReceivingDialbackInitializer(xs, self.thisHost, self.otherHost,
self.originalStreamID, self.key)
xs.initializers = [init]
class XMPPServerListenAuthenticator(xmlstream.ListenAuthenticator):
"""
Authenticator for an incoming XMPP server-to-server connection.
This authenticator handles two types of incoming connections. Regular
server-to-server connections are from the Originating Server to the
Receiving Server, where this server is the Receiving Server. These
connections start out by receiving a dialback key, verifying the
key with the Authoritative Server, and then accept normal XMPP stanzas.
The other type of connections is from a Receiving Server to an
Authoritative Server, where this server acts as the Authoritative Server.
These connections are used to verify the validity of an outgoing connection
from this server. In this case, this server receives a verification
request, checks the key and then returns the result.
@ivar service: The service that keeps the list of domains we accept
connections for.
"""
namespace = 'jabber:server'
def __init__(self, service):
xmlstream.ListenAuthenticator.__init__(self)
self.service = service
def streamStarted(self, rootElement):
xmlstream.ListenAuthenticator.streamStarted(self, rootElement)
# Compatibility fix for pre-8.2 implementations of ListenAuthenticator
if not self.xmlstream.sid:
self.xmlstream.sid = randbytes.secureRandom(8).encode('hex')
if self.xmlstream.thisEntity:
targetDomain = self.xmlstream.thisEntity.host
else:
targetDomain = self.service.defaultDomain
def prepareStream(domain):
self.xmlstream.namespace = self.namespace
self.xmlstream.prefixes = {xmlstream.NS_STREAMS: 'stream',
NS_DIALBACK: 'db'}
if domain:
self.xmlstream.thisEntity = jid.internJID(domain)
try:
if xmlstream.NS_STREAMS != rootElement.uri or \
self.namespace != self.xmlstream.namespace or \
('db', NS_DIALBACK) not in rootElement.localPrefixes.iteritems():
raise error.StreamError('invalid-namespace')
if targetDomain and targetDomain not in self.service.domains:
raise error.StreamError('host-unknown')
except error.StreamError, exc:
prepareStream(self.service.defaultDomain)
self.xmlstream.sendStreamError(exc)
return
self.xmlstream.addObserver("//verify[@xmlns='%s']" % NS_DIALBACK,
trapStreamError(self.xmlstream,
self.onVerify))
self.xmlstream.addObserver("//result[@xmlns='%s']" % NS_DIALBACK,
self.onResult)
prepareStream(targetDomain)
self.xmlstream.sendHeader()
if self.xmlstream.version >= (1, 0):
features = domish.Element((xmlstream.NS_STREAMS, 'features'))
self.xmlstream.send(features)
def onVerify(self, verify):
try:
receivingServer = jid.JID(verify['from']).host
originatingServer = jid.JID(verify['to']).host
except (KeyError, jid.InvalidFormat):
raise error.StreamError('improper-addressing')
if originatingServer not in self.service.domains:
raise error.StreamError('host-unknown')
if (self.xmlstream.otherEntity and
receivingServer != self.xmlstream.otherEntity.host):
raise error.StreamError('invalid-from')
streamID = verify.getAttribute('id', '')
key = unicode(verify)
calculatedKey = generateKey(self.service.secret, receivingServer,
originatingServer, streamID)
validity = (key == calculatedKey) and 'valid' or 'invalid'
reply = domish.Element((NS_DIALBACK, 'verify'))
reply['from'] = originatingServer
reply['to'] = receivingServer
reply['id'] = streamID
reply['type'] = validity
self.xmlstream.send(reply)
def onResult(self, result):
def reply(validity):
reply = domish.Element((NS_DIALBACK, 'result'))
reply['from'] = result['to']
reply['to'] = result['from']
reply['type'] = validity
self.xmlstream.send(reply)
def valid(xs):
reply('valid')
if not self.xmlstream.thisEntity:
self.xmlstream.thisEntity = jid.internJID(receivingServer)
self.xmlstream.otherEntity = jid.internJID(originatingServer)
self.xmlstream.dispatch(self.xmlstream,
xmlstream.STREAM_AUTHD_EVENT)
def invalid(failure):
log.err(failure)
reply('invalid')
receivingServer = result['to']
originatingServer = result['from']
key = unicode(result)
d = self.service.validateConnection(receivingServer, originatingServer,
self.xmlstream.sid, key)
d.addCallbacks(valid, invalid)
return d
class DeferredS2SClientFactory(DeferredXmlStreamFactory):
"""
Deferred firing factory for initiating XMPP server-to-server connection.
The deferred has its callbacks called upon succesful authentication with
the other server. In case of failed authentication or connection, the
deferred will have its errbacks called instead.
"""
logTraffic = False
def __init__(self, authenticator):
DeferredXmlStreamFactory.__init__(self, authenticator)
self.addBootstrap(xmlstream.STREAM_CONNECTED_EVENT,
self.onConnectionMade)
self.serial = 0
def onConnectionMade(self, xs):
xs.serial = self.serial
self.serial += 1
def logDataIn(buf):
log.msg("RECV (%d): %r" % (xs.serial, buf))
def logDataOut(buf):
log.msg("SEND (%d): %r" % (xs.serial, buf))
if self.logTraffic:
xs.rawDataInFn = logDataIn
xs.rawDataOutFn = logDataOut
def initiateS2S(factory):
domain = prepareIDNName(factory.authenticator.otherHost)
c = XMPPServerConnector(reactor, domain, factory)
c.connect()
return factory.deferred
class XMPPS2SServerFactory(xmlstream.XmlStreamServerFactory):
"""
XMPP Server-to-Server Server factory.
This factory accepts XMPP server-to-server connections.
"""
logTraffic = False
def __init__(self, service):
self.service = service
def authenticatorFactory():
return XMPPServerListenAuthenticator(service)
xmlstream.XmlStreamServerFactory.__init__(self, authenticatorFactory)
self.addBootstrap(xmlstream.STREAM_CONNECTED_EVENT,
self.onConnectionMade)
self.addBootstrap(xmlstream.STREAM_AUTHD_EVENT,
self.onAuthenticated)
self.serial = 0
def onConnectionMade(self, xs):
"""
Called when a server-to-server connection was made.
This enables traffic debugging on incoming streams.
"""
xs.serial = self.serial
self.serial += 1
def logDataIn(buf):
log.msg("RECV (%d): %r" % (xs.serial, buf))
def logDataOut(buf):
log.msg("SEND (%d): %r" % (xs.serial, buf))
if self.logTraffic:
xs.rawDataInFn = logDataIn
xs.rawDataOutFn = logDataOut
xs.addObserver(xmlstream.STREAM_ERROR_EVENT, self.onError)
def onAuthenticated(self, xs):
thisHost = xs.thisEntity.host
otherHost = xs.otherEntity.host
log.msg("Incoming connection %d from %r to %r established" %
(xs.serial, otherHost, thisHost))
xs.addObserver(xmlstream.STREAM_END_EVENT, self.onConnectionLost,
0, xs)
xs.addObserver('/*', self.onElement, 0, xs)
def onConnectionLost(self, xs, reason):
thisHost = xs.thisEntity.host
otherHost = xs.otherEntity.host
log.msg("Incoming connection %d from %r to %r disconnected" %
(xs.serial, otherHost, thisHost))
def onError(self, reason):
log.err(reason, "Stream Error")
def onElement(self, xs, element):
"""
Called when an element was received from one of the connected streams.
"""
if element.handled:
return
else:
self.service.dispatch(xs, element)
class ServerService(object):
"""
Service for managing XMPP server to server connections.
"""
logTraffic = False
def __init__(self, router, domain=None, secret=None):
self.router = router
self.defaultDomain = domain
self.domains = set()
if self.defaultDomain:
self.domains.add(self.defaultDomain)
if secret is not None:
self.secret = secret
else:
self.secret = randbytes.secureRandom(16).encode('hex')
self._outgoingStreams = {}
self._outgoingQueues = {}
self._outgoingConnecting = set()
self.serial = 0
pipe = XmlPipe()
self.xmlstream = pipe.source
self.router.addRoute(None, pipe.sink)
self.xmlstream.addObserver('/*', self.send)
def outgoingInitialized(self, xs):
thisHost = xs.thisEntity.host
otherHost = xs.otherEntity.host
log.msg("Outgoing connection %d from %r to %r established" %
(xs.serial, thisHost, otherHost))
self._outgoingStreams[thisHost, otherHost] = xs
xs.addObserver(xmlstream.STREAM_END_EVENT,
lambda _: self.outgoingDisconnected(xs))
if (thisHost, otherHost) in self._outgoingQueues:
for element in self._outgoingQueues[thisHost, otherHost]:
xs.send(element)
del self._outgoingQueues[thisHost, otherHost]
def outgoingDisconnected(self, xs):
thisHost = xs.thisEntity.host
otherHost = xs.otherEntity.host
log.msg("Outgoing connection %d from %r to %r disconnected" %
(xs.serial, thisHost, otherHost))
del self._outgoingStreams[thisHost, otherHost]
def initiateOutgoingStream(self, thisHost, otherHost):
"""
Initiate an outgoing XMPP server-to-server connection.
"""
def resetConnecting(_):
self._outgoingConnecting.remove((thisHost, otherHost))
if (thisHost, otherHost) in self._outgoingConnecting:
return
authenticator = XMPPServerConnectAuthenticator(thisHost,
otherHost,
self.secret)
factory = DeferredS2SClientFactory(authenticator)
factory.addBootstrap(xmlstream.STREAM_AUTHD_EVENT,
self.outgoingInitialized)
factory.logTraffic = self.logTraffic
self._outgoingConnecting.add((thisHost, otherHost))
d = initiateS2S(factory)
d.addBoth(resetConnecting)
return d
def validateConnection(self, thisHost, otherHost, sid, key):
"""
Validate an incoming XMPP server-to-server connection.
"""
def connected(xs):
# Set up stream for immediate disconnection.
def disconnect(_):
xs.transport.loseConnection()
xs.addObserver(xmlstream.STREAM_AUTHD_EVENT, disconnect)
xs.addObserver(xmlstream.INIT_FAILED_EVENT, disconnect)
authenticator = XMPPServerVerifyAuthenticator(thisHost, otherHost,
sid, key)
factory = DeferredS2SClientFactory(authenticator)
factory.addBootstrap(xmlstream.STREAM_CONNECTED_EVENT, connected)
factory.logTraffic = self.logTraffic
d = initiateS2S(factory)
return d
def send(self, stanza):
"""
Send stanza to the proper XML Stream.
This uses addressing embedded in the stanza to find the correct stream
to forward the stanza to.
"""
otherHost = jid.internJID(stanza["to"]).host
thisHost = jid.internJID(stanza["from"]).host
if (thisHost, otherHost) not in self._outgoingStreams:
# There is no connection with the destination (yet). Cache the
# outgoing stanza until the connection has been established.
# XXX: If the connection cannot be established, the queue should
# be emptied at some point.
if (thisHost, otherHost) not in self._outgoingQueues:
self._outgoingQueues[(thisHost, otherHost)] = []
self._outgoingQueues[(thisHost, otherHost)].append(stanza)
self.initiateOutgoingStream(thisHost, otherHost)
else:
self._outgoingStreams[(thisHost, otherHost)].send(stanza)
def dispatch(self, xs, stanza):
"""
Send on element to be routed within the server.
"""
stanzaFrom = stanza.getAttribute('from')
stanzaTo = stanza.getAttribute('to')
if not stanzaFrom or not stanzaTo:
xs.sendStreamError(error.StreamError('improper-addressing'))
else:
try:
sender = jid.internJID(stanzaFrom)
jid.internJID(stanzaTo)
except jid.InvalidFormat:
log.msg("Dropping error stanza with malformed JID")
if sender.host != xs.otherEntity.host:
xs.sendStreamError(error.StreamError('invalid-from'))
else:
self.xmlstream.send(stanza)
wokkel-0.7.1/wokkel/iwokkel.py 0000775 0001750 0001750 00000106600 12074262111 017122 0 ustar ralphm ralphm 0000000 0000000 # -*- test-case-name: wokkel.test.test_iwokkel -*-
#
# Copyright (c) Ralph Meijer.
# See LICENSE for details.
"""
Wokkel interfaces.
"""
__all__ = ['IXMPPHandler', 'IXMPPHandlerCollection',
'IPubSubClient', 'IPubSubService', 'IPubSubResource',
'IMUCClient', 'IMUCStatuses']
from zope.interface import Interface
from twisted.python.deprecate import deprecatedModuleAttribute
from twisted.python.versions import Version
from twisted.words.protocols.jabber.ijabber import IXMPPHandler
from twisted.words.protocols.jabber.ijabber import IXMPPHandlerCollection
deprecatedModuleAttribute(
Version("Wokkel", 0, 7, 0),
"Use twisted.words.protocols.jabber.ijabber.IXMPPHandler instead.",
__name__,
"IXMPPHandler")
deprecatedModuleAttribute(
Version("Wokkel", 0, 7, 0),
"Use twisted.words.protocols.jabber.ijabber.IXMPPHandlerCollection "
"instead.",
__name__,
"IXMPPHandlerCollection")
class IDisco(Interface):
"""
Interface for XMPP service discovery.
"""
def getDiscoInfo(requestor, target, nodeIdentifier=''):
"""
Get identity and features from this entity, node.
@param requestor: The entity the request originated from.
@type requestor: L{JID}
@param target: The target entity to which the request is made.
@type target: L{JID}
@param nodeIdentifier: The optional identifier of the node at this
entity to retrieve the identify and features of. The default is
C{''}, meaning the root node.
@type nodeIdentifier: C{unicode}
"""
def getDiscoItems(requestor, target, nodeIdentifier=''):
"""
Get contained items for this entity, node.
@param requestor: The entity the request originated from.
@type requestor: L{JID}
@param target: The target entity to which the request is made.
@type target: L{JID}
@param nodeIdentifier: The optional identifier of the node at this
entity to retrieve the identify and features of.
The default is C{''}, meaning the root node.
@type nodeIdentifier: C{unicode}
"""
class IPubSubClient(Interface):
def itemsReceived(event):
"""
Called when an items notification has been received for a node.
An item can be an element named C{item} or C{retract}. Respectively,
they signal an item being published or retracted, optionally
accompanied with an item identifier in the C{id} attribute.
@param event: The items event.
@type event: L{ItemsEvent}
"""
def deleteReceived(event):
"""
Called when a deletion notification has been received for a node.
@param event: The items event.
@type event: L{ItemsEvent}
"""
def purgeReceived(event):
"""
Called when a purge notification has been received for a node.
Upon receiving this notification all items associated should be
considered retracted.
@param event: The items event.
@type event: L{ItemsEvent}
"""
def createNode(service, nodeIdentifier=None):
"""
Create a new publish subscribe node.
@param service: The publish-subscribe service entity.
@type service: L{JID}
@param nodeIdentifier: Optional suggestion for the new node's
identifier. If omitted, the creation of an
instant node will be attempted.
@type nodeIdentifier: C{unicode}
@return: a deferred that fires with the identifier of the newly created
node. Note that this can differ from the suggested identifier
if the publish subscribe service chooses to modify or ignore
the suggested identifier.
@rtype: L{Deferred}
"""
def deleteNode(service, nodeIdentifier):
"""
Delete a node.
@param service: The publish-subscribe service entity.
@type service: L{JID}
@param nodeIdentifier: Identifier of the node to be deleted.
@type nodeIdentifier: C{unicode}
@rtype: L{Deferred}
"""
def subscribe(service, nodeIdentifier, subscriber):
"""
Subscribe to a node with a given JID.
@param service: The publish-subscribe service entity.
@type service: L{JID}
@param nodeIdentifier: Identifier of the node to subscribe to.
@type nodeIdentifier: C{unicode}
@param subscriber: JID to subscribe to the node.
@type subscriber: L{JID}
@rtype: L{Deferred}
"""
def unsubscribe(service, nodeIdentifier, subscriber):
"""
Unsubscribe from a node with a given JID.
@param service: The publish-subscribe service entity.
@type service: L{JID}
@param nodeIdentifier: Identifier of the node to unsubscribe from.
@type nodeIdentifier: C{unicode}
@param subscriber: JID to unsubscribe from the node.
@type subscriber: L{JID}
@rtype: L{Deferred}
"""
def publish(service, nodeIdentifier, items=[]):
"""
Publish to a node.
Node that the C{items} parameter is optional, because so-called
transient, notification-only nodes do not use items and publish
actions only signify a change in some resource.
@param service: The publish-subscribe service entity.
@type service: L{JID}
@param nodeIdentifier: Identifier of the node to publish to.
@type nodeIdentifier: C{unicode}
@param items: List of item elements.
@type items: C{list} of L{Item}
@rtype: L{Deferred}
"""
class IPubSubService(Interface):
"""
Interface for an XMPP Publish Subscribe Service.
All methods that are called as the result of an XMPP request are to
return a deferred that fires when the requested action has been performed.
Alternatively, exceptions maybe raised directly or by calling C{errback}
on the returned deferred.
"""
def notifyPublish(service, nodeIdentifier, notifications):
"""
Send out notifications for a publish event.
@param service: The entity the notifications will originate from.
@type service: L{JID}
@param nodeIdentifier: The identifier of the node that was published
to.
@type nodeIdentifier: C{unicode}
@param notifications: The notifications as tuples of subscriber, the
list of subscriptions and the list of items to be notified.
@type notifications: C{list} of
(L{JID}, C{list} of
L{Subscription}, C{list} of
L{Element})
"""
def notifyDelete(service, nodeIdentifier, subscribers,
redirectURI=None):
"""
Send out node deletion notifications.
@param service: The entity the notifications will originate from.
@type service: L{JID}
@param nodeIdentifier: The identifier of the node that was deleted.
@type nodeIdentifier: C{unicode}
@param subscribers: The subscribers for which a notification should be
sent out.
@type subscribers: C{list} of
L{JID}
@param redirectURI: Optional XMPP URI of another node that subscribers
are redirected to.
@type redirectURI: C{str}
"""
def publish(requestor, service, nodeIdentifier, items):
"""
Called when a publish request has been received.
@param requestor: The entity the request originated from.
@type requestor: L{JID}
@param service: The entity the request was addressed to.
@type service: L{JID}
@param nodeIdentifier: The identifier of the node to publish to.
@type nodeIdentifier: C{unicode}
@param items: The items to be published as elements.
@type items: C{list} of C{Element}
@return: deferred that fires on success.
@rtype: L{Deferred}
"""
def subscribe(requestor, service, nodeIdentifier, subscriber):
"""
Called when a subscribe request has been received.
@param requestor: The entity the request originated from.
@type requestor: L{JID}
@param service: The entity the request was addressed to.
@type service: L{JID}
@param nodeIdentifier: The identifier of the node to subscribe to.
@type nodeIdentifier: C{unicode}
@param subscriber: The entity to be subscribed.
@type subscriber: L{JID}
@return: A deferred that fires with a
L{Subscription}.
@rtype: L{Deferred}
"""
def unsubscribe(requestor, service, nodeIdentifier, subscriber):
"""
Called when a subscribe request has been received.
@param requestor: The entity the request originated from.
@type requestor: L{JID}
@param service: The entity the request was addressed to.
@type service: L{JID}
@param nodeIdentifier: The identifier of the node to unsubscribe from.
@type nodeIdentifier: C{unicode}
@param subscriber: The entity to be unsubscribed.
@type subscriber: L{JID}
@return: A deferred that fires with C{None} when unsubscription has
succeeded.
@rtype: L{Deferred}
"""
def subscriptions(requestor, service):
"""
Called when a subscriptions retrieval request has been received.
@param requestor: The entity the request originated from.
@type requestor: L{JID}
@param service: The entity the request was addressed to.
@type service: L{JID}
@return: A deferred that fires with a C{list} of subscriptions as
L{Subscription}.
@rtype: L{Deferred}
"""
def affiliations(requestor, service):
"""
Called when a affiliations retrieval request has been received.
@param requestor: The entity the request originated from.
@type requestor: L{JID}
@param service: The entity the request was addressed to.
@type service: L{JID}
@return: A deferred that fires with a C{list} of affiliations as
C{tuple}s of (node identifier as C{unicode}, affiliation state as
C{str}). The affiliation can be C{'owner'}, C{'publisher'}, or
C{'outcast'}.
@rtype: L{Deferred}
"""
def create(requestor, service, nodeIdentifier):
"""
Called when a node creation request has been received.
@param requestor: The entity the request originated from.
@type requestor: L{JID}
@param service: The entity the request was addressed to.
@type service: L{JID}
@param nodeIdentifier: The suggestion for the identifier of the node
to be created. If the request did not include a suggestion for the
node identifier, the value is C{None}.
@type nodeIdentifier: C{unicode} or C{NoneType}
@return: A deferred that fires with a C{unicode} that represents
the identifier of the new node.
@rtype: L{Deferred}
"""
def getConfigurationOptions():
"""
Retrieve all known node configuration options.
The returned dictionary holds the possible node configuration options
by option name. The value of each entry represents the specifics for
that option in a dictionary:
- C{'type'} (C{str}): The option's type (see
L{Field}'s doc string for possible values).
- C{'label'} (C{unicode}): A human readable label for this option.
- C{'options'} (C{dict}): Optional list of possible values for this
option.
Example::
{
"pubsub#persist_items":
{"type": "boolean",
"label": "Persist items to storage"},
"pubsub#deliver_payloads":
{"type": "boolean",
"label": "Deliver payloads with event notifications"},
"pubsub#send_last_published_item":
{"type": "list-single",
"label": "When to send the last published item",
"options": {
"never": "Never",
"on_sub": "When a new subscription is processed"}
}
}
@rtype: C{dict}.
"""
def getDefaultConfiguration(requestor, service, nodeType):
"""
Called when a default node configuration request has been received.
@param requestor: The entity the request originated from.
@type requestor: L{JID}
@param service: The entity the request was addressed to.
@type service: L{JID}
@param nodeType: The type of node for which the configuration is
retrieved, C{'leaf'} or C{'collection'}.
@type nodeType: C{str}
@return: A deferred that fires with a C{dict} representing the default
node configuration. Keys are C{str}s that represent the
field name. Values can be of types C{unicode}, C{int} or
C{bool}.
@rtype: L{Deferred}
"""
def getConfiguration(requestor, service, nodeIdentifier):
"""
Called when a node configuration retrieval request has been received.
@param requestor: The entity the request originated from.
@type requestor: L{JID}
@param service: The entity the request was addressed to.
@type service: L{JID}
@param nodeIdentifier: The identifier of the node to retrieve the
configuration from.
@type nodeIdentifier: C{unicode}
@return: A deferred that fires with a C{dict} representing the node
configuration. Keys are C{str}s that represent the field name.
Values can be of types C{unicode}, C{int} or C{bool}.
@rtype: L{Deferred}
"""
def setConfiguration(requestor, service, nodeIdentifier, options):
"""
Called when a node configuration change request has been received.
@param requestor: The entity the request originated from.
@type requestor: L{JID}
@param service: The entity the request was addressed to.
@type service: L{JID}
@param nodeIdentifier: The identifier of the node to change the
configuration of.
@type nodeIdentifier: C{unicode}
@return: A deferred that fires with C{None} when the node's
configuration has been changed.
@rtype: L{Deferred}
"""
def items(requestor, service, nodeIdentifier, maxItems, itemIdentifiers):
"""
Called when a items retrieval request has been received.
@param requestor: The entity the request originated from.
@type requestor: L{JID}
@param service: The entity the request was addressed to.
@type service: L{JID}
@param nodeIdentifier: The identifier of the node to retrieve items
from.
@type nodeIdentifier: C{unicode}
"""
def retract(requestor, service, nodeIdentifier, itemIdentifiers):
"""
Called when a item retraction request has been received.
@param requestor: The entity the request originated from.
@type requestor: L{JID}
@param service: The entity the request was addressed to.
@type service: L{JID}
@param nodeIdentifier: The identifier of the node to retract items
from.
@type nodeIdentifier: C{unicode}
"""
def purge(requestor, service, nodeIdentifier):
"""
Called when a node purge request has been received.
@param requestor: The entity the request originated from.
@type requestor: L{JID}
@param service: The entity the request was addressed to.
@type service: L{JID}
@param nodeIdentifier: The identifier of the node to be purged.
@type nodeIdentifier: C{unicode}
"""
def delete(requestor, service, nodeIdentifier):
"""
Called when a node deletion request has been received.
@param requestor: The entity the request originated from.
@type requestor: L{JID}
@param service: The entity the request was addressed to.
@type service: L{JID}
@param nodeIdentifier: The identifier of the node to be delete.
@type nodeIdentifier: C{unicode}
"""
class IPubSubResource(Interface):
def locateResource(request):
"""
Locate a resource that will handle the request.
@param request: The publish-subscribe request.
@type request: L{wokkel.pubsub.PubSubRequest}
"""
def getInfo(requestor, service, nodeIdentifier):
"""
Get node type and meta data.
@param requestor: The entity the request originated from.
@type requestor: L{JID}
@param service: The publish-subscribe service entity.
@type service: L{JID}
@param nodeIdentifier: Identifier of the node to request the info for.
@type nodeIdentifier: C{unicode}
@return: A deferred that fires with a dictionary. If not empty,
it must have the keys C{'type'} and C{'meta-data'} to keep
respectively the node type and a dictionary with the meta
data for that node.
@rtype: L{Deferred}
"""
def getNodes(requestor, service, nodeIdentifier):
"""
Get all nodes contained by this node.
@param requestor: The entity the request originated from.
@type requestor: L{JID}
@param service: The publish-subscribe service entity.
@type service: L{JID}
@param nodeIdentifier: Identifier of the node to request the childs
for.
@type nodeIdentifier: C{unicode}
@return: A deferred that fires with a list of child node identifiers.
@rtype: L{Deferred}
"""
def getConfigurationOptions():
"""
Retrieve all known node configuration options.
The returned dictionary holds the possible node configuration options
by option name. The value of each entry represents the specifics for
that option in a dictionary:
- C{'type'} (C{str}): The option's type (see
L{Field}'s doc string for possible values).
- C{'label'} (C{unicode}): A human readable label for this option.
- C{'options'} (C{dict}): Optional list of possible values for this
option.
Example::
{
"pubsub#persist_items":
{"type": "boolean",
"label": "Persist items to storage"},
"pubsub#deliver_payloads":
{"type": "boolean",
"label": "Deliver payloads with event notifications"},
"pubsub#send_last_published_item":
{"type": "list-single",
"label": "When to send the last published item",
"options": {
"never": "Never",
"on_sub": "When a new subscription is processed"}
}
}
@rtype: C{dict}.
"""
def publish(request):
"""
Called when a publish request has been received.
@param request: The publish-subscribe request.
@type request: L{wokkel.pubsub.PubSubRequest}
@return: deferred that fires on success.
@rtype: L{Deferred}
"""
def subscribe(request):
"""
Called when a subscribe request has been received.
@param request: The publish-subscribe request.
@type request: L{wokkel.pubsub.PubSubRequest}
@return: A deferred that fires with a
L{Subscription}.
@rtype: L{Deferred}
"""
def unsubscribe(request):
"""
Called when a subscribe request has been received.
@param request: The publish-subscribe request.
@type request: L{wokkel.pubsub.PubSubRequest}
@return: A deferred that fires with C{None} when unsubscription has
succeeded.
@rtype: L{Deferred}
"""
def subscriptions(request):
"""
Called when a subscriptions retrieval request has been received.
@param request: The publish-subscribe request.
@type request: L{wokkel.pubsub.PubSubRequest}
@return: A deferred that fires with a C{list} of subscriptions as
L{Subscription}.
@rtype: L{Deferred}
"""
def affiliations(request):
"""
Called when a affiliations retrieval request has been received.
@param request: The publish-subscribe request.
@type request: L{wokkel.pubsub.PubSubRequest}
@return: A deferred that fires with a C{list} of affiliations as
C{tuple}s of (node identifier as C{unicode}, affiliation state as
C{str}). The affiliation can be C{'owner'}, C{'publisher'}, or
C{'outcast'}.
@rtype: L{Deferred}
"""
def create(request):
"""
Called when a node creation request has been received.
@param request: The publish-subscribe request.
@type request: L{wokkel.pubsub.PubSubRequest}
@return: A deferred that fires with a C{unicode} that represents
the identifier of the new node.
@rtype: L{Deferred}
"""
def default(request):
"""
Called when a default node configuration request has been received.
@param request: The publish-subscribe request.
@type request: L{wokkel.pubsub.PubSubRequest}
@return: A deferred that fires with a C{dict} representing the default
node configuration. Keys are C{str}s that represent the
field name. Values can be of types C{unicode}, C{int} or
C{bool}.
@rtype: L{Deferred}
"""
def configureGet(request):
"""
Called when a node configuration retrieval request has been received.
@param request: The publish-subscribe request.
@type request: L{wokkel.pubsub.PubSubRequest}
@return: A deferred that fires with a C{dict} representing the node
configuration. Keys are C{str}s that represent the field name.
Values can be of types C{unicode}, C{int} or C{bool}.
@rtype: L{Deferred}
"""
def configureSet(request):
"""
Called when a node configuration change request has been received.
@param request: The publish-subscribe request.
@type request: L{wokkel.pubsub.PubSubRequest}
@return: A deferred that fires with C{None} when the node's
configuration has been changed.
@rtype: L{Deferred}
"""
def items(request):
"""
Called when a items retrieval request has been received.
@param request: The publish-subscribe request.
@type request: L{wokkel.pubsub.PubSubRequest}
@return: A deferred that fires with a C{list} of L{pubsub.Item}.
@rtype: L{Deferred}
"""
def retract(request):
"""
Called when a item retraction request has been received.
@param request: The publish-subscribe request.
@type request: L{wokkel.pubsub.PubSubRequest}
@return: A deferred that fires with C{None} when the given items have
been retracted.
@rtype: L{Deferred}
"""
def purge(request):
"""
Called when a node purge request has been received.
@param request: The publish-subscribe request.
@type request: L{wokkel.pubsub.PubSubRequest}
@return: A deferred that fires with C{None} when the node has been
purged.
@rtype: L{Deferred}
"""
def delete(request):
"""
Called when a node deletion request has been received.
@param request: The publish-subscribe request.
@type request: L{wokkel.pubsub.PubSubRequest}
@return: A deferred that fires with C{None} when the node has been
deleted.
@rtype: L{Deferred}
"""
def affiliationsGet(request):
"""
Called when an owner affiliations retrieval request been received.
@param request: The publish-subscribe request.
@type request: L{wokkel.pubsub.PubSubRequest}
@return: A deferred that fires with a C{dict} of affiliations with the
entity as key (L{JID}) and
the affiliation state as value (C{unicode}). The affiliation can
be C{u'owner'}, C{u'publisher'}, or C{u'outcast'}.
@rtype: L{Deferred}
@note: Affiliations are always on the bare JID. An implementation of
this method MUST NOT return JIDs with a resource part.
"""
def affiliationsSet(request):
"""
Called when a affiliations modify request has been received.
@param request: The publish-subscribe request.
@type request: L{wokkel.pubsub.PubSubRequest}
@return: A deferred that fires with C{None} when the affiliation
changes were succesfully processed..
@rtype: L{Deferred}
@note: Affiliations are always on the bare JID. The JIDs in
L{wokkel.pubsub.PubSubRequest}'s C{affiliations} attribute are
already stripped of any resource.
"""
class IMUCClient(Interface):
"""
Multi-User Chat Client.
A client interface to XEP-045 : http://xmpp.org/extensions/xep-0045.html
"""
def receivedSubject(room, user, subject):
"""
The room subject has been received.
A subject is received when you join a room and when the subject is
changed.
@param room: The room the subject was accepted for.
@type room: L{muc.Room}
@param user: The user that set the subject.
@type user: L{muc.User}
@param subject: The subject of the given room.
@type subject: C{unicode}
"""
def receivedHistory(room, user, message):
"""
Past messages from a chat room have been received.
This occurs when you join a room.
"""
def configure(roomJID, options):
"""
Configure a room.
@param roomJID: The room to configure.
@type roomJID: L{JID}
@param options: A mapping of field names to values, or C{None} to
cancel.
@type options: C{dict}
"""
def getConfiguration(roomJID):
"""
Grab the configuration from the room.
This sends an iq request to the room.
@param roomJID: The bare JID of the room.
@type roomJID: L{JID}
@return: A deferred that fires with the room's configuration form as
a L{data_form.Form} or C{None} if there are no configuration
options available.
"""
def join(roomJID, nick, historyOptions=None, password=None):
"""
Join a MUC room by sending presence to it.
@param roomJID: The JID of the room the entity is joining.
@type roomJID: L{JID}
@param nick: The nick name for the entitity joining the room.
@type nick: C{unicode}
@param historyOptions: Options for conversation history sent by the
room upon joining.
@type historyOptions: L{HistoryOptions}
@param password: Optional password for the room.
@type password: C{unicode}
@return: A deferred that fires when the entity is in the room or an
error has occurred.
"""
def nick(roomJID, nick):
"""
Change an entity's nick name in a MUC room.
See: http://xmpp.org/extensions/xep-0045.html#changenick
@param roomJID: The JID of the room, i.e. without a resource.
@type roomJID: L{JID}
@param nick: The new nick name within the room.
@type nick: C{unicode}
"""
def leave(roomJID):
"""
Leave a MUC room.
See: http://xmpp.org/extensions/xep-0045.html#exit
@param roomJID: The Room JID of the room to leave.
@type roomJID: L{JID}
"""
def userJoinedRoom(room, user):
"""
User has joined a MUC room.
This method will need to be modified inorder for clients to
do something when this event occurs.
@param room: The room the user joined.
@type room: L{muc.Room}
@param user: The user that joined the room.
@type user: L{muc.User}
"""
def groupChat(roomJID, body):
"""
Send a groupchat message.
"""
def chat(occupantJID, body):
"""
Send a private chat message to a user in a MUC room.
See: http://xmpp.org/extensions/xep-0045.html#privatemessage
@param occupantJID: The Room JID of the other user.
@type occupantJID: L{JID}
"""
def register(roomJID, options):
"""
Send a request to register for a room.
@param roomJID: The bare JID of the room.
@type roomJID: L{JID}
@param options: A mapping of field names to values, or C{None} to
cancel.
@type options: C{dict}
"""
def subject(roomJID, subject):
"""
Change the subject of a MUC room.
See: http://xmpp.org/extensions/xep-0045.html#subject-mod
@param roomJID: The bare JID of the room.
@type roomJID: L{JID}
@param subject: The subject you want to set.
@type subject: C{unicode}
"""
def voice(roomJID):
"""
Request voice for a moderated room.
@param roomJID: The room jabber/xmpp entity id.
@type roomJID: L{JID}
"""
def history(roomJID, messages):
"""
Send history to create a MUC based on a one on one chat.
See: http://xmpp.org/extensions/xep-0045.html#continue
@param roomJID: The room jabber/xmpp entity id.
@type roomJID: L{JID}
@param messages: The history to send to the room as an ordered list of
message, represented by a dictionary with the keys C{'stanza'},
holding the original stanza a
L{Element}, and C{'timestamp'}
with the timestamp.
@type messages: C{list} of
L{Element}
"""
def ban(roomJID, entity, reason=None, sender=None):
"""
Ban a user from a MUC room.
@param roomJID: The bare JID of the room.
@type roomJID: L{JID}
@param entity: The bare JID of the entity to be banned.
@type entity: L{JID}
@param reason: The reason for banning the entity.
@type reason: C{unicode}
@param sender: The entity sending the request.
@type sender: L{JID}
"""
def kick(roomJID, nick, reason=None, sender=None):
"""
Kick a user from a MUC room.
@param roomJID: The bare JID of the room.
@type roomJID: L{JID}
@param nick: The occupant to be banned.
@type nick: L{JID} or
C{unicode}
@param reason: The reason given for the kick.
@type reason: C{unicode}
@param sender: The entity sending the request.
@type sender: L{JID}
"""
class IMUCStatuses(Interface):
"""
Interface for a container of Multi-User Chat status conditions.
"""
def __contains__(key):
"""
Return if a status exists in the container.
"""
def __iter__():
"""
Return an iterator over the status codes.
"""
def __len__():
"""
Return the number of status conditions.
"""
wokkel-0.7.1/wokkel/generic.py 0000775 0001750 0001750 00000024232 12074265150 017077 0 ustar ralphm ralphm 0000000 0000000 # -*- test-case-name: wokkel.test.test_generic -*-
#
# Copyright (c) Ralph Meijer.
# See LICENSE for details.
"""
Generic XMPP protocol helpers.
"""
from encodings import idna
from zope.interface import implements
from twisted.internet import defer, protocol
from twisted.python import reflect
from twisted.words.protocols.jabber import error, jid, xmlstream
from twisted.words.protocols.jabber.xmlstream import toResponse
from twisted.words.xish import domish, utility
from twisted.words.xish.xmlstream import BootstrapMixin
from wokkel.iwokkel import IDisco
from wokkel.subprotocols import XMPPHandler
IQ_GET = '/iq[@type="get"]'
IQ_SET = '/iq[@type="set"]'
NS_VERSION = 'jabber:iq:version'
VERSION = IQ_GET + '/query[@xmlns="' + NS_VERSION + '"]'
def parseXml(string):
"""
Parse serialized XML into a DOM structure.
@param string: The serialized XML to be parsed, UTF-8 encoded.
@type string: C{str}.
@return: The DOM structure, or C{None} on empty or incomplete input.
@rtype: L{domish.Element}
"""
roots = []
results = []
elementStream = domish.elementStream()
elementStream.DocumentStartEvent = roots.append
elementStream.ElementEvent = lambda elem: roots[0].addChild(elem)
elementStream.DocumentEndEvent = lambda: results.append(roots[0])
elementStream.parse(string)
return results and results[0] or None
def stripNamespace(rootElement):
namespace = rootElement.uri
def strip(element):
if element.uri == namespace:
element.uri = None
if element.defaultUri == namespace:
element.defaultUri = None
for child in element.elements():
strip(child)
if namespace is not None:
strip(rootElement)
return rootElement
class FallbackHandler(XMPPHandler):
"""
XMPP subprotocol handler that catches unhandled iq requests.
Unhandled iq requests are replied to with a service-unavailable stanza
error.
"""
def connectionInitialized(self):
self.xmlstream.addObserver(IQ_SET, self.iqFallback, -1)
self.xmlstream.addObserver(IQ_GET, self.iqFallback, -1)
def iqFallback(self, iq):
if iq.handled == True:
return
reply = error.StanzaError('service-unavailable')
self.xmlstream.send(reply.toResponse(iq))
class VersionHandler(XMPPHandler):
"""
XMPP subprotocol handler for XMPP Software Version.
This protocol is described in
U{XEP-0092}.
"""
implements(IDisco)
def __init__(self, name, version):
self.name = name
self.version = version
def connectionInitialized(self):
self.xmlstream.addObserver(VERSION, self.onVersion)
def onVersion(self, iq):
response = toResponse(iq, "result")
query = response.addElement((NS_VERSION, "query"))
query.addElement("name", content=self.name)
query.addElement("version", content=self.version)
self.send(response)
iq.handled = True
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 getDiscoItems(self, requestor, target, node):
return defer.succeed([])
class XmlPipe(object):
"""
XML stream pipe.
Connects two objects that communicate stanzas through an XML stream like
interface. Each of the ends of the pipe (sink and source) can be used to
send XML stanzas to the other side, or add observers to process XML stanzas
that were sent from the other side.
XML pipes are usually used in place of regular XML streams that are
transported over TCP. This is the reason for the use of the names source
and sink for both ends of the pipe. The source side corresponds with the
entity that initiated the TCP connection, whereas the sink corresponds with
the entity that accepts that connection. In this object, though, the source
and sink are treated equally.
Unlike Jabber
L{XmlStream}s, the sink
and source objects are assumed to represent an eternal connected and
initialized XML stream. As such, events corresponding to connection,
disconnection, initialization and stream errors are not dispatched or
processed.
@ivar source: Source XML stream.
@ivar sink: Sink XML stream.
"""
def __init__(self):
self.source = utility.EventDispatcher()
self.sink = utility.EventDispatcher()
self.source.send = lambda obj: self.sink.dispatch(obj)
self.sink.send = lambda obj: self.source.dispatch(obj)
class Stanza(object):
"""
Abstract representation of a stanza.
@ivar sender: The sending entity.
@type sender: L{jid.JID}
@ivar recipient: The receiving entity.
@type recipient: L{jid.JID}
"""
recipient = None
sender = None
stanzaKind = None
stanzaID = None
stanzaType = None
def __init__(self, recipient=None, sender=None):
self.recipient = recipient
self.sender = sender
@classmethod
def fromElement(Class, element):
"""
Create a stanza from a L{domish.Element}.
"""
stanza = Class()
stanza.parseElement(element)
return stanza
def parseElement(self, element):
"""
Parse the stanza element.
This is called with the stanza's element when a L{Stanza} is
created using L{fromElement}. It parses the stanza's core attributes
(addressing, type and id), strips the namespace from the stanza
element for easier transport across streams and passes on
child elements for further parsing.
Child element parsers are defined by providing a C{childParsers}
attribute on a subclass, as a mapping from (URI, name) to the name
of the handler on C{self}. C{parseElement} will accumulate
C{childParsers} from its class hierarchy, iterate over the child
elements and pass it to matching handlers based on the child element's
URI and name. The special key of C{None} can be used to pass all
child elements to.
"""
if element.hasAttribute('from'):
self.sender = jid.internJID(element['from'])
if element.hasAttribute('to'):
self.recipient = jid.internJID(element['to'])
self.stanzaType = element.getAttribute('type')
self.stanzaID = element.getAttribute('id')
# Save element
stripNamespace(element)
self.element = element
# accumulate all childHandlers in the class hierarchy of Class
handlers = {}
reflect.accumulateClassDict(self.__class__, 'childParsers', handlers)
for child in element.elements():
try:
handler = handlers[child.uri, child.name]
except KeyError:
try:
handler = handlers[None]
except KeyError:
continue
getattr(self, handler)(child)
def toElement(self):
element = domish.Element((None, self.stanzaKind))
if self.sender is not None:
element['from'] = self.sender.full()
if self.recipient is not None:
element['to'] = self.recipient.full()
if self.stanzaType:
element['type'] = self.stanzaType
if self.stanzaID:
element['id'] = self.stanzaID
return element
class ErrorStanza(Stanza):
def parseElement(self, element):
Stanza.parseElement(self, element)
self.exception = error.exceptionFromStanza(element)
class Request(Stanza):
"""
IQ request stanza.
This is a base class for IQ get or set stanzas, to be used with
L{wokkel.subprotocols.StreamManager.request}.
"""
stanzaKind = 'iq'
stanzaType = 'get'
timeout = None
childParsers = {None: 'parseRequest'}
def __init__(self, recipient=None, sender=None, stanzaType='get'):
Stanza.__init__(self, recipient=recipient, sender=sender)
self.stanzaType = stanzaType
def parseRequest(self, element):
"""
Called with the request's child element for parsing.
When a request instance is created using L{fromElement}, this method
is called with the child element of the iq. Override this method for
parsing the request's payload.
"""
def toElement(self):
element = Stanza.toElement(self)
if not self.stanzaID:
element.addUniqueId()
self.stanzaID = element['id']
return element
class DeferredXmlStreamFactory(BootstrapMixin, protocol.ClientFactory):
protocol = xmlstream.XmlStream
def __init__(self, authenticator):
BootstrapMixin.__init__(self)
self.authenticator = authenticator
deferred = defer.Deferred()
self.deferred = deferred
self.addBootstrap(xmlstream.STREAM_AUTHD_EVENT, self.deferred.callback)
self.addBootstrap(xmlstream.INIT_FAILED_EVENT, deferred.errback)
def buildProtocol(self, addr):
"""
Create an instance of XmlStream.
A new authenticator instance will be created and passed to the new
XmlStream. Registered bootstrap event observers are installed as well.
"""
xs = self.protocol(self.authenticator)
xs.factory = self
self.installBootstraps(xs)
return xs
def clientConnectionFailed(self, connector, reason):
self.deferred.errback(reason)
def prepareIDNName(name):
"""
Encode a unicode IDN Domain Name into its ACE equivalent.
This will encode the domain labels, separated by allowed dot code points,
to their ASCII Compatible Encoding (ACE) equivalent, using punycode. The
result is an ASCII byte string of the encoded labels, separated by the
standard full stop.
"""
result = []
labels = idna.dots.split(name)
if labels and len(labels[-1]) == 0:
trailing_dot = b'.'
del labels[-1]
else:
trailing_dot = b''
for label in labels:
result.append(idna.ToASCII(label))
return b'.'.join(result) + trailing_dot
wokkel-0.7.1/wokkel/client.py 0000775 0001750 0001750 00000012257 12074266455 016756 0 ustar ralphm ralphm 0000000 0000000 # -*- test-case-name: wokkel.test.test_client -*-
#
# Copyright (c) Ralph Meijer.
# See LICENSE for details.
"""
XMPP Client support.
This module holds several improvements on top of Twisted's XMPP support
that should probably eventually move there.
"""
from twisted.application import service
from twisted.internet import reactor
from twisted.names.srvconnect import SRVConnector
from twisted.words.protocols.jabber import client, sasl, xmlstream
from wokkel import generic
from wokkel.subprotocols import StreamManager
class CheckAuthInitializer(object):
"""
Check what authentication methods are available.
"""
def __init__(self, xs):
self.xmlstream = xs
def initialize(self):
if (sasl.NS_XMPP_SASL, 'mechanisms') in self.xmlstream.features:
inits = [(sasl.SASLInitiatingInitializer, True),
(client.BindInitializer, True),
(client.SessionInitializer, False)]
for initClass, required in inits:
init = initClass(self.xmlstream)
init.required = required
self.xmlstream.initializers.append(init)
elif (client.NS_IQ_AUTH_FEATURE, 'auth') in self.xmlstream.features:
self.xmlstream.initializers.append(
client.IQAuthInitializer(self.xmlstream))
else:
raise Exception("No available authentication method found")
class HybridAuthenticator(xmlstream.ConnectAuthenticator):
"""
Initializes an XmlStream connecting to an XMPP server as a Client.
This is similar to L{client.XMPPAuthenticator}, but also tries non-SASL
autentication.
"""
namespace = 'jabber:client'
def __init__(self, jid, password):
xmlstream.ConnectAuthenticator.__init__(self, jid.host)
self.jid = jid
self.password = password
def associateWithStream(self, xs):
xmlstream.ConnectAuthenticator.associateWithStream(self, xs)
tlsInit = xmlstream.TLSInitiatingInitializer(xs)
xs.initializers = [client.CheckVersionInitializer(xs),
tlsInit,
CheckAuthInitializer(xs)]
def HybridClientFactory(jid, password):
"""
Client factory for XMPP 1.0.
This is similar to L{client.XMPPClientFactory} but also tries non-SASL
autentication.
"""
a = HybridAuthenticator(jid, password)
return xmlstream.XmlStreamFactory(a)
class XMPPClient(StreamManager, service.Service):
"""
Service that initiates an XMPP client connection.
"""
def __init__(self, jid, password, host=None, port=5222):
self.jid = jid
self.domain = generic.prepareIDNName(jid.host)
self.host = host
self.port = port
factory = HybridClientFactory(jid, password)
StreamManager.__init__(self, factory)
def startService(self):
service.Service.startService(self)
self._connection = self._getConnection()
def stopService(self):
service.Service.stopService(self)
self.factory.stopTrying()
self._connection.disconnect()
def _authd(self, xs):
"""
Called when the stream has been initialized.
Save the JID that we were assigned by the server, as the resource might
differ from the JID we asked for. This is stored on the authenticator
by its constituent initializers.
"""
self.jid = self.factory.authenticator.jid
StreamManager._authd(self, xs)
def initializationFailed(self, reason):
"""
Called when stream initialization has failed.
Stop the service (thereby disconnecting the current stream) and
raise the exception.
"""
self.stopService()
reason.raiseException()
def _getConnection(self):
if self.host:
return reactor.connectTCP(self.host, self.port, self.factory)
else:
c = XMPPClientConnector(reactor, self.domain, self.factory)
c.connect()
return c
class DeferredClientFactory(generic.DeferredXmlStreamFactory):
def __init__(self, jid, password):
authenticator = client.XMPPAuthenticator(jid, password)
generic.DeferredXmlStreamFactory.__init__(self, authenticator)
self.streamManager = StreamManager(self)
def addHandler(self, handler):
"""
Add a subprotocol handler to the stream manager.
"""
self.streamManager.addHandler(handler)
def removeHandler(self, handler):
"""
Add a subprotocol handler to the stream manager.
"""
self.streamManager.removeHandler(handler)
class XMPPClientConnector(SRVConnector):
def __init__(self, reactor, domain, factory):
SRVConnector.__init__(self, reactor, 'xmpp-client', domain, factory)
def pickServer(self):
host, port = SRVConnector.pickServer(self)
if not self.servers and not self.orderedServers:
# no SRV record, fall back..
port = 5222
return host, port
def clientCreator(factory):
domain = generic.prepareIDNName(factory.authenticator.jid.host)
c = XMPPClientConnector(reactor, domain, factory)
c.connect()
return factory.deferred
wokkel-0.7.1/wokkel/subprotocols.py 0000775 0001750 0001750 00000036405 12074262111 020220 0 ustar ralphm ralphm 0000000 0000000 # -*- test-case-name: wokkel.test.test_subprotocols -*-
#
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.
"""
XMPP subprotocol support.
"""
__all__ = ['XMPPHandler', 'XMPPHandlerCollection', 'StreamManager',
'IQHandlerMixin']
from zope.interface import implements
from twisted.internet import defer
from twisted.internet.error import ConnectionDone
from twisted.python import failure, log
from twisted.python.deprecate import deprecatedModuleAttribute
from twisted.python.versions import Version
from twisted.words.protocols.jabber import error, ijabber, xmlstream
from twisted.words.protocols.jabber.xmlstream import toResponse
from twisted.words.protocols.jabber.xmlstream import XMPPHandlerCollection
from twisted.words.xish import xpath
from twisted.words.xish.domish import IElement
deprecatedModuleAttribute(
Version("Wokkel", 0, 7, 0),
"Use twisted.words.protocols.jabber.xmlstream.XMPPHandlerCollection "
"instead.",
__name__,
"XMPPHandlerCollection")
class XMPPHandler(object):
"""
XMPP protocol handler.
Classes derived from this class implement (part of) one or more XMPP
extension protocols, and are referred to as a subprotocol implementation.
"""
implements(ijabber.IXMPPHandler)
def __init__(self):
self.parent = None
self.xmlstream = None
def setHandlerParent(self, parent):
self.parent = parent
self.parent.addHandler(self)
def disownHandlerParent(self, parent):
self.parent.removeHandler(self)
self.parent = None
def makeConnection(self, xs):
self.xmlstream = xs
self.connectionMade()
def connectionMade(self):
"""
Called after a connection has been established.
Can be overridden to perform work before stream initialization.
"""
def connectionInitialized(self):
"""
The XML stream has been initialized.
Can be overridden to perform work after stream initialization, e.g. to
set up observers and start exchanging XML stanzas.
"""
def connectionLost(self, reason):
"""
The XML stream has been closed.
This method can be extended to inspect the C{reason} argument and
act on it.
"""
self.xmlstream = None
def send(self, obj):
"""
Send data over the managed XML stream.
@note: The stream manager maintains a queue for data sent using this
method when there is no current initialized XML stream. This
data is then sent as soon as a new stream has been established
and initialized. Subsequently, L{connectionInitialized} will be
called again. If this queueing is not desired, use C{send} on
C{self.xmlstream}.
@param obj: data to be sent over the XML stream. This is usually an
object providing L{domish.IElement}, or serialized XML. See
L{xmlstream.XmlStream} for details.
"""
self.parent.send(obj)
def request(self, request):
"""
Send an IQ request and track the response.
This passes the request to the parent for sending and response
tracking.
@see: L{StreamManager.request}.
"""
return self.parent.request(request)
class StreamManager(XMPPHandlerCollection):
"""
Business logic representing a managed XMPP connection.
This maintains a single XMPP connection and provides facilities for packet
routing and transmission. Business logic modules are objects providing
L{IXMPPHandler} (like subclasses of L{XMPPHandler}), and added
using L{addHandler}.
@ivar xmlstream: currently managed XML stream
@type xmlstream: L{XmlStream}
@ivar logTraffic: if true, log all traffic.
@type logTraffic: C{bool}
@ivar _initialized: Whether the stream represented by L{xmlstream} has
been initialized. This is used when caching outgoing
stanzas.
@type _initialized: C{bool}
@ivar _packetQueue: internal buffer of unsent data. See L{send} for details.
@type _packetQueue: L{list}
@ivar timeout: Default IQ request timeout in seconds.
@type timeout: C{int}
@ivar _reactor: A provider of L{IReactorTime} to track timeouts.
"""
timeout = None
_reactor = None
logTraffic = False
def __init__(self, factory, reactor=None):
"""
Construct a stream manager.
@param factory: The stream factory to connect with.
@param reactor: A provider of L{IReactorTime} to track timeouts.
If not provided, the global reactor will be used.
"""
XMPPHandlerCollection.__init__(self)
self.xmlstream = None
self._packetQueue = []
self._initialized = False
factory.addBootstrap(xmlstream.STREAM_CONNECTED_EVENT, self._connected)
factory.addBootstrap(xmlstream.STREAM_AUTHD_EVENT, self._authd)
factory.addBootstrap(xmlstream.INIT_FAILED_EVENT,
self.initializationFailed)
factory.addBootstrap(xmlstream.STREAM_END_EVENT, self._disconnected)
self.factory = factory
if reactor is None:
from twisted.internet import reactor
self._reactor = reactor
# Set up IQ response tracking
self._iqDeferreds = {}
def addHandler(self, handler):
"""
Add protocol handler.
When an XML stream has already been established, the handler's
C{connectionInitialized} will be called to get it up to speed.
"""
XMPPHandlerCollection.addHandler(self, handler)
# get protocol handler up to speed when a connection has already
# been established
if self.xmlstream:
handler.makeConnection(self.xmlstream)
if self._initialized:
handler.connectionInitialized()
def _connected(self, xs):
"""
Called when the transport connection has been established.
Here we optionally set up traffic logging (depending on L{logTraffic})
and call each handler's C{makeConnection} method with the L{XmlStream}
instance.
"""
def logDataIn(buf):
log.msg("RECV: %r" % buf)
def logDataOut(buf):
log.msg("SEND: %r" % buf)
if self.logTraffic:
xs.rawDataInFn = logDataIn
xs.rawDataOutFn = logDataOut
self.xmlstream = xs
for e in list(self):
e.makeConnection(xs)
def _authd(self, xs):
"""
Called when the stream has been initialized.
Send out cached stanzas and call each handler's
C{connectionInitialized} method.
"""
xs.addObserver('/iq[@type="result"]', self._onIQResponse)
xs.addObserver('/iq[@type="error"]', self._onIQResponse)
# Flush all pending packets
for p in self._packetQueue:
xs.send(p)
self._packetQueue = []
self._initialized = True
# Notify all child services which implement
# the IService interface
for e in list(self):
e.connectionInitialized()
def initializationFailed(self, reason):
"""
Called when stream initialization has failed.
Stream initialization has halted, with the reason indicated by
C{reason}. It may be retried by calling the authenticator's
C{initializeStream}. See the respective authenticators for details.
@param reason: A failure instance indicating why stream initialization
failed.
@type reason: L{failure.Failure}
"""
def _disconnected(self, reason):
"""
Called when the stream has been closed.
From this point on, the manager doesn't interact with the
L{XmlStream} anymore and notifies each handler that the connection
was lost by calling its C{connectionLost} method.
"""
self.xmlstream = None
self._initialized = False
# Twisted versions before 11.0 passed an XmlStream here.
if not hasattr(reason, 'trap'):
reason = failure.Failure(ConnectionDone())
# Notify all child services which implement
# the IService interface
for e in list(self):
e.connectionLost(reason)
# This errbacks all deferreds of iq's for which no response has
# been received with a L{ConnectionLost} failure. Otherwise, the
# deferreds will never be fired.
iqDeferreds = self._iqDeferreds
self._iqDeferreds = {}
for d in iqDeferreds.itervalues():
d.errback(reason)
def _onIQResponse(self, iq):
"""
Handle iq response by firing associated deferred.
"""
try:
d = self._iqDeferreds[iq["id"]]
except KeyError:
return
del self._iqDeferreds[iq["id"]]
iq.handled = True
if iq['type'] == 'error':
d.errback(error.exceptionFromStanza(iq))
else:
d.callback(iq)
def send(self, obj):
"""
Send data over the XML stream.
When there is no established XML stream, the data is queued and sent
out when a new XML stream has been established and initialized.
@param obj: data to be sent over the XML stream. See
L{xmlstream.XmlStream.send} for details.
"""
if self._initialized:
self.xmlstream.send(obj)
else:
self._packetQueue.append(obj)
def request(self, request):
"""
Send an IQ request and track the response.
A request is an IQ L{generic.Stanza} of type C{'get'} or C{'set'}. It
will have its C{toElement} called to render to a
L{Element} which is then sent out
over the current stream. If there is no such stream (yet), it is queued
and sent whenever a connection is established and initialized, just
like L{send}.
If the request doesn't have an identifier, it will be assigned a fresh
one, so the response can be tracked.
The deferred that is returned will fire with the
L{Element} representation of the
response if it is a result iq. If the response is an error iq, a
corresponding L{error.StanzaError} will be errbacked.
If the connection is closed before a response was received, the deferred
will be errbacked with the reason failure.
A request may also have a timeout, either by setting a default timeout
in L{StreamManager}'s C{timeout} attribute or on the C{timeout}
attribute of the request.
@param request: The IQ request.
@type request: L{generic.Request}
"""
if (request.stanzaKind != 'iq' or
request.stanzaType not in ('get', 'set')):
return defer.fail(ValueError("Not a request"))
element = request.toElement()
# Make sure we have a trackable id on the stanza
if not request.stanzaID:
element.addUniqueId()
request.stanzaID = element['id']
# Set up iq response tracking
d = defer.Deferred()
self._iqDeferreds[element['id']] = d
timeout = getattr(request, 'timeout', self.timeout)
if timeout is not None:
def onTimeout():
del self._iqDeferreds[element['id']]
d.errback(xmlstream.TimeoutError("IQ timed out"))
call = self._reactor.callLater(timeout, onTimeout)
def cancelTimeout(result):
if call.active():
call.cancel()
return result
d.addBoth(cancelTimeout)
self.send(element)
return d
class IQHandlerMixin(object):
"""
XMPP subprotocol mixin for handle incoming IQ stanzas.
This matches up the iq with XPath queries to call methods on itself,
wrapping the call so that exceptions result in proper error responses,
or, when succesful will reply with a response with optional payload.
Derivatives of this class must provide an
L{XmlStream} instance
in its C{xmlstream} attribute.
The optional payload is taken from the result of the handler and is
expected to be a child or a list of childs.
If an exception is raised, or the deferred has its errback called,
the exception is checked for being a L{error.StanzaError}. If so,
an error response is sent. Any other exception will cause a error
response of C{internal-server-error} to be sent.
A typical way to use this mixin, is to set up L{xpath} observers on the
C{xmlstream} to call handleRequest, for example in an overridden
L{XMPPHandler.connectionMade}. It is likely a good idea to only listen for
incoming iq get and/org iq set requests, and not for any iq, to prevent
hijacking incoming responses to outgoing iq requests. An example:
>>> QUERY_ROSTER = "/query[@xmlns='jabber:iq:roster']"
>>> class MyHandler(XMPPHandler, IQHandlerMixin):
... iqHandlers = {"/iq[@type='get']" + QUERY_ROSTER: 'onRosterGet',
... "/iq[@type='set']" + QUERY_ROSTER: 'onRosterSet'}
... def connectionMade(self):
... self.xmlstream.addObserver(
... "/iq[@type='get' or @type='set']" + QUERY_ROSTER,
... self.handleRequest)
... def onRosterGet(self, iq):
... pass
... def onRosterSet(self, iq):
... pass
@cvar iqHandlers: Mapping from XPath queries (as a string) to the method
name that will handle requests that match the query.
@type iqHandlers: C{dict}
"""
iqHandlers = None
def handleRequest(self, iq):
"""
Find a handler and wrap the call for sending a response stanza.
"""
def toResult(result, iq):
response = toResponse(iq, 'result')
if result:
if IElement.providedBy(result):
response.addChild(result)
else:
for element in result:
response.addChild(element)
return response
def checkNotImplemented(failure):
failure.trap(NotImplementedError)
raise error.StanzaError('feature-not-implemented')
def fromStanzaError(failure, iq):
failure.trap(error.StanzaError)
return failure.value.toResponse(iq)
def fromOtherError(failure, iq):
log.msg("Unhandled error in iq handler:", isError=True)
log.err(failure)
return error.StanzaError('internal-server-error').toResponse(iq)
handler = None
for queryString, method in self.iqHandlers.iteritems():
if xpath.internQuery(queryString).matches(iq):
handler = getattr(self, method)
if handler:
d = defer.maybeDeferred(handler, iq)
else:
d = defer.fail(NotImplementedError())
d.addCallback(toResult, iq)
d.addErrback(checkNotImplemented)
d.addErrback(fromStanzaError, iq)
d.addErrback(fromOtherError, iq)
d.addCallback(self.send)
iq.handled = True
wokkel-0.7.1/wokkel/ping.py 0000775 0001750 0001750 00000005677 11707274572 016446 0 ustar ralphm ralphm 0000000 0000000 # -*- test-case-name: wokkel.test.test_ping -*-
#
# Copyright (c) Ralph Meijer.
# See LICENSE for details.
"""
XMPP Ping.
The XMPP Ping protocol is documented in
U{XEP-0199}.
"""
from zope.interface import implements
from twisted.words.protocols.jabber.error import StanzaError
from twisted.words.protocols.jabber.xmlstream import IQ, toResponse
from twisted.words.protocols.jabber.xmlstream import XMPPHandler
from wokkel import disco, iwokkel
NS_PING = 'urn:xmpp:ping'
PING_REQUEST = "/iq[@type='get']/ping[@xmlns='%s']" % NS_PING
class PingClientProtocol(XMPPHandler):
"""
Ping client.
This handler implements the protocol for sending out XMPP Ping requests.
"""
def ping(self, entity, sender=None):
"""
Send out a ping request and wait for a response.
@param entity: Entity to be pinged.
@type entity: L{JID}
@return: A deferred that fires upon receiving a response.
@rtype: L{Deferred}
@param sender: Optional sender address.
@type sender: L{JID}
"""
def cb(response):
return None
def eb(failure):
failure.trap(StanzaError)
exc = failure.value
if exc.condition == 'service-unavailable':
return None
else:
return failure
request = IQ(self.xmlstream, 'get')
request.addElement((NS_PING, 'ping'))
if sender is not None:
request['from'] = unicode(sender)
d = request.send(entity.full())
d.addCallbacks(cb, eb)
return d
class PingHandler(XMPPHandler):
"""
Ping responder.
This handler waits for XMPP Ping requests and sends a response.
"""
implements(iwokkel.IDisco)
def connectionInitialized(self):
"""
Called when the XML stream has been initialized.
This sets up an observer for incoming ping requests.
"""
self.xmlstream.addObserver(PING_REQUEST, self.onPing)
def onPing(self, iq):
"""
Called when a ping request has been received.
This immediately replies with a result response.
"""
response = toResponse(iq, 'result')
self.xmlstream.send(response)
iq.handled = True
def getDiscoInfo(self, requestor, target, nodeIdentifier=''):
"""
Get identity and features from this entity, node.
This handler supports XMPP Ping, but only without a nodeIdentifier
specified.
"""
if not nodeIdentifier:
return [disco.DiscoFeature(NS_PING)]
else:
return []
def getDiscoItems(self, requestor, target, nodeIdentifier=''):
"""
Get contained items for this entity, node.
This handler does not support items.
"""
return []
wokkel-0.7.1/wokkel/compat.py 0000775 0001750 0001750 00000022426 11707274572 016763 0 ustar ralphm ralphm 0000000 0000000 # -*- test-case-name: wokkel.test.test_compat -*-
#
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.
"""
Compatibility module to provide backwards compatibility with Twisted features.
"""
__all__ = ['BootstrapMixin', 'XmlStreamServerFactory', 'IQ',
'NamedConstant', 'ValueConstant', 'Names', 'Values']
from itertools import count
from twisted.python.deprecate import deprecatedModuleAttribute
from twisted.python.versions import Version
from twisted.words.protocols.jabber import xmlstream
from twisted.words.protocols.jabber.xmlstream import XmlStreamServerFactory
from twisted.words.xish.xmlstream import BootstrapMixin
deprecatedModuleAttribute(
Version("Wokkel", 0, 7, 0),
"Use twisted.words.xish.xmlstream.BootstrapMixin instead.",
__name__,
"BootstrapMixin")
deprecatedModuleAttribute(
Version("Wokkel", 0, 7, 0),
"Use twisted.words.protocols.jabber.xmlstream.XmlStreamServerFactory "
"instead.",
__name__,
"XmlStreamServerFactory")
class IQ(xmlstream.IQ):
def __init__(self, *args, **kwargs):
# Make sure we have a reactor parameter
try:
reactor = kwargs['reactor']
except KeyError:
from twisted.internet import reactor
kwargs['reactor'] = reactor
# Check if IQ's init accepts the reactor parameter
try:
xmlstream.IQ.__init__(self, *args, **kwargs)
except TypeError:
# Guess not. Remove the reactor parameter and try again.
del kwargs['reactor']
xmlstream.IQ.__init__(self, *args, **kwargs)
# Patch the XmlStream instance so that it has a _callLater
self._xmlstream._callLater = reactor.callLater
_unspecified = object()
_constantOrder = count().next
class _Constant(object):
"""
@ivar _index: A C{int} allocated from a shared counter in order to keep
track of the order in which L{_Constant}s are instantiated.
@ivar name: A C{str} giving the name of this constant; only set once the
constant is initialized by L{_ConstantsContainer}.
@ivar _container: The L{_ConstantsContainer} subclass this constant belongs
to; only set once the constant is initialized by that subclass.
@since: Twisted 12.0.0.
"""
def __init__(self):
self._index = _constantOrder()
def __get__(self, oself, cls):
"""
Ensure this constant has been initialized before returning it.
"""
cls._initializeEnumerants()
return self
def __repr__(self):
"""
Return text identifying both which constant this is and which collection
it belongs to.
"""
return "<%s=%s>" % (self._container.__name__, self.name)
def _realize(self, container, name, value):
"""
Complete the initialization of this L{_Constant}.
@param container: The L{_ConstantsContainer} subclass this constant is
part of.
@param name: The name of this constant in its container.
@param value: The value of this constant; not used, as named constants
have no value apart from their identity.
"""
self._container = container
self.name = name
class _EnumerantsInitializer(object):
"""
L{_EnumerantsInitializer} is a descriptor used to initialize a cache of
objects representing named constants for a particular L{_ConstantsContainer}
subclass.
@since: Twisted 12.0.0.
"""
def __get__(self, oself, cls):
"""
Trigger the initialization of the enumerants cache on C{cls} and then
return it.
"""
cls._initializeEnumerants()
return cls._enumerants
class _ConstantsContainer(object):
"""
L{_ConstantsContainer} is a class with attributes used as symbolic
constants. It is up to subclasses to specify what kind of constants are
allowed.
@cvar _constantType: Specified by a L{_ConstantsContainer} subclass to
specify the type of constants allowed by that subclass.
@cvar _enumerantsInitialized: A C{bool} tracking whether C{_enumerants} has
been initialized yet or not.
@cvar _enumerants: A C{dict} mapping the names of constants (eg
L{NamedConstant} instances) found in the class definition to those
instances. This is initialized via the L{_EnumerantsInitializer}
descriptor the first time it is accessed.
@since: Twisted 12.0.0.
"""
_constantType = None
_enumerantsInitialized = False
_enumerants = _EnumerantsInitializer()
def __new__(cls):
"""
Classes representing constants containers are not intended to be
instantiated.
The class object itself is used directly.
"""
raise TypeError("%s may not be instantiated." % (cls.__name__,))
def _initializeEnumerants(cls):
"""
Find all of the L{NamedConstant} instances in the definition of C{cls},
initialize them with constant values, and build a mapping from their
names to them to attach to C{cls}.
"""
if not cls._enumerantsInitialized:
constants = []
for (name, descriptor) in cls.__dict__.iteritems():
if isinstance(descriptor, cls._constantType):
constants.append((descriptor._index, name, descriptor))
enumerants = {}
for (index, enumerant, descriptor) in constants:
value = cls._constantFactory(enumerant)
descriptor._realize(cls, enumerant, value)
enumerants[enumerant] = descriptor
# Replace the _enumerants descriptor with the result so future
# access will go directly to the values. The _enumerantsInitialized
# flag is still necessary because NamedConstant.__get__ may also
# call this method.
cls._enumerants = enumerants
cls._enumerantsInitialized = True
_initializeEnumerants = classmethod(_initializeEnumerants)
def _constantFactory(cls, name):
"""
Construct the value for a new constant to add to this container.
@param name: The name of the constant to create.
@return: L{NamedConstant} instances have no value apart from identity,
so return a meaningless dummy value.
"""
return _unspecified
_constantFactory = classmethod(_constantFactory)
def lookupByName(cls, name):
"""
Retrieve a constant by its name or raise a C{ValueError} if there is no
constant associated with that name.
@param name: A C{str} giving the name of one of the constants defined by
C{cls}.
@raise ValueError: If C{name} is not the name of one of the constants
defined by C{cls}.
@return: The L{NamedConstant} associated with C{name}.
"""
if name in cls._enumerants:
return getattr(cls, name)
raise ValueError(name)
lookupByName = classmethod(lookupByName)
def iterconstants(cls):
"""
Iteration over a L{Names} subclass results in all of the constants it
contains.
@return: an iterator the elements of which are the L{NamedConstant}
instances defined in the body of this L{Names} subclass.
"""
constants = cls._enumerants.values()
constants.sort(key=lambda descriptor: descriptor._index)
return iter(constants)
iterconstants = classmethod(iterconstants)
class NamedConstant(_Constant):
"""
L{NamedConstant} defines an attribute to be a named constant within a
collection defined by a L{Names} subclass.
L{NamedConstant} is only for use in the definition of L{Names}
subclasses. Do not instantiate L{NamedConstant} elsewhere and do not
subclass it.
@since: Twisted 12.0.0.
"""
class Names(_ConstantsContainer):
"""
A L{Names} subclass contains constants which differ only in their names and
identities.
@since: Twisted 12.0.0.
"""
_constantType = NamedConstant
class ValueConstant(_Constant):
"""
L{ValueConstant} defines an attribute to be a named constant within a
collection defined by a L{Values} subclass.
L{ValueConstant} is only for use in the definition of L{Values} subclasses.
Do not instantiate L{ValueConstant} elsewhere and do not subclass it.
@since: Twisted 12.0.0.
"""
def __init__(self, value):
_Constant.__init__(self)
self.value = value
class Values(_ConstantsContainer):
"""
A L{Values} subclass contains constants which are associated with arbitrary
values.
@since: Twisted 12.0.0.
"""
_constantType = ValueConstant
def lookupByValue(cls, value):
"""
Retrieve a constant by its value or raise a C{ValueError} if there is no
constant associated with that value.
@param value: The value of one of the constants defined by C{cls}.
@raise ValueError: If C{value} is not the value of one of the constants
defined by C{cls}.
@return: The L{ValueConstant} associated with C{value}.
"""
for constant in cls.iterconstants():
if constant.value == value:
return constant
raise ValueError(value)
lookupByValue = classmethod(lookupByValue)
wokkel-0.7.1/wokkel/test/ 0000775 0001750 0001750 00000000000 12074346436 016071 5 ustar ralphm ralphm 0000000 0000000 wokkel-0.7.1/wokkel/test/test_shim.py 0000775 0001750 0001750 00000006131 11707215356 020444 0 ustar ralphm ralphm 0000000 0000000 # -*- test-case-name: wokkel.test.test_shim -*-
#
# Copyright (c) Ralph Meijer.
# See LICENSE for details.
"""
Tests for {wokkel.shim}.
"""
from twisted.trial import unittest
from wokkel import shim
from wokkel.generic import parseXml
NS_SHIM = 'http://jabber.org/protocol/shim'
class HeadersTest(unittest.TestCase):
"""
Tests for L{wokkel.shim.headers}.
"""
def test_noHeaders(self):
headers = shim.Headers([])
self.assertEquals(NS_SHIM, headers.uri)
self.assertEquals('headers', headers.name)
self.assertEquals([], headers.children)
def test_header(self):
headers = shim.Headers([('Urgency', 'high')])
elements = list(headers.elements())
self.assertEquals(1, len(elements))
header = elements[0]
self.assertEquals(NS_SHIM, header.uri)
self.assertEquals('header', header.name)
self.assertEquals('Urgency', header['name'])
self.assertEquals('high', unicode(header))
def test_headerRepeated(self):
"""
Some headers can appear more than once with the same name.
"""
headers = shim.Headers([('Collection', 'node1'),
('Collection', 'node2')])
elements = list(headers.elements())
self.assertEquals(2, len(elements))
collections = set((unicode(element) for element in elements
if element['name'] == 'Collection'))
self.assertIn('node1', collections)
self.assertIn('node2', collections)
class ExtractHeadersTest(unittest.TestCase):
"""
Tests for L{wokkel.shim.extractHeaders}.
"""
def test_noHeaders(self):
"""
A stanza without headers results in an empty dictionary.
"""
stanza = parseXml("""""")
headers = shim.extractHeaders(stanza)
self.assertEquals({}, headers)
def test_headers(self):
"""
A stanza with headers results in a dictionary with those headers.
"""
xml = """
"""
stanza = parseXml(xml)
headers = shim.extractHeaders(stanza)
self.assertEquals({'Urgency': ['high'],
'Collection': ['node1']}, headers)
def test_headersRepeated(self):
"""
Some headers may appear repeatedly. Make sure all values are extracted.
"""
xml = """
"""
stanza = parseXml(xml)
headers = shim.extractHeaders(stanza)
self.assertEquals({'Urgency': ['high'],
'Collection': ['node1', 'node2']}, headers)
wokkel-0.7.1/wokkel/test/test_server.py 0000775 0001750 0001750 00000035755 11707215356 021030 0 ustar ralphm ralphm 0000000 0000000 # Copyright (c) Ralph Meijer.
# See LICENSE for details.
"""
Tests for L{wokkel.server}.
"""
from twisted.internet import defer
from twisted.python import failure
from twisted.test.proto_helpers import StringTransport
from twisted.trial import unittest
from twisted.words.protocols.jabber import error, jid, xmlstream
from twisted.words.xish import domish
from wokkel import component, server
NS_STREAMS = 'http://etherx.jabber.org/streams'
NS_DIALBACK = "jabber:server:dialback"
class GenerateKeyTest(unittest.TestCase):
"""
Tests for L{server.generateKey}.
"""
def testBasic(self):
originating = "example.org"
receiving = "xmpp.example.com"
sid = "D60000229F"
secret = "s3cr3tf0rd14lb4ck"
key = server.generateKey(secret, receiving, originating, sid)
self.assertEqual(key,
'37c69b1cf07a3f67c04a5ef5902fa5114f2c76fe4a2686482ba5b89323075643')
class XMPPServerListenAuthenticatorTest(unittest.TestCase):
"""
Tests for L{server.XMPPServerListenAuthenticator}.
"""
secret = "s3cr3tf0rd14lb4ck"
originating = "example.org"
receiving = "xmpp.example.com"
sid = "D60000229F"
key = '37c69b1cf07a3f67c04a5ef5902fa5114f2c76fe4a2686482ba5b89323075643'
def setUp(self):
self.output = []
class MyService(object):
pass
self.service = MyService()
self.service.defaultDomain = self.receiving
self.service.domains = [self.receiving, 'pubsub.'+self.receiving]
self.service.secret = self.secret
self.authenticator = server.XMPPServerListenAuthenticator(self.service)
self.xmlstream = xmlstream.XmlStream(self.authenticator)
self.xmlstream.send = self.output.append
self.xmlstream.transport = StringTransport()
def test_attributes(self):
"""
Test attributes of authenticator and stream objects.
"""
self.assertEqual(self.service, self.authenticator.service)
self.assertEqual(self.xmlstream.initiating, False)
def test_streamStartedVersion0(self):
"""
The authenticator supports pre-XMPP 1.0 streams.
"""
self.xmlstream.connectionMade()
self.xmlstream.dataReceived(
"")
self.assertEqual((0, 0), self.xmlstream.version)
def test_streamStartedVersion1(self):
"""
The authenticator supports XMPP 1.0 streams.
"""
self.xmlstream.connectionMade()
self.xmlstream.dataReceived(
"")
self.assertEqual((1, 0), self.xmlstream.version)
def test_streamStartedSID(self):
"""
The response stream will have a stream ID.
"""
self.xmlstream.connectionMade()
self.assertIdentical(None, self.xmlstream.sid)
self.xmlstream.dataReceived(
"")
self.assertNotIdentical(None, self.xmlstream.sid)
def test_streamStartedSentResponseHeader(self):
"""
A stream header is sent in response to the incoming stream header.
"""
self.xmlstream.connectionMade()
self.assertFalse(self.xmlstream._headerSent)
self.xmlstream.dataReceived(
"")
self.assertTrue(self.xmlstream._headerSent)
def test_streamStartedNotSentFeatures(self):
"""
No features are sent in response to an XMPP < 1.0 stream header.
"""
self.xmlstream.connectionMade()
self.xmlstream.dataReceived(
"")
self.assertEqual(1, len(self.output))
def test_streamStartedSentFeatures(self):
"""
Features are sent in response to an XMPP >= 1.0 stream header.
"""
self.xmlstream.connectionMade()
self.xmlstream.dataReceived(
"")
self.assertEqual(2, len(self.output))
features = self.output[-1]
self.assertEqual(NS_STREAMS, features.uri)
self.assertEqual('features', features.name)
def test_streamRootElement(self):
"""
Test stream error on wrong stream namespace.
"""
self.xmlstream.connectionMade()
self.xmlstream.dataReceived(
"")
self.assertEqual(3, len(self.output))
exc = error.exceptionFromStreamError(self.output[1])
self.assertEqual('invalid-namespace', exc.condition)
def test_streamDefaultNamespace(self):
"""
Test stream error on missing dialback namespace.
"""
self.xmlstream.connectionMade()
self.xmlstream.dataReceived(
"")
self.assertEqual(3, len(self.output))
exc = error.exceptionFromStreamError(self.output[1])
self.assertEqual('invalid-namespace', exc.condition)
def test_streamNoDialbackNamespace(self):
"""
Test stream error on missing dialback namespace.
"""
self.xmlstream.connectionMade()
self.xmlstream.dataReceived(
"")
self.assertEqual(3, len(self.output))
exc = error.exceptionFromStreamError(self.output[1])
self.assertEqual('invalid-namespace', exc.condition)
def test_streamBadDialbackNamespace(self):
"""
Test stream error on missing dialback namespace.
"""
self.xmlstream.connectionMade()
self.xmlstream.dataReceived(
"")
self.assertEqual(3, len(self.output))
exc = error.exceptionFromStreamError(self.output[1])
self.assertEqual('invalid-namespace', exc.condition)
def test_streamToUnknownHost(self):
"""
Test stream error on stream's to attribute having unknown host.
"""
self.xmlstream.connectionMade()
self.xmlstream.dataReceived(
"")
self.assertEqual(3, len(self.output))
exc = error.exceptionFromStreamError(self.output[1])
self.assertEqual('host-unknown', exc.condition)
def test_streamToOtherLocalHost(self):
"""
The authenticator supports XMPP 1.0 streams.
"""
self.xmlstream.connectionMade()
self.xmlstream.dataReceived(
"")
self.assertEqual(2, len(self.output))
self.assertEqual(jid.JID('pubsub.xmpp.example.com'),
self.xmlstream.thisEntity)
def test_onResult(self):
def cb(result):
self.assertEqual(1, len(self.output))
reply = self.output[0]
self.assertEqual(self.originating, reply['to'])
self.assertEqual(self.receiving, reply['from'])
self.assertEqual('valid', reply['type'])
def validateConnection(thisHost, otherHost, sid, key):
self.assertEqual(thisHost, self.receiving)
self.assertEqual(otherHost, self.originating)
self.assertEqual(sid, self.sid)
self.assertEqual(key, self.key)
return defer.succeed(None)
self.xmlstream.sid = self.sid
self.service.validateConnection = validateConnection
result = domish.Element((NS_DIALBACK, 'result'))
result['to'] = self.receiving
result['from'] = self.originating
result.addContent(self.key)
d = self.authenticator.onResult(result)
d.addCallback(cb)
return d
def test_onResultFailure(self):
class TestError(Exception):
pass
def cb(result):
reply = self.output[0]
self.assertEqual('invalid', reply['type'])
self.assertEqual(1, len(self.flushLoggedErrors(TestError)))
def validateConnection(thisHost, otherHost, sid, key):
return defer.fail(TestError())
self.xmlstream.sid = self.sid
self.service.validateConnection = validateConnection
result = domish.Element((NS_DIALBACK, 'result'))
result['to'] = self.receiving
result['from'] = self.originating
result.addContent(self.key)
d = self.authenticator.onResult(result)
d.addCallback(cb)
return d
class FakeService(object):
domains = set(['example.org', 'pubsub.example.org'])
defaultDomain = 'example.org'
secret = 'mysecret'
def __init__(self):
self.dispatched = []
def dispatch(self, xs, element):
self.dispatched.append(element)
class XMPPS2SServerFactoryTest(unittest.TestCase):
"""
Tests for L{component.XMPPS2SServerFactory}.
"""
def setUp(self):
self.service = FakeService()
self.factory = server.XMPPS2SServerFactory(self.service)
self.xmlstream = self.factory.buildProtocol(None)
self.transport = StringTransport()
self.xmlstream.thisEntity = jid.JID('example.org')
self.xmlstream.otherEntity = jid.JID('example.com')
def test_makeConnection(self):
"""
A new connection increases the stream serial count. No logs by default.
"""
self.xmlstream.makeConnection(self.transport)
self.assertEqual(0, self.xmlstream.serial)
self.assertEqual(1, self.factory.serial)
self.assertIdentical(None, self.xmlstream.rawDataInFn)
self.assertIdentical(None, self.xmlstream.rawDataOutFn)
def test_makeConnectionLogTraffic(self):
"""
Setting logTraffic should set up raw data loggers.
"""
self.factory.logTraffic = True
self.xmlstream.makeConnection(self.transport)
self.assertNotIdentical(None, self.xmlstream.rawDataInFn)
self.assertNotIdentical(None, self.xmlstream.rawDataOutFn)
def test_onError(self):
"""
An observer for stream errors should trigger onError to log it.
"""
self.xmlstream.makeConnection(self.transport)
class TestError(Exception):
pass
reason = failure.Failure(TestError())
self.xmlstream.dispatch(reason, xmlstream.STREAM_ERROR_EVENT)
self.assertEqual(1, len(self.flushLoggedErrors(TestError)))
def test_connectionInitialized(self):
"""
"""
self.xmlstream.makeConnection(self.transport)
self.xmlstream.dispatch(self.xmlstream, xmlstream.STREAM_AUTHD_EVENT)
def test_connectionLost(self):
"""
"""
self.xmlstream.makeConnection(self.transport)
self.xmlstream.dispatch(self.xmlstream, xmlstream.STREAM_AUTHD_EVENT)
self.xmlstream.dispatch(None, xmlstream.STREAM_END_EVENT)
def test_Element(self):
self.xmlstream.makeConnection(self.transport)
self.xmlstream.dispatch(self.xmlstream, xmlstream.STREAM_AUTHD_EVENT)
stanza = domish.Element((None, "presence"))
self.xmlstream.dispatch(stanza)
self.assertEqual(1, len(self.service.dispatched))
self.assertIdentical(stanza, self.service.dispatched[-1])
def test_ElementNotAuthenticated(self):
self.xmlstream.makeConnection(self.transport)
stanza = domish.Element((None, "presence"))
self.xmlstream.dispatch(stanza)
self.assertEqual(0, len(self.service.dispatched))
class ServerServiceTest(unittest.TestCase):
def setUp(self):
self.output = []
self.xmlstream = xmlstream.XmlStream(xmlstream.Authenticator())
self.xmlstream.thisEntity = jid.JID('example.org')
self.xmlstream.otherEntity = jid.JID('example.com')
self.xmlstream.send = self.output.append
self.router = component.Router()
self.service = server.ServerService(self.router,
secret='mysecret',
domain='example.org')
self.service.xmlstream = self.xmlstream
def test_defaultDomainInDomains(self):
"""
The default domain is part of the domains considered local.
"""
self.assertIn(self.service.defaultDomain, self.service.domains)
def test_dispatch(self):
stanza = domish.Element((None, "presence"))
stanza['to'] = 'user@example.org'
stanza['from'] = 'other@example.com'
self.service.dispatch(self.xmlstream, stanza)
self.assertEqual(1, len(self.output))
self.assertIdentical(stanza, self.output[-1])
def test_dispatchNoTo(self):
errors = []
self.xmlstream.sendStreamError = errors.append
stanza = domish.Element((None, "presence"))
stanza['from'] = 'other@example.com'
self.service.dispatch(self.xmlstream, stanza)
self.assertEqual(1, len(errors))
wokkel-0.7.1/wokkel/test/test_compat.py 0000775 0001750 0001750 00000037317 11707274572 021006 0 ustar ralphm ralphm 0000000 0000000 # Copyright (c) Twisted Matrix Laboratories.
# Copyright (c) Ralph Meijer.
# See LICENSE for details.
"""
Tests for L{wokkel.compat}.
"""
from zope.interface import implements
from twisted.internet import task
from twisted.internet.interfaces import IReactorTime
from twisted.trial import unittest
from twisted.words.protocols.jabber import xmlstream
from wokkel.compat import IQ
from wokkel.compat import NamedConstant, Names, ValueConstant, Values
class DeprecationTest(unittest.TestCase):
"""
Deprecation tests for L{wokkel.compat}.
"""
def lookForDeprecationWarning(self, testmethod, attributeName, newName):
"""
Importing C{testmethod} emits a deprecation warning.
"""
warningsShown = self.flushWarnings([testmethod])
self.assertEqual(len(warningsShown), 1)
self.assertIdentical(warningsShown[0]['category'], DeprecationWarning)
self.assertEqual(
warningsShown[0]['message'],
"wokkel.compat." + attributeName + " "
"was deprecated in Wokkel 0.7.0: Use " + newName + " instead.")
def test_bootstrapMixinTest(self):
"""
L{compat.BootstrapMixin} is deprecated.
"""
from wokkel.compat import BootstrapMixin
BootstrapMixin
self.lookForDeprecationWarning(
self.test_bootstrapMixinTest,
"BootstrapMixin",
"twisted.words.xish.xmlstream.BootstrapMixin")
def test_xmlStreamServerFactory(self):
"""
L{compat.XmlStreamServerFactory} is deprecated.
"""
from wokkel.compat import XmlStreamServerFactory
XmlStreamServerFactory
self.lookForDeprecationWarning(
self.test_xmlStreamServerFactory,
"XmlStreamServerFactory",
"twisted.words.protocols.jabber.xmlstream."
"XmlStreamServerFactory")
class FakeReactor(object):
implements(IReactorTime)
def __init__(self):
self.clock = task.Clock()
self.callLater = self.clock.callLater
self.getDelayedCalls = self.clock.getDelayedCalls
class IQTest(unittest.TestCase):
"""
Tests for L{IQ}.
"""
def setUp(self):
self.reactor = FakeReactor()
self.clock = self.reactor.clock
def testRequestTimingOutEventDispatcher(self):
"""
Test that an iq request with a defined timeout times out.
"""
from twisted.words.xish import utility
output = []
xs = utility.EventDispatcher()
xs.send = output.append
self.iq = IQ(xs, reactor=self.reactor)
self.iq.timeout = 60
d = self.iq.send()
self.assertFailure(d, xmlstream.TimeoutError)
self.clock.pump([1, 60])
self.assertFalse(self.reactor.getDelayedCalls())
self.assertFalse(xs.iqDeferreds)
return d
class NamedConstantTests(unittest.TestCase):
"""
Tests for the L{twisted.python.constants.NamedConstant} class which is used
to represent individual values.
"""
def setUp(self):
"""
Create a dummy container into which constants can be placed.
"""
class foo(Names):
pass
self.container = foo
def test_name(self):
"""
The C{name} attribute of a L{NamedConstant} refers to the value passed
for the C{name} parameter to C{_realize}.
"""
name = NamedConstant()
name._realize(self.container, "bar", None)
self.assertEqual("bar", name.name)
def test_representation(self):
"""
The string representation of an instance of L{NamedConstant} includes
the container the instances belongs to as well as the instance's name.
"""
name = NamedConstant()
name._realize(self.container, "bar", None)
self.assertEqual("", repr(name))
def test_equality(self):
"""
A L{NamedConstant} instance compares equal to itself.
"""
name = NamedConstant()
name._realize(self.container, "bar", None)
self.assertTrue(name == name)
self.assertFalse(name != name)
def test_nonequality(self):
"""
Two different L{NamedConstant} instances do not compare equal to each
other.
"""
first = NamedConstant()
first._realize(self.container, "bar", None)
second = NamedConstant()
second._realize(self.container, "bar", None)
self.assertFalse(first == second)
self.assertTrue(first != second)
def test_hash(self):
"""
Because two different L{NamedConstant} instances do not compare as equal
to each other, they also have different hashes to avoid collisions when
added to a C{dict} or C{set}.
"""
first = NamedConstant()
first._realize(self.container, "bar", None)
second = NamedConstant()
second._realize(self.container, "bar", None)
self.assertNotEqual(hash(first), hash(second))
class _ConstantsTestsMixin(object):
"""
Mixin defining test helpers common to multiple types of constants
collections.
"""
def _notInstantiableTest(self, name, cls):
"""
Assert that an attempt to instantiate the constants class raises
C{TypeError}.
@param name: A C{str} giving the name of the constants collection.
@param cls: The constants class to test.
"""
exc = self.assertRaises(TypeError, cls)
self.assertEqual(name + " may not be instantiated.", str(exc))
class NamesTests(unittest.TestCase, _ConstantsTestsMixin):
"""
Tests for L{twisted.python.constants.Names}, a base class for containers of
related constaints.
"""
def setUp(self):
"""
Create a fresh new L{Names} subclass for each unit test to use. Since
L{Names} is stateful, re-using the same subclass across test methods
makes exercising all of the implementation code paths difficult.
"""
class METHOD(Names):
"""
A container for some named constants to use in unit tests for
L{Names}.
"""
GET = NamedConstant()
PUT = NamedConstant()
POST = NamedConstant()
DELETE = NamedConstant()
self.METHOD = METHOD
def test_notInstantiable(self):
"""
A subclass of L{Names} raises C{TypeError} if an attempt is made to
instantiate it.
"""
self._notInstantiableTest("METHOD", self.METHOD)
def test_symbolicAttributes(self):
"""
Each name associated with a L{NamedConstant} instance in the definition
of a L{Names} subclass is available as an attribute on the resulting
class.
"""
self.assertTrue(hasattr(self.METHOD, "GET"))
self.assertTrue(hasattr(self.METHOD, "PUT"))
self.assertTrue(hasattr(self.METHOD, "POST"))
self.assertTrue(hasattr(self.METHOD, "DELETE"))
def test_withoutOtherAttributes(self):
"""
As usual, names not defined in the class scope of a L{Names}
subclass are not available as attributes on the resulting class.
"""
self.assertFalse(hasattr(self.METHOD, "foo"))
def test_representation(self):
"""
The string representation of a constant on a L{Names} subclass includes
the name of the L{Names} subclass and the name of the constant itself.
"""
self.assertEqual("", repr(self.METHOD.GET))
def test_lookupByName(self):
"""
Constants can be looked up by name using L{Names.lookupByName}.
"""
method = self.METHOD.lookupByName("GET")
self.assertIdentical(self.METHOD.GET, method)
def test_notLookupMissingByName(self):
"""
Names not defined with a L{NamedConstant} instance cannot be looked up
using L{Names.lookupByName}.
"""
self.assertRaises(ValueError, self.METHOD.lookupByName, "lookupByName")
self.assertRaises(ValueError, self.METHOD.lookupByName, "__init__")
self.assertRaises(ValueError, self.METHOD.lookupByName, "foo")
def test_name(self):
"""
The C{name} attribute of one of the named constants gives that
constant's name.
"""
self.assertEqual("GET", self.METHOD.GET.name)
def test_attributeIdentity(self):
"""
Repeated access of an attribute associated with a L{NamedConstant} value
in a L{Names} subclass results in the same object.
"""
self.assertIdentical(self.METHOD.GET, self.METHOD.GET)
def test_iterconstants(self):
"""
L{Names.iterconstants} returns an iterator over all of the constants
defined in the class, in the order they were defined.
"""
constants = list(self.METHOD.iterconstants())
self.assertEqual(
[self.METHOD.GET, self.METHOD.PUT,
self.METHOD.POST, self.METHOD.DELETE],
constants)
def test_attributeIterconstantsIdentity(self):
"""
The constants returned from L{Names.iterconstants} are identical to the
constants accessible using attributes.
"""
constants = list(self.METHOD.iterconstants())
self.assertIdentical(self.METHOD.GET, constants[0])
self.assertIdentical(self.METHOD.PUT, constants[1])
self.assertIdentical(self.METHOD.POST, constants[2])
self.assertIdentical(self.METHOD.DELETE, constants[3])
def test_iterconstantsIdentity(self):
"""
The constants returned from L{Names.iterconstants} are identical on each
call to that method.
"""
constants = list(self.METHOD.iterconstants())
again = list(self.METHOD.iterconstants())
self.assertIdentical(again[0], constants[0])
self.assertIdentical(again[1], constants[1])
self.assertIdentical(again[2], constants[2])
self.assertIdentical(again[3], constants[3])
def test_initializedOnce(self):
"""
L{Names._enumerants} is initialized once and its value re-used on
subsequent access.
"""
first = self.METHOD._enumerants
self.METHOD.GET # Side-effects!
second = self.METHOD._enumerants
self.assertIdentical(first, second)
class ValuesTests(unittest.TestCase, _ConstantsTestsMixin):
"""
Tests for L{twisted.python.constants.Names}, a base class for containers of
related constaints with arbitrary values.
"""
def setUp(self):
"""
Create a fresh new L{Values} subclass for each unit test to use. Since
L{Values} is stateful, re-using the same subclass across test methods
makes exercising all of the implementation code paths difficult.
"""
class STATUS(Values):
OK = ValueConstant("200")
NOT_FOUND = ValueConstant("404")
self.STATUS = STATUS
def test_notInstantiable(self):
"""
A subclass of L{Values} raises C{TypeError} if an attempt is made to
instantiate it.
"""
self._notInstantiableTest("STATUS", self.STATUS)
def test_symbolicAttributes(self):
"""
Each name associated with a L{ValueConstant} instance in the definition
of a L{Values} subclass is available as an attribute on the resulting
class.
"""
self.assertTrue(hasattr(self.STATUS, "OK"))
self.assertTrue(hasattr(self.STATUS, "NOT_FOUND"))
def test_withoutOtherAttributes(self):
"""
As usual, names not defined in the class scope of a L{Values}
subclass are not available as attributes on the resulting class.
"""
self.assertFalse(hasattr(self.STATUS, "foo"))
def test_representation(self):
"""
The string representation of a constant on a L{Values} subclass includes
the name of the L{Values} subclass and the name of the constant itself.
"""
self.assertEqual("", repr(self.STATUS.OK))
def test_lookupByName(self):
"""
Constants can be looked up by name using L{Values.lookupByName}.
"""
method = self.STATUS.lookupByName("OK")
self.assertIdentical(self.STATUS.OK, method)
def test_notLookupMissingByName(self):
"""
Names not defined with a L{ValueConstant} instance cannot be looked up
using L{Values.lookupByName}.
"""
self.assertRaises(ValueError, self.STATUS.lookupByName, "lookupByName")
self.assertRaises(ValueError, self.STATUS.lookupByName, "__init__")
self.assertRaises(ValueError, self.STATUS.lookupByName, "foo")
def test_lookupByValue(self):
"""
Constants can be looked up by their associated value, defined by the
argument passed to L{ValueConstant}, using L{Values.lookupByValue}.
"""
status = self.STATUS.lookupByValue("200")
self.assertIdentical(self.STATUS.OK, status)
def test_lookupDuplicateByValue(self):
"""
If more than one constant is associated with a particular value,
L{Values.lookupByValue} returns whichever of them is defined first.
"""
class TRANSPORT_MESSAGE(Values):
"""
Message types supported by an SSH transport.
"""
KEX_DH_GEX_REQUEST_OLD = ValueConstant(30)
KEXDH_INIT = ValueConstant(30)
self.assertIdentical(
TRANSPORT_MESSAGE.lookupByValue(30),
TRANSPORT_MESSAGE.KEX_DH_GEX_REQUEST_OLD)
def test_notLookupMissingByValue(self):
"""
L{Values.lookupByValue} raises L{ValueError} when called with a value
with which no constant is associated.
"""
self.assertRaises(ValueError, self.STATUS.lookupByValue, "OK")
self.assertRaises(ValueError, self.STATUS.lookupByValue, 200)
self.assertRaises(ValueError, self.STATUS.lookupByValue, "200.1")
def test_name(self):
"""
The C{name} attribute of one of the constants gives that constant's
name.
"""
self.assertEqual("OK", self.STATUS.OK.name)
def test_attributeIdentity(self):
"""
Repeated access of an attribute associated with a L{ValueConstant} value
in a L{Values} subclass results in the same object.
"""
self.assertIdentical(self.STATUS.OK, self.STATUS.OK)
def test_iterconstants(self):
"""
L{Values.iterconstants} returns an iterator over all of the constants
defined in the class, in the order they were defined.
"""
constants = list(self.STATUS.iterconstants())
self.assertEqual(
[self.STATUS.OK, self.STATUS.NOT_FOUND],
constants)
def test_attributeIterconstantsIdentity(self):
"""
The constants returned from L{Values.iterconstants} are identical to the
constants accessible using attributes.
"""
constants = list(self.STATUS.iterconstants())
self.assertIdentical(self.STATUS.OK, constants[0])
self.assertIdentical(self.STATUS.NOT_FOUND, constants[1])
def test_iterconstantsIdentity(self):
"""
The constants returned from L{Values.iterconstants} are identical on
each call to that method.
"""
constants = list(self.STATUS.iterconstants())
again = list(self.STATUS.iterconstants())
self.assertIdentical(again[0], constants[0])
self.assertIdentical(again[1], constants[1])
def test_initializedOnce(self):
"""
L{Values._enumerants} is initialized once and its value re-used on
subsequent access.
"""
first = self.STATUS._enumerants
self.STATUS.OK # Side-effects!
second = self.STATUS._enumerants
self.assertIdentical(first, second)
wokkel-0.7.1/wokkel/test/helpers.py 0000775 0001750 0001750 00000007170 12074262111 020100 0 ustar ralphm ralphm 0000000 0000000 # Copyright (c) Ralph Meijer.
# See LICENSE for details.
"""
Unit test helpers.
"""
from twisted.internet import defer
from twisted.words.xish import xpath
from twisted.words.xish.utility import EventDispatcher
from wokkel.generic import parseXml
from wokkel.subprotocols import StreamManager
class XmlStreamStub(object):
"""
Stub for testing objects that communicate through XML Streams.
Instances of this stub hold an object in L{xmlstream} that acts like an
L{XmlStream} as its first argument.
These appear in sequence in the L{output} instance variable of the stub.
For the reverse direction, stanzas passed to L{send} of the stub, will be
dispatched in the stubbed XmlStream as if it was received over the wire, so
that registered observers will be called.
Example:
>>> stub = XmlStreamStub()
>>> stub.xmlstream.send(domish.Element((None, 'presence')))
>>> stub.output[-1].toXml()
u''
>>> def cb(stanza):
... print "Got: %r" stanza.toXml()
>>> stub.xmlstream.addObserver('/presence')
>>> stub.send(domish.Element((None, 'presence')))
Got: u''
@ivar xmlstream: Stubbed XML Stream.
@type xmlstream: L{EventDispatcher}
@ivar output: List of stanzas sent to the XML Stream.
@type output: L{list}
"""
def __init__(self):
self.output = []
self.xmlstream = EventDispatcher()
self.xmlstream.send = self.output.append
def send(self, obj):
"""
Pass an element to the XML Stream as if received.
@param obj: Element to be dispatched to C{self.xmlstream}.
@type obj: object implementing
L{IElement}.
"""
self.xmlstream.dispatch(obj)
class TestableRequestHandlerMixin(object):
"""
Mixin for testing XMPPHandlers that process iq requests.
Handlers that use L{wokkel.subprotocols.IQHandlerMixin} define a
C{iqHandlers} attribute that lists the handlers to be called for iq
requests. This mixin provides L{handleRequest} to mimic the handler
processing for easier testing.
"""
def handleRequest(self, xml):
"""
Find a handler and call it directly.
@param xml: XML stanza that may yield a handler being called.
@type xml: C{str}.
@return: Deferred that fires with the result of a handler for this
stanza. If no handler was found, the deferred has its errback
called with a C{NotImplementedError} exception.
"""
handler = None
iq = parseXml(xml)
for queryString, method in self.service.iqHandlers.iteritems():
if xpath.internQuery(queryString).matches(iq):
handler = getattr(self.service, method)
if handler:
d = defer.maybeDeferred(handler, iq)
else:
d = defer.fail(NotImplementedError())
return d
class TestableStreamManager(StreamManager):
"""
Stream manager for testing subprotocol handlers.
"""
def __init__(self, reactor=None):
class DummyFactory(object):
def addBootstrap(self, event, fn):
pass
factory = DummyFactory()
StreamManager.__init__(self, factory, reactor)
self.stub = XmlStreamStub()
self._connected(self.stub.xmlstream)
self._authd(self.stub.xmlstream)
wokkel-0.7.1/wokkel/test/test_component.py 0000775 0001750 0001750 00000040764 11722233042 021505 0 ustar ralphm ralphm 0000000 0000000 # Copyright (c) Ralph Meijer.
# See LICENSE for details.
"""
Tests for L{wokkel.component}.
"""
from zope.interface.verify import verifyObject
from twisted.internet.base import BaseConnector
from twisted.internet.error import ConnectionRefusedError
from twisted.internet.task import Clock
from twisted.python import failure
from twisted.trial import unittest
from twisted.words.protocols.jabber import xmlstream
from twisted.words.protocols.jabber.ijabber import IXMPPHandlerCollection
from twisted.words.protocols.jabber.jid import JID
from twisted.words.protocols.jabber.xmlstream import XMPPHandler
from twisted.words.xish import domish
from wokkel import component
from wokkel.generic import XmlPipe
class FakeConnector(BaseConnector):
"""
Fake connector that counts connection attempts.
"""
connects = 0
def connect(self):
self.connects += 1
BaseConnector.connect(self)
def _makeTransport(self):
return None
class TestableComponent(component.Component):
"""
Testable component.
This component provides the created factory with a L{Clock}
instead of the regular reactor and uses L{FakeConnector} for testing
connects and reconnects.
"""
def __init__(self, *args, **kwargs):
component.Component.__init__(self, *args, **kwargs)
self.factory.clock = Clock()
def _getConnection(self):
c = FakeConnector(self.factory, None, None)
c.connect()
return c
class ComponentTest(unittest.TestCase):
"""
Tests for L{component.Component}.
"""
def test_startServiceReconnectAfterFailure(self):
"""
When the first connection attempt fails, retry.
"""
comp = TestableComponent('example.org', 5347,
'test.example.org', 'secret')
# Starting the service initiates a connection attempt.
comp.startService()
connector = comp._connection
self.assertEqual(1, connector.connects)
# Fail the connection.
connector.connectionFailed(ConnectionRefusedError())
# After a back-off delay, a new connection is attempted.
comp.factory.clock.advance(5)
self.assertEqual(2, connector.connects)
def test_stopServiceNoReconnect(self):
"""
When the service is stopped, no reconnect is attempted.
"""
comp = TestableComponent('example.org', 5347,
'test.example.org', 'secret')
# Starting the service initiates a connection attempt.
comp.startService()
connector = comp._connection
# Fail the connection.
connector.connectionFailed(ConnectionRefusedError())
# If the service is stopped before the back-off delay expires,
# no new connection is attempted.
comp.factory.clock.advance(1)
comp.stopService()
comp.factory.clock.advance(4)
self.assertEqual(1, connector.connects)
class InternalComponentTest(unittest.TestCase):
"""
Tests for L{component.InternalComponent}.
"""
def setUp(self):
self.router = component.Router()
self.component = component.InternalComponent(self.router, 'component')
def test_interface(self):
"""
L{component.InternalComponent} implements
L{IXMPPHandlerCollection}.
"""
verifyObject(IXMPPHandlerCollection, self.component)
def test_startServiceRunning(self):
"""
Starting the service makes it running.
"""
self.assertFalse(self.component.running)
self.component.startService()
self.assertTrue(self.component.running)
def test_startServiceAddRoute(self):
"""
Starting the service creates a new route.
"""
self.component.startService()
self.assertIn('component', self.router.routes)
def test_startServiceNoDomain(self):
self.component = component.InternalComponent(self.router)
self.component.startService()
def test_startServiceAddMultipleRoutes(self):
"""
Starting the service creates a new route.
"""
self.component.domains.add('component2')
self.component.startService()
self.assertIn('component', self.router.routes)
self.assertIn('component2', self.router.routes)
def test_startServiceHandlerDispatch(self):
"""
Starting the service hooks up handlers.
"""
events = []
class TestHandler(XMPPHandler):
def connectionInitialized(self):
fn = lambda obj: events.append(obj)
self.xmlstream.addObserver('//event/test', fn)
TestHandler().setHandlerParent(self.component)
self.component.startService()
self.assertEquals([], events)
self.component.xmlstream.dispatch(None, '//event/test')
self.assertEquals([None], events)
def test_stopServiceNotRunning(self):
"""
Stopping the service makes it not running.
"""
self.component.startService()
self.component.stopService()
self.assertFalse(self.component.running)
def test_stopServiceRemoveRoute(self):
"""
Stopping the service removes routes.
"""
self.component.startService()
self.component.stopService()
self.assertNotIn('component', self.router.routes)
def test_stopServiceNoDomain(self):
self.component = component.InternalComponent(self.router)
self.component.startService()
self.component.stopService()
def test_startServiceRemoveMultipleRoutes(self):
"""
Starting the service creates a new route.
"""
self.component.domains.add('component2')
self.component.startService()
self.component.stopService()
self.assertNotIn('component', self.router.routes)
self.assertNotIn('component2', self.router.routes)
def test_stopServiceHandlerDispatch(self):
"""
Stopping the service disconnects handlers.
"""
events = []
class TestHandler(XMPPHandler):
def connectionLost(self, reason):
events.append(reason)
TestHandler().setHandlerParent(self.component)
self.component.startService()
self.component.stopService()
self.assertEquals(1, len(events))
def test_addHandler(self):
"""
Adding a handler connects it to the stream.
"""
events = []
class TestHandler(XMPPHandler):
def connectionInitialized(self):
fn = lambda obj: events.append(obj)
self.xmlstream.addObserver('//event/test', fn)
self.component.startService()
self.component.xmlstream.dispatch(None, '//event/test')
self.assertEquals([], events)
TestHandler().setHandlerParent(self.component)
self.component.xmlstream.dispatch(None, '//event/test')
self.assertEquals([None], events)
def test_send(self):
"""
A message sent from the component ends up at the router.
"""
events = []
fn = lambda obj: events.append(obj)
message = domish.Element((None, 'message'))
self.router.route = fn
self.component.startService()
self.component.send(message)
self.assertEquals([message], events)
class RouterTest(unittest.TestCase):
"""
Tests for L{component.Router}.
"""
def test_addRoute(self):
"""
Test route registration and routing on incoming stanzas.
"""
router = component.Router()
routed = []
router.route = lambda element: routed.append(element)
pipe = XmlPipe()
router.addRoute('example.org', pipe.sink)
self.assertEquals(1, len(router.routes))
self.assertEquals(pipe.sink, router.routes['example.org'])
element = domish.Element(('testns', 'test'))
pipe.source.send(element)
self.assertEquals([element], routed)
def test_route(self):
"""
Test routing of a message.
"""
component1 = XmlPipe()
component2 = XmlPipe()
router = component.Router()
router.addRoute('component1.example.org', component1.sink)
router.addRoute('component2.example.org', component2.sink)
outgoing = []
component2.source.addObserver('/*',
lambda element: outgoing.append(element))
stanza = domish.Element((None, 'presence'))
stanza['from'] = 'component1.example.org'
stanza['to'] = 'component2.example.org'
component1.source.send(stanza)
self.assertEquals([stanza], outgoing)
def test_routeDefault(self):
"""
Test routing of a message using the default route.
The default route is the one with C{None} as its key in the
routing table. It is taken when there is no more specific route
in the routing table that matches the stanza's destination.
"""
component1 = XmlPipe()
s2s = XmlPipe()
router = component.Router()
router.addRoute('component1.example.org', component1.sink)
router.addRoute(None, s2s.sink)
outgoing = []
s2s.source.addObserver('/*', lambda element: outgoing.append(element))
stanza = domish.Element((None, 'presence'))
stanza['from'] = 'component1.example.org'
stanza['to'] = 'example.com'
component1.source.send(stanza)
self.assertEquals([stanza], outgoing)
class ListenComponentAuthenticatorTest(unittest.TestCase):
"""
Tests for L{component.ListenComponentAuthenticator}.
"""
def setUp(self):
self.output = []
authenticator = component.ListenComponentAuthenticator('secret')
self.xmlstream = xmlstream.XmlStream(authenticator)
self.xmlstream.send = self.output.append
def loseConnection(self):
"""
Stub loseConnection because we are a transport.
"""
self.xmlstream.connectionLost("no reason")
def test_streamStarted(self):
"""
The received stream header should set several attributes.
"""
observers = []
def addOnetimeObserver(event, observerfn):
observers.append((event, observerfn))
xs = self.xmlstream
xs.addOnetimeObserver = addOnetimeObserver
xs.makeConnection(self)
self.assertIdentical(None, xs.sid)
self.assertFalse(xs._headerSent)
xs.dataReceived("")
self.assertEqual((0, 0), xs.version)
self.assertNotIdentical(None, xs.sid)
self.assertTrue(xs._headerSent)
self.assertEquals(('/*', xs.authenticator.onElement), observers[-1])
def test_streamStartedWrongNamespace(self):
"""
The received stream header should have a correct namespace.
"""
streamErrors = []
xs = self.xmlstream
xs.sendStreamError = streamErrors.append
xs.makeConnection(self)
xs.dataReceived("")
self.assertEquals(1, len(streamErrors))
self.assertEquals('invalid-namespace', streamErrors[-1].condition)
def test_streamStartedNoTo(self):
"""
The received stream header should have a 'to' attribute.
"""
streamErrors = []
xs = self.xmlstream
xs.sendStreamError = streamErrors.append
xs.makeConnection(self)
xs.dataReceived("")
self.assertEquals(1, len(streamErrors))
self.assertEquals('improper-addressing', streamErrors[-1].condition)
def test_onElement(self):
"""
We expect a handshake element with a hash.
"""
handshakes = []
xs = self.xmlstream
xs.authenticator.onHandshake = handshakes.append
handshake = domish.Element(('jabber:component:accept', 'handshake'))
handshake.addContent('1234')
xs.authenticator.onElement(handshake)
self.assertEqual('1234', handshakes[-1])
def test_onElementNotHandshake(self):
"""
Reject elements that are not handshakes
"""
handshakes = []
streamErrors = []
xs = self.xmlstream
xs.authenticator.onHandshake = handshakes.append
xs.sendStreamError = streamErrors.append
element = domish.Element(('jabber:component:accept', 'message'))
xs.authenticator.onElement(element)
self.assertFalse(handshakes)
self.assertEquals('not-authorized', streamErrors[-1].condition)
def test_onHandshake(self):
"""
Receiving a handshake matching the secret authenticates the stream.
"""
authd = []
def authenticated(xs):
authd.append(xs)
xs = self.xmlstream
xs.addOnetimeObserver(xmlstream.STREAM_AUTHD_EVENT, authenticated)
xs.sid = u'1234'
theHash = '32532c0f7dbf1253c095b18b18e36d38d94c1256'
xs.authenticator.onHandshake(theHash)
self.assertEqual('', self.output[-1])
self.assertEquals(1, len(authd))
def test_onHandshakeWrongHash(self):
"""
Receiving a bad handshake should yield a stream error.
"""
streamErrors = []
authd = []
def authenticated(xs):
authd.append(xs)
xs = self.xmlstream
xs.addOnetimeObserver(xmlstream.STREAM_AUTHD_EVENT, authenticated)
xs.sendStreamError = streamErrors.append
xs.sid = u'1234'
theHash = '1234'
xs.authenticator.onHandshake(theHash)
self.assertEquals('not-authorized', streamErrors[-1].condition)
self.assertEquals(0, len(authd))
class XMPPComponentServerFactoryTest(unittest.TestCase):
"""
Tests for L{component.XMPPComponentServerFactory}.
"""
def setUp(self):
self.router = component.Router()
self.factory = component.XMPPComponentServerFactory(self.router,
'secret')
self.xmlstream = self.factory.buildProtocol(None)
self.xmlstream.thisEntity = JID('component.example.org')
def test_makeConnection(self):
"""
A new connection increases the stream serial count. No logs by default.
"""
self.xmlstream.dispatch(self.xmlstream,
xmlstream.STREAM_CONNECTED_EVENT)
self.assertEqual(0, self.xmlstream.serial)
self.assertEqual(1, self.factory.serial)
self.assertIdentical(None, self.xmlstream.rawDataInFn)
self.assertIdentical(None, self.xmlstream.rawDataOutFn)
def test_makeConnectionLogTraffic(self):
"""
Setting logTraffic should set up raw data loggers.
"""
self.factory.logTraffic = True
self.xmlstream.dispatch(self.xmlstream,
xmlstream.STREAM_CONNECTED_EVENT)
self.assertNotIdentical(None, self.xmlstream.rawDataInFn)
self.assertNotIdentical(None, self.xmlstream.rawDataOutFn)
def test_onError(self):
"""
An observer for stream errors should trigger onError to log it.
"""
self.xmlstream.dispatch(self.xmlstream,
xmlstream.STREAM_CONNECTED_EVENT)
class TestError(Exception):
pass
reason = failure.Failure(TestError())
self.xmlstream.dispatch(reason, xmlstream.STREAM_ERROR_EVENT)
self.assertEqual(1, len(self.flushLoggedErrors(TestError)))
def test_connectionInitialized(self):
"""
Make sure a new stream is added to the routing table.
"""
self.xmlstream.dispatch(self.xmlstream, xmlstream.STREAM_AUTHD_EVENT)
self.assertIn('component.example.org', self.router.routes)
self.assertIdentical(self.xmlstream,
self.router.routes['component.example.org'])
def test_connectionLost(self):
"""
Make sure a stream is removed from the routing table on disconnect.
"""
self.xmlstream.dispatch(self.xmlstream, xmlstream.STREAM_AUTHD_EVENT)
self.xmlstream.dispatch(None, xmlstream.STREAM_END_EVENT)
self.assertNotIn('component.example.org', self.router.routes)
wokkel-0.7.1/wokkel/test/test_xmppim.py 0000664 0001750 0001750 00000123650 12074337005 021013 0 ustar ralphm ralphm 0000000 0000000 # Copyright (c) Ralph Meijer.
# See LICENSE for details
"""
Tests for L{wokkel.xmppim}.
"""
from twisted.internet import defer
from twisted.trial import unittest
from twisted.words.protocols.jabber import error
from twisted.words.protocols.jabber.jid import JID
from twisted.words.protocols.jabber.xmlstream import toResponse
from twisted.words.xish import domish, utility
from wokkel import xmppim
from wokkel.generic import ErrorStanza, parseXml
from wokkel.test.helpers import TestableRequestHandlerMixin, XmlStreamStub
NS_XML = 'http://www.w3.org/XML/1998/namespace'
NS_ROSTER = 'jabber:iq:roster'
class PresenceClientProtocolTest(unittest.TestCase):
def setUp(self):
self.output = []
self.protocol = xmppim.PresenceClientProtocol()
self.protocol.parent = self
def send(self, obj):
self.output.append(obj)
def test_unavailableDirected(self):
"""
Test sending of directed unavailable presence broadcast.
"""
self.protocol.unavailable(JID('user@example.com'))
presence = self.output[-1]
self.assertEquals("presence", presence.name)
self.assertEquals(None, presence.uri)
self.assertEquals("user@example.com", presence.getAttribute('to'))
self.assertEquals("unavailable", presence.getAttribute('type'))
def test_unavailableWithStatus(self):
"""
Test sending of directed unavailable presence broadcast with status.
"""
self.protocol.unavailable(JID('user@example.com'),
{None: 'Disconnected'})
presence = self.output[-1]
self.assertEquals("presence", presence.name)
self.assertEquals(None, presence.uri)
self.assertEquals("user@example.com", presence.getAttribute('to'))
self.assertEquals("unavailable", presence.getAttribute('type'))
self.assertEquals("Disconnected", unicode(presence.status))
def test_unavailableBroadcast(self):
"""
Test sending of unavailable presence broadcast.
"""
self.protocol.unavailable(None)
presence = self.output[-1]
self.assertEquals("presence", presence.name)
self.assertEquals(None, presence.uri)
self.assertEquals(None, presence.getAttribute('to'))
self.assertEquals("unavailable", presence.getAttribute('type'))
def test_unavailableBroadcastNoEntityParameter(self):
"""
Test sending of unavailable presence broadcast by not passing entity.
"""
self.protocol.unavailable()
presence = self.output[-1]
self.assertEquals("presence", presence.name)
self.assertEquals(None, presence.uri)
self.assertEquals(None, presence.getAttribute('to'))
self.assertEquals("unavailable", presence.getAttribute('type'))
class AvailabilityPresenceTest(unittest.TestCase):
def test_fromElement(self):
xml = """
chat
Let's chat!
50
"""
presence = xmppim.AvailabilityPresence.fromElement(parseXml(xml))
self.assertEquals(JID('user@example.org'), presence.sender)
self.assertEquals(JID('user@example.com'), presence.recipient)
self.assertTrue(presence.available)
self.assertEquals('chat', presence.show)
self.assertEquals({None: "Let's chat!"}, presence.statuses)
self.assertEquals(50, presence.priority)
class PresenceProtocolTest(unittest.TestCase):
"""
Tests for L{xmppim.PresenceProtocol}
"""
def setUp(self):
self.output = []
self.protocol = xmppim.PresenceProtocol()
self.protocol.parent = self
self.protocol.xmlstream = utility.EventDispatcher()
self.protocol.connectionInitialized()
def send(self, obj):
self.output.append(obj)
def test_errorReceived(self):
"""
Incoming presence stanzas are parsed and dispatched.
"""
xml = """"""
def errorReceived(error):
xmppim.PresenceProtocol.errorReceived(self.protocol, error)
try:
self.assertIsInstance(error, ErrorStanza)
except:
d.errback()
else:
d.callback(None)
d = defer.Deferred()
self.protocol.errorReceived = errorReceived
self.protocol.xmlstream.dispatch(parseXml(xml))
return d
def test_availableReceived(self):
"""
Incoming presence stanzas are parsed and dispatched.
"""
xml = """"""
def availableReceived(presence):
xmppim.PresenceProtocol.availableReceived(self.protocol, presence)
try:
self.assertIsInstance(presence, xmppim.AvailabilityPresence)
except:
d.errback()
else:
d.callback(None)
d = defer.Deferred()
self.protocol.availableReceived = availableReceived
self.protocol.xmlstream.dispatch(parseXml(xml))
return d
def test_unavailableReceived(self):
"""
Incoming presence stanzas are parsed and dispatched.
"""
xml = """"""
def unavailableReceived(presence):
xmppim.PresenceProtocol.unavailableReceived(self.protocol, presence)
try:
self.assertIsInstance(presence, xmppim.AvailabilityPresence)
except:
d.errback()
else:
d.callback(None)
d = defer.Deferred()
self.protocol.unavailableReceived = unavailableReceived
self.protocol.xmlstream.dispatch(parseXml(xml))
return d
def test_subscribeReceived(self):
"""
Incoming presence stanzas are parsed and dispatched.
"""
xml = """"""
def subscribeReceived(presence):
xmppim.PresenceProtocol.subscribeReceived(self.protocol, presence)
try:
self.assertIsInstance(presence, xmppim.SubscriptionPresence)
except:
d.errback()
else:
d.callback(None)
d = defer.Deferred()
self.protocol.subscribeReceived = subscribeReceived
self.protocol.xmlstream.dispatch(parseXml(xml))
return d
def test_unsubscribeReceived(self):
"""
Incoming presence stanzas are parsed and dispatched.
"""
xml = """"""
def unsubscribeReceived(presence):
xmppim.PresenceProtocol.unsubscribeReceived(self.protocol, presence)
try:
self.assertIsInstance(presence, xmppim.SubscriptionPresence)
except:
d.errback()
else:
d.callback(None)
d = defer.Deferred()
self.protocol.unsubscribeReceived = unsubscribeReceived
self.protocol.xmlstream.dispatch(parseXml(xml))
return d
def test_subscribedReceived(self):
"""
Incoming presence stanzas are parsed and dispatched.
"""
xml = """"""
def subscribedReceived(presence):
xmppim.PresenceProtocol.subscribedReceived(self.protocol, presence)
try:
self.assertIsInstance(presence, xmppim.SubscriptionPresence)
except:
d.errback()
else:
d.callback(None)
d = defer.Deferred()
self.protocol.subscribedReceived = subscribedReceived
self.protocol.xmlstream.dispatch(parseXml(xml))
return d
def test_unsubscribedReceived(self):
"""
Incoming presence stanzas are parsed and dispatched.
"""
xml = """"""
def unsubscribedReceived(presence):
xmppim.PresenceProtocol.unsubscribedReceived(self.protocol,
presence)
try:
self.assertIsInstance(presence, xmppim.SubscriptionPresence)
except:
d.errback()
else:
d.callback(None)
d = defer.Deferred()
self.protocol.unsubscribedReceived = unsubscribedReceived
self.protocol.xmlstream.dispatch(parseXml(xml))
return d
def test_probeReceived(self):
"""
Incoming presence stanzas are parsed and dispatched.
"""
xml = """"""
def probeReceived(presence):
xmppim.PresenceProtocol.probeReceived(self.protocol, presence)
try:
self.assertIsInstance(presence, xmppim.ProbePresence)
except:
d.errback()
else:
d.callback(None)
d = defer.Deferred()
self.protocol.probeReceived = probeReceived
self.protocol.xmlstream.dispatch(parseXml(xml))
return d
def test_available(self):
"""
It should be possible to pass a sender address.
"""
self.protocol.available(JID('user@example.com'),
show=u'chat',
status=u'Talk to me!',
priority=50)
element = self.output[-1]
self.assertEquals("user@example.com", element.getAttribute('to'))
self.assertIdentical(None, element.getAttribute('type'))
self.assertEquals(u'chat', unicode(element.show))
self.assertEquals(u'Talk to me!', unicode(element.status))
self.assertEquals(u'50', unicode(element.priority))
def test_availableLanguages(self):
"""
It should be possible to pass a sender address.
"""
self.protocol.available(JID('user@example.com'),
show=u'chat',
statuses={None: u'Talk to me!',
'nl': u'Praat met me!'},
priority=50)
element = self.output[-1]
self.assertEquals("user@example.com", element.getAttribute('to'))
self.assertIdentical(None, element.getAttribute('type'))
self.assertEquals(u'chat', unicode(element.show))
statuses = {}
for status in element.elements():
if status.name == 'status':
lang = status.getAttribute((NS_XML, 'lang'))
statuses[lang] = unicode(status)
self.assertIn(None, statuses)
self.assertEquals(u'Talk to me!', statuses[None])
self.assertIn('nl', statuses)
self.assertEquals(u'Praat met me!', statuses['nl'])
self.assertEquals(u'50', unicode(element.priority))
def test_availableSender(self):
"""
It should be possible to pass a sender address.
"""
self.protocol.available(JID('user@example.com'),
sender=JID('user@example.org'))
element = self.output[-1]
self.assertEquals("user@example.org", element.getAttribute('from'))
def test_unavailableDirected(self):
"""
Test sending of directed unavailable presence broadcast.
"""
self.protocol.unavailable(JID('user@example.com'))
element = self.output[-1]
self.assertEquals("presence", element.name)
self.assertEquals(None, element.uri)
self.assertEquals("user@example.com", element.getAttribute('to'))
self.assertEquals("unavailable", element.getAttribute('type'))
def test_unavailableWithStatus(self):
"""
Test sending of directed unavailable presence broadcast with status.
"""
self.protocol.unavailable(JID('user@example.com'),
{None: 'Disconnected'})
element = self.output[-1]
self.assertEquals("presence", element.name)
self.assertEquals(None, element.uri)
self.assertEquals("user@example.com", element.getAttribute('to'))
self.assertEquals("unavailable", element.getAttribute('type'))
self.assertEquals("Disconnected", unicode(element.status))
def test_unavailableBroadcast(self):
"""
Test sending of unavailable presence broadcast.
"""
self.protocol.unavailable(None)
element = self.output[-1]
self.assertEquals("presence", element.name)
self.assertEquals(None, element.uri)
self.assertEquals(None, element.getAttribute('to'))
self.assertEquals("unavailable", element.getAttribute('type'))
def test_unavailableBroadcastNoRecipientParameter(self):
"""
Test sending of unavailable presence broadcast by not passing entity.
"""
self.protocol.unavailable()
element = self.output[-1]
self.assertEquals("presence", element.name)
self.assertEquals(None, element.uri)
self.assertEquals(None, element.getAttribute('to'))
self.assertEquals("unavailable", element.getAttribute('type'))
def test_unavailableSender(self):
"""
It should be possible to pass a sender address.
"""
self.protocol.unavailable(JID('user@example.com'),
sender=JID('user@example.org'))
element = self.output[-1]
self.assertEquals("user@example.org", element.getAttribute('from'))
def test_subscribeSender(self):
"""
It should be possible to pass a sender address.
"""
self.protocol.subscribe(JID('user@example.com'),
sender=JID('user@example.org'))
element = self.output[-1]
self.assertEquals("user@example.org", element.getAttribute('from'))
def test_unsubscribeSender(self):
"""
It should be possible to pass a sender address.
"""
self.protocol.unsubscribe(JID('user@example.com'),
sender=JID('user@example.org'))
element = self.output[-1]
self.assertEquals("user@example.org", element.getAttribute('from'))
def test_subscribedSender(self):
"""
It should be possible to pass a sender address.
"""
self.protocol.subscribed(JID('user@example.com'),
sender=JID('user@example.org'))
element = self.output[-1]
self.assertEquals("user@example.org", element.getAttribute('from'))
def test_unsubscribedSender(self):
"""
It should be possible to pass a sender address.
"""
self.protocol.unsubscribed(JID('user@example.com'),
sender=JID('user@example.org'))
element = self.output[-1]
self.assertEquals("user@example.org", element.getAttribute('from'))
def test_probeSender(self):
"""
It should be possible to pass a sender address.
"""
self.protocol.probe(JID('user@example.com'),
sender=JID('user@example.org'))
element = self.output[-1]
self.assertEquals("user@example.org", element.getAttribute('from'))
class RosterItemTest(unittest.TestCase):
"""
Tests for L{xmppim.RosterItem}.
"""
def test_toElement(self):
"""
A roster item has the correct namespace/name, lacks unset attributes.
"""
item = xmppim.RosterItem(JID('user@example.org'))
element = item.toElement()
self.assertEqual('item', element.name)
self.assertEqual(NS_ROSTER, element.uri)
self.assertFalse(element.hasAttribute('subscription'))
self.assertFalse(element.hasAttribute('ask'))
self.assertEqual(u"", element.getAttribute('name', u""))
self.assertFalse(element.hasAttribute('approved'))
self.assertEquals(0, len(list(element.elements())))
def test_toElementMinimal(self):
"""
A bare roster item only has a jid attribute.
"""
item = xmppim.RosterItem(JID('user@example.org'))
element = item.toElement()
self.assertEqual(u'user@example.org', element.getAttribute('jid'))
def test_toElementSubscriptionNone(self):
"""
A roster item with no subscription has no subscription attribute.
"""
item = xmppim.RosterItem(JID('user@example.org'),
subscriptionTo=False,
subscriptionFrom=False)
element = item.toElement()
self.assertIdentical(None, element.getAttribute('subscription'))
def test_toElementSubscriptionTo(self):
"""
A roster item with subscriptionTo set has subscription 'to'.
"""
item = xmppim.RosterItem(JID('user@example.org'),
subscriptionTo=True,
subscriptionFrom=False)
element = item.toElement()
self.assertEqual('to', element.getAttribute('subscription'))
def test_toElementSubscriptionFrom(self):
"""
A roster item with subscriptionFrom set has subscription 'to'.
"""
item = xmppim.RosterItem(JID('user@example.org'),
subscriptionTo=False,
subscriptionFrom=True)
element = item.toElement()
self.assertEqual('from', element.getAttribute('subscription'))
def test_toElementSubscriptionBoth(self):
"""
A roster item with mutual subscription has subscription 'both'.
"""
item = xmppim.RosterItem(JID('user@example.org'),
subscriptionTo=True,
subscriptionFrom=True)
element = item.toElement()
self.assertEqual('both', element.getAttribute('subscription'))
def test_toElementSubscriptionRemove(self):
"""
A roster item with remove set has subscription 'remove'.
"""
item = xmppim.RosterItem(JID('user@example.org'))
item.remove = True
element = item.toElement()
self.assertEqual('remove', element.getAttribute('subscription'))
def test_toElementAsk(self):
"""
A roster item with pendingOut set has subscription 'ask'.
"""
item = xmppim.RosterItem(JID('user@example.org'))
item.pendingOut = True
element = item.toElement()
self.assertEqual('subscribe', element.getAttribute('ask'))
def test_toElementName(self):
"""
A roster item's name is rendered to the 'name' attribute.
"""
item = xmppim.RosterItem(JID('user@example.org'),
name='Joe User')
element = item.toElement()
self.assertEqual(u'Joe User', element.getAttribute('name'))
def test_toElementGroups(self):
"""
A roster item's groups are rendered as 'group' child elements.
"""
groups = set(['Friends', 'Jabber'])
item = xmppim.RosterItem(JID('user@example.org'),
groups=groups)
element = item.toElement()
foundGroups = set()
for child in element.elements():
if child.uri == NS_ROSTER and child.name == 'group':
foundGroups.add(unicode(child))
self.assertEqual(groups, foundGroups)
def test_toElementApproved(self):
"""
A pre-approved subscription for a roster item has an 'approved' flag.
"""
item = xmppim.RosterItem(JID('user@example.org'))
item.approved = True
element = item.toElement()
self.assertEqual(u'true', element.getAttribute('approved'))
def test_fromElementMinimal(self):
"""
A minimal roster item has a reference to the JID of the contact.
"""
xml = """
-
Friends
Twisted
"""
item = xmppim.RosterItem.fromElement(parseXml(xml))
self.assertIn(u"Twisted", item.groups)
self.assertIn(u"Friends", item.groups)
def test_fromElementSubscriptionNone(self):
"""
Subscription 'none' sets both attributes to False.
"""
xml = """