source: ralphm-patches/c2s_stanza_handlers.patch

wokkel/client.py

@@ -20 +20 @@
 from twisted.words.protocols.jabber import client, error, sasl, xmlstream
 from twisted.words.xish import domish
 
-from wokkel import generic
+from wokkel import generic, xmppim
 from wokkel.iwokkel import IUserSession
 from wokkel.subprotocols import ServerStreamManager
 from wokkel.subprotocols import StreamManager
@@ -548 +548 @@
         return [
             generic.StanzaForwarder(),
             RecipientAddressStamper(),
+            xmppim.UserSessionPresenceProtocol(),
+            xmppim.UserRosterProtocol(),
             ]

wokkel/test/test_xmppim.py

@@ -5 +5 @@
 Tests for L{wokkel.xmppim}.
 """
 
-from zope.interface import verify
+from zope.interface import implementer, verify
 
 from twisted.cred import checkers, error as ecred
 from twisted.cred.portal import IRealm
@@ -17 +17 @@
 from twisted.words.xish import domish, utility
 
 from wokkel import ewokkel, component, xmppim
-from wokkel.generic import ErrorStanza, parseXml
+from wokkel.generic import ErrorStanza, Stanza, parseXml
 from wokkel.test.helpers import TestableRequestHandlerMixin, XmlStreamStub
 from wokkel.subprotocols import IQHandlerMixin
 
@@ -2031 +2031 @@
         d = self.sessionManager.probePresence(user)
         d.addCallback(cb)
         return d
+
+
+
+class AccountIQHandlerTest(unittest.TestCase):
+    """
+    Tests for L{xmppim.AccountIQHandler}.
+    """
+
+    def setUp(self):
+        self.user = xmppim.User(JID(u'user@example.org'))
+        users = {self.user.entity: self.user}
+        realm = xmppim.StaticRealm(u'example.org', users)
+
+        self.stub = XmlStreamStub()
+        self.protocol = xmppim.AccountIQHandler(realm)
+        self.protocol.makeConnection(self.stub.xmlstream)
+        self.protocol.connectionInitialized()
+
+
+    def test_onIQ(self):
+        """
+        IQ stanzas are observed.
+        """
+        received = []
+        self.patch(self.protocol, 'iqReceived', received.append)
+
+        xml = """
+          <iq to='user@example.org/Home' from='contact@example.com/Work'>
+            <query xmlns='jabber:iq:version'/>
+          </iq>
+        """
+
+        iq = parseXml(xml)
+        self.stub.send(iq)
+
+        self.assertEqual(1, len(received))
+        stanza = received[-1]
+        self.assertEqual(JID(u'user@example.org/Home'), stanza.recipient)
+
+
+    def test_onIQNotUser(self):
+        """
+        IQs to JIDs without local part are ignored.
+        """
+        xml = """
+          <iq to='example.org' from='contact@example.com/Work'>
+            <query xmlns='jabber:iq:version'/>
+          </iq>
+        """
+
+        iq = parseXml(xml)
+        self.stub.send(iq)
+
+        self.assertFalse(getattr(iq, 'handled'))
+
+
+    def test_onIQNoResource(self):
+        """
+        IQs to JIDs without resource are ignored.
+        """
+        xml = """
+          <iq to='user@example.org' from='contact@example.com/Work'>
+            <query xmlns='jabber:iq:version'/>
+          </iq>
+        """
+
+        iq = parseXml(xml)
+        self.stub.send(iq)
+
+        self.assertFalse(getattr(iq, 'handled'))
+
+
+    def test_iqReceivedDelivered(self):
+        """
+        IQs are delivered to the user's deliverIQ method.
+        """
+        received = []
+        self.patch(self.user, 'deliverIQ', received.append)
+
+        stanza = Stanza(recipient=JID(u'user@example.org/Home'),
+                        sender=JID(u'contact@example.com/Work'))
+        stanza.stanzaKind = u'iq'
+        stanza.stanzaType = u'get'
+        self.protocol.iqReceived(stanza)
+        self.assertEqual([stanza], received)
+
+
+    def test_iqReceivedNoSuchUser(self):
+        """
+        IQs are delivered to the user's deliverIQ method.
+        """
+        def deliverIQ(stanza):
+            raise ewokkel.NoSuchUser()
+
+        def cb(error):
+            self.assertEqual('service-unavailable', error.condition)
+
+        self.patch(self.user, 'deliverIQ', deliverIQ)
+
+        stanza = Stanza(recipient=JID(u'other@example.org/Home'),
+                        sender=JID(u'contact@example.com/Work'))
+        stanza.stanzaKind = u'iq'
+        stanza.stanzaType = u'get'
+        d = self.protocol.iqReceived(stanza)
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+
+class AccountMessageHandlerTest(unittest.TestCase):
+    """
+    Tests for L{xmppim.AccountMessageHandler}.
+    """
+
+    def setUp(self):
+        self.user = xmppim.User(JID(u'test@example.org'))
+        users = {self.user.entity: self.user}
+        realm = xmppim.StaticRealm(u'example.org', users)
+
+        self.stub = XmlStreamStub()
+        self.protocol = xmppim.AccountMessageHandler(realm)
+        self.protocol.makeConnection(self.stub.xmlstream)
+        self.protocol.connectionInitialized()
+
+
+    def test_messageReceived(self):
+        """
+        Message stanzas are observed.
+        """
+        received = []
+        self.patch(self.protocol, 'messageReceived', received.append)
+
+        xml = """
+          <message to='example.org'>
+            <body>Hello</body>
+          </message>
+        """
+
+        message = parseXml(xml)
+        self.stub.send(message)
+
+        self.assertEqual(1, len(received))
+        stanza = received[-1]
+        self.assertEqual(u'Hello', stanza.body)
+
+
+    def test_messageReceivedNotUser(self):
+        """
+        Messages to JIDs without local part are ignored.
+
+        This also tests the observer that is set up to handle message stanzas.
+        """
+        xml = """
+          <message to='example.org'>
+            <body>Hello</body>
+          </message>
+        """
+
+        message = parseXml(xml)
+        self.stub.send(message)
+
+        self.assertFalse(getattr(message, 'handled'))
+
+
+    def test_messageReceivedDelivered(self):
+        """
+        Messages are delivered to the user's deliverMessage method.
+        """
+        received = []
+        self.patch(self.user, 'deliverMessage', received.append)
+
+        stanza = xmppim.Message(recipient=JID(u'test@example.org'),
+                                sender=JID(u'other@example.com'))
+        self.protocol.messageReceived(stanza)
+        self.assertEqual([stanza], received)
+
+
+    def test_messageReceivedNotImplemented(self):
+        """
+        If NotImplementedError is raised, service-available is returned.
+        """
+        def deliverMessage(stanza):
+            raise NotImplementedError()
+
+        def cb(error):
+            self.assertEqual('service-unavailable', error.condition)
+
+        self.patch(self.user, 'deliverMessage', deliverMessage)
+
+        stanza = xmppim.Message(recipient=JID(u'test@example.org'),
+                                sender=JID(u'other@example.com'))
+        d = self.protocol.messageReceived(stanza)
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+@implementer(xmppim.IUserSession)
+class FakeUserSession(xmppim.UserSession):
+
+    def __init__(self, *args, **kwargs):
+        super(FakeUserSession, self).__init__(*args, **kwargs)
+        self.broadcastPresenceCalls = []
+
+
+    def broadcastPresence(self, presence):
+        self.broadcastPresenceCalls.append(presence)
+
+
+
+class FakeUserSessionTest(unittest.TestCase):
+    """
+    Tests for L{FakeUserSessionTest}.
+    """
+
+    def test_interface(self):
+        verify.verifyObject(xmppim.IUserSession, FakeUserSession(None))
+
+
+
+class UserSessionPresenceProtocolTest(unittest.TestCase):
+    """
+    Tests for L{xmppim.UserSessionPresenceProtocol}.
+    """
+
+    def setUp(self):
+        self.stub = XmlStreamStub()
+        self.protocol = xmppim.UserSessionPresenceProtocol()
+        self.protocol.makeConnection(self.stub.xmlstream)
+
+        entity = JID(u'user@example.org')
+        user = xmppim.User(entity)
+        user.roster = xmppim.InMemoryRoster([])
+
+        self.session = FakeUserSession(user)
+        self.stub.xmlstream.avatar = self.session
+
+
+    def test_availableReceivedDirected(self):
+        """
+        The directed available stanza is passed for delivery.
+        """
+        stanza = xmppim.AvailabilityPresence(
+                recipient=JID(u'contact@example.org'),
+                sender=JID(u'user@example.org'),
+                available=True)
+
+        self.assertFalse(self.protocol.availableReceived(stanza))
+
+
+    def test_availableReceivedBroadcast(self):
+        """
+        Availabilty is broadcast to contacts and presence is probed.
+        """
+        stanza = xmppim.AvailabilityPresence(
+                sender=JID(u'user@example.org'),
+                available=True)
+
+        self.assertTrue(self.protocol.availableReceived(stanza))
+        self.assertEqual(1, len(self.session.broadcastPresenceCalls))
+        presence = self.session.broadcastPresenceCalls[-1]
+        self.assertIdentical(stanza, presence)
+        self.assertTrue(presence.available)
+
+
+    def test_unavailableReceivedDirected(self):
+        """
+        The directed available stanza is passed for delivery.
+        """
+        stanza = xmppim.AvailabilityPresence(
+                recipient=JID(u'contact@example.org'),
+                sender=JID(u'user@example.org'),
+                available=False)
+
+        self.assertFalse(self.protocol.unavailableReceived(stanza))
+
+
+    def test_unavailableReceivedBroadcast(self):
+        """
+        Unavailabilty is broadcast to contacts.
+        """
+        stanza = xmppim.AvailabilityPresence(
+                sender=JID(u'user@example.org'),
+                available=False)
+
+        self.assertTrue(self.protocol.unavailableReceived(stanza))
+        self.assertEqual(1, len(self.session.broadcastPresenceCalls))
+        presence = self.session.broadcastPresenceCalls[-1]
+        self.assertIdentical(stanza, presence)
+        self.assertFalse(presence.available)
+
+
+    def test_subscribedReceived(self):
+        """
+        The subscription approval stanza is passed for delivery.
+        """
+        stanza = xmppim.SubscriptionPresence(
+                recipient=JID(u'contact@example.org'),
+                sender=JID(u'user@example.org'))
+        stanza.stanzaType = u'subscribed'
+
+        self.assertFalse(self.protocol.unsubscribedReceived(stanza))
+
+
+    def test_subscribedReceivedFullJID(self):
+        """
+        The resource is stripped from full JIDs for subscription approval.
+        """
+        stanza = xmppim.SubscriptionPresence(
+                recipient=JID(u'contact@example.org/Home'),
+                sender=JID(u'user@example.org'))
+        stanza.stanzaType = u'subscribed'
+        stanza.toElement()
+
+        self.protocol.subscribedReceived(stanza)
+        self.assertEqual(u'contact@example.org', stanza.element['to'])
+
+
+    def test_unsubscribedReceived(self):
+        """
+        The subscription cancellation stanza is passed for delivery.
+        """
+        stanza = xmppim.SubscriptionPresence(
+                recipient=JID(u'contact@example.org'),
+                sender=JID(u'user@example.org'))
+        stanza.stanzaType = u'unsubscribed'
+
+        self.assertFalse(self.protocol.unsubscribedReceived(stanza))
+
+
+    def test_unsubscribedReceivedFullJID(self):
+        """
+        The resource is stripped from full JIDs for subscription cancellation.
+        """
+        stanza = xmppim.SubscriptionPresence(
+                recipient=JID(u'contact@example.org/Home'),
+                sender=JID(u'user@example.org'))
+        stanza.stanzaType = u'unsubscribed'
+        stanza.toElement()
+
+        self.protocol.unsubscribedReceived(stanza)
+        self.assertEqual(u'contact@example.org', stanza.element['to'])
+
+
+    def test_subscribeReceived(self):
+        """
+        The subscribe request stanza is passed for delivery.
+        """
+        stanza = xmppim.SubscriptionPresence(
+                recipient=JID(u'contact@example.org'),
+                sender=JID(u'user@example.org'))
+        stanza.stanzaType = u'subscribe'
+
+        self.assertFalse(self.protocol.subscribedReceived(stanza))
+
+
+    def test_subscribeReceivedFullJID(self):
+        """
+        The resource is stripped from full JIDs for subscribe requests.
+        """
+        stanza = xmppim.SubscriptionPresence(
+                recipient=JID(u'contact@example.org/Home'),
+                sender=JID(u'user@example.org'))
+        stanza.stanzaType = u'subscribe'
+        stanza.toElement()
+
+        self.protocol.subscribeReceived(stanza)
+        self.assertEqual(u'contact@example.org', stanza.element['to'])
+
+
+    def test_unsubscribeReceived(self):
+        """
+        The unsubscribe request stanza is passed for delivery.
+        """
+        stanza = xmppim.SubscriptionPresence(
+                recipient=JID(u'contact@example.org'),
+                sender=JID(u'user@example.org'))
+        stanza.stanzaType = u'unsubscribe'
+
+        self.assertFalse(self.protocol.unsubscribeReceived(stanza))
+
+
+    def test_unsubscribeReceivedFullJID(self):
+        """
+        The resource is stripped from full JIDs for unsubscribe requests.
+        """
+        stanza = xmppim.SubscriptionPresence(
+                recipient=JID(u'contact@example.org/Home'),
+                sender=JID(u'user@example.org'))
+        stanza.stanzaType = u'unsubscribe'
+        stanza.toElement()
+
+        self.protocol.unsubscribeReceived(stanza)
+        self.assertEqual(u'contact@example.org', stanza.element['to'])
+
+
+    def test_probeReceived(self):
+        """
+        The probe stanza is passed for delivery.
+        """
+        stanza = xmppim.ProbePresence(
+                recipient=JID(u'contact@example.org'),
+                sender=JID(u'user@example.org'))
+
+        self.assertFalse(self.protocol.probeReceived(stanza))
+
+

wokkel/xmppim.py

@@ -417 +417 @@
 
 
 
+    def parsePresence(self, element):
+        stanza = Stanza.fromElement(element)
+
+        presenceType = stanza.stanzaType or 'available'
+
+        try:
+            parser = self.presenceTypeParserMap[presenceType]
+        except KeyError:
+            return
+
+        return parser.fromElement(element)
+
+
+    @asyncObserver
     def _onPresence(self, element):
         """
         Called when a presence stanza has been received.
         """
-        stanza = Stanza.fromElement(element)
-
-        presenceType = stanza.stanzaType or 'available'
-
-        try:
-            parser = self.presenceTypeParserMap[presenceType]
-        except KeyError:
-            return
-
-        presence = parser.fromElement(element)
+        presence = self.parsePresence(element)
+        presenceType = presence.stanzaType or 'available'
 
         try:
             handler = getattr(self, '%sReceived' % presenceType)
         except AttributeError:
-            return
+            return False
         else:
-            handler(presence)
+            return handler(presence)
 
 
 
@@ -1188 +1194 @@
         L{Message}.
     """
 
+    observerPriority = 0
     messageFactory = Message
 
     def connectionInitialized(self):
-        self.xmlstream.addObserver("/message", self._onMessage)
+        self.xmlstream.addObserver("/message", self._onMessage,
+                                   self.observerPriority)
 
 
     @asyncObserver
@@ -1693 +1701 @@
             presence = ProbePresence(recipient=entity,
                                      sender=user.entity)
             self.routeOrDeliver(presence.toElement())
+
+
+
+class AccountIQHandler(XMPPHandler):
+
+    def __init__(self, realm):
+        XMPPHandler.__init__(self)
+        self.realm = realm
+
+
+    def connectionMade(self):
+        self.xmlstream.addObserver('/iq', self._onIQ, 1)
+
+
+    @asyncObserver
+    def _onIQ(self, element):
+        stanza = Stanza.fromElement(element)
+        return self.iqReceived(stanza)
+
+
+    def iqReceived(self, iq):
+        """
+        Handler for iq stazas to user accounts' connected resources.
+
+        If the recipient is a bare JID or there is no associated user, this
+        handler ignores the stanza, so that other handlers have a chance
+        to pick it up. If used, L{generic.FallbackHandler} will respond with a
+        C{'service-unavailable'} stanza error if no other handlers handle
+        the iq.
+        """
+        if not iq.recipient.user:
+            # This is not for a user.
+            return False
+        elif not iq.recipient.resource:
+            # This might be picked up by another handler.
+            return False
+
+        def gotUser(user):
+            user.deliverIQ(iq)
+
+        def notFound(failure):
+            failure.trap(NoSuchResource, NoSuchUser)
+            raise error.StanzaError('service-unavailable')
+
+        d = self.realm.lookupUser(iq.recipient.userhostJID())
+        d.addCallback(gotUser)
+        d.addErrback(notFound)
+        return d
+
+
+
+class AccountMessageHandler(MessageProtocol):
+
+    observerPriority = 1
+
+    def __init__(self, realm):
+        MessageProtocol.__init__(self)
+        self.realm = realm
+
+
+    def messageReceived(self, message):
+        """
+        Handler for message stanzas to user accounts.
+        """
+        if not message.recipient.user:
+            # This is not for a user.
+            return False
+
+        def gotUser(user):
+            user.deliverMessage(message)
+
+        def eb(failure):
+            failure.trap(NoSuchUser, NoSuchResource, NotImplementedError)
+            raise error.StanzaError('service-unavailable')
+
+        d = self.realm.lookupUser(message.recipient.userhostJID())
+        d.addCallback(gotUser)
+        d.addErrback(eb)
+        return d
+
+
+
+class AccountPresenceHandler(PresenceProtocol):
+
+    def __init__(self, realm):
+        PresenceProtocol.__init__(self)
+        self.realm = realm
+
+
+    def _deliverPresence(self, presence):
+        if not presence.recipient.user:
+            # This is not for a user.
+            return False
+
+        def gotUser(user):
+            user.deliverPresence(presence)
+
+        def notFound(failure):
+            failure.trap(NoSuchResource, NoSuchUser)
+            return
+
+        d = self.realm.lookupUser(presence.recipient.userhostJID())
+        d.addCallback(gotUser)
+        d.addErrback(notFound)
+        return d
+
+
+    def availableReceived(self, presence):
+        return self._deliverPresence(presence)
+
+
+    def unavailableReceived(self, presence):
+        return self._deliverPresence(presence)
+
+
+    def subscribedReceived(self, presence):
+        log.msg("%r subscribed %s to its presence" % (presence.sender,
+                                                      presence.recipient))
+        return self._deliverPresence(presence)
+
+
+    def unsubscribedReceived(self, presence):
+        log.msg("%r unsubscribed %s from its presence" % (presence.sender,
+                                                          presence.recipient))
+        return self._deliverPresence(presence)
+
+
+    def subscribeReceived(self, presence):
+        log.msg("%r requests subscription to %s" % (presence.sender,
+                                                    presence.recipient))
+        return self._deliverPresence(presence)
+
+
+    def unsubscribeReceived(self, presence):
+        log.msg("%r requests unsubscription from %s" % (presence.sender,
+                                                        presence.recipient))
+        return self._deliverPresence(presence)
+
+
+    def probeReceived(self, presence):
+        if not presence.recipient.user:
+            # This is not for a user.
+            return False
+
+        def gotUser(user):
+            return user.getPresences(presence.sender.userhostJID())
+
+        def notSubscribed(failure):
+            failure.trap(NoSuchUser, NotSubscribed)
+            response = SubscriptionPresence(recipient=presence.sender,
+                                            sender=presence.recipient)
+            response.stanzaType = 'unsubscribed'
+            return [response]
+
+        def sendPresences(userPresences):
+            for userPresence in userPresences:
+                self.parent.multicast(userPresence, [presence.sender])
+
+        d = self.realm.lookupUser(presence.recipient.userhostJID())
+        d.addCallback(gotUser)
+        d.addErrback(notSubscribed)
+        d.addCallback(sendPresences)
+        return d
+
+
+
+class UserSessionPresenceProtocol(PresenceProtocol):
+    """
+    Presence protocol for user client sessions.
+    """
+
+    def _stampContactJID(self, presence):
+        """
+        Stamp the contact JID to be a bare JID.
+        """
+        if presence.recipient.resource:
+            contactJID = presence.recipient.userhostJID()
+            presence.element['to'] = contactJID.userhost()
+
+
+    def availableReceived(self, presence):
+        if presence.recipient:
+            # Pass through directed presence.
+            return False
+        else:
+            session = self.xmlstream.avatar
+            session.broadcastPresence(presence)
+            return True
+
+
+    def unavailableReceived(self, presence):
+        if presence.recipient:
+            # Pass through directed presence.
+            return False
+        else:
+            session = self.xmlstream.avatar
+            session.broadcastPresence(presence)
+            return True
+
+
+    def subscribedReceived(self, presence):
+        """
+        Subscription approval confirmation was received.
+        """
+        self._stampContactJID(presence)
+        return False
+
+
+    def unsubscribedReceived(self, presence):
+        """
+        Unsubscription confirmation was received.
+        """
+        self._stampContactJID(presence)
+        return False
+
+
+    def subscribeReceived(self, presence):
+        """
+        Subscription request was received.
+        """
+        self._stampContactJID(presence)
+        return False
+
+
+    def unsubscribeReceived(self, presence):
+        """
+        Unsubscription request was received.
+        """
+        self._stampContactJID(presence)
+        return False
+
+
+    def probeReceived(self, presence):
+        """
+        Probe presence was received.
+        """
+        return False