source: ralphm-patches/session_manager.patch @ 70:cc8ecefb5519

wokkel/client.py

@@ -12 +12 @@
 
 import base64
 
+from zope.interface import implements
+
 from twisted.application import service
-from twisted.cred import credentials, error as ecred
+from twisted.cred import credentials, error as ecred, portal
 from twisted.internet import defer, reactor
-from twisted.python import log
+from twisted.python import log, randbytes
 from twisted.names.srvconnect import SRVConnector
 from twisted.words.protocols.jabber import client, error, sasl, xmlstream
-from twisted.words.xish import domish
+from twisted.words.protocols.jabber.jid import JID, internJID
+from twisted.words.xish import domish, utility
 
 from wokkel import generic
 from wokkel.compat import XmlStreamServerFactory
 from wokkel.iwokkel import IUserSession
 from wokkel.subprotocols import ServerStreamManager
 from wokkel.subprotocols import StreamManager
+from wokkel.subprotocols import XMPPHandler
 
 NS_CLIENT = 'jabber:client'
 
@@ -482 +486 @@
         return [
             generic.StanzaForwarder()
         ]
+
+
+
+class UserSession(object):
+
+    implements(IUserSession)
+
+    realm = None
+    mind = None
+
+    connected = False
+    interested = False
+    presence = None
+
+    clientStream = None
+
+    def __init__(self, entity):
+        self.entity = entity
+
+
+    def loggedIn(self, realm, mind):
+        self.realm = realm
+        self.mind = mind
+
+
+    def bindResource(self, resource):
+        def cb(entity):
+            self.entity = entity
+            self.connected = True
+            return entity
+
+        d = self.realm.bindResource(self, resource)
+        d.addCallback(cb)
+        return d
+
+
+    def logout(self):
+        self.connected = False
+        self.realm.unbindResource(self)
+
+
+    def send(self, element):
+        self.realm.onElement(element, self)
+
+
+    def receive(self, element):
+        self.mind.send(element)
+
+
+
+class SessionManager(XMPPHandler):
+    """
+    Session Manager.
+
+    @ivar xmlstream: XML Stream to inject incoming stanzas from client
+        connections into. Stanzas where the C{'to'} attribute is not set
+        or is directed at the local domain are injected as if received on
+        the XML Stream (using C{dispatch}), other stanzas are injected as if
+        they were sent from the XML Stream (using C{send}).
+    """
+
+    implements(portal.IRealm)
+
+    def __init__(self, domain, accounts):
+        XMPPHandler.__init__(self)
+        self.domain = domain
+        self.accounts = accounts
+
+        self.sessions = {}
+        self.clientStream = utility.EventDispatcher()
+        self.clientStream.addObserver('/*', self.routeOrDeliver, -1)
+
+
+    def requestAvatar(self, avatarId, mind, *interfaces):
+        if IUserSession not in interfaces:
+            raise NotImplementedError(self, interfaces)
+
+        localpart = avatarId.decode('utf-8')
+        entity = JID(tuple=(localpart, self.domain, None))
+        session = UserSession(entity)
+        session.loggedIn(self, mind)
+        return IUserSession, session, session.logout
+
+
+    def bindResource(self, session, resource):
+        localpart = session.entity.user
+
+        try:
+            userSessions = self.sessions[localpart]
+        except KeyError:
+            userSessions = self.sessions[localpart] = {}
+
+        if resource is None:
+            resource = randbytes.secureRandom(8).encode('hex')
+        elif resource in self.userSessions:
+            resource = resource + ' ' + randbytes.secureRandom(8).encode('hex')
+
+        entity = JID(tuple=(session.entity.user, session.entity.host, resource))
+        userSessions[resource] = session
+
+        return defer.succeed(entity)
+
+
+    def lookupSessions(self, entity):
+        """
+        Return all sessions for a user.
+
+        @param entity: Entity to retrieve sessions for. This the resource part
+            will be ignored.
+        @type entity: L{JID<twisted.words.protocols.jabber.jid.JID>}
+
+        @return: Mapping of sessions keyed by resource.
+        @rtype: C{dict}
+        """
+        localpart = entity.user
+
+        try:
+            return self.sessions[localpart]
+        except:
+            return {}
+
+
+    def lookupSession(self, entity):
+        """
+        Return the session for a particular resource of an entity.
+
+        @param entity: Entity to retrieve sessions for.
+        @type entity: L{JID<twisted.words.protocols.jabber.jid.JID>}
+
+        @return: C{UserSession}.
+        """
+
+        userSessions = self.lookupSessions(entity)
+        return userSessions[entity.resource]
+
+
+
+    def unbindResource(self, session, reason=None):
+        session.connected = False
+
+        localpart = session.entity.user
+        resource = session.entity.resource
+
+        del self.sessions[localpart][resource]
+        if not self.sessions[localpart]:
+            del self.sessions[localpart]
+
+        return defer.succeed(None)
+
+
+    def onElement(self, element, session):
+        # Make sure each stanza has a sender address
+        if (element.name == 'presence' and
+            element.getAttribute('type') in ('subscribe', 'subscribed',
+                                             'unsubscribe', 'unsubscribed')):
+            element['from'] = session.entity.userhost()
+        else:
+            element['from'] = session.entity.full()
+
+        self.clientStream.dispatch(element)
+
+
+    def routeOrDeliver(self, element):
+        """
+        Deliver a stanza locally or pass on for routing.
+        """
+        if element.handled:
+            return
+
+        if (not element.hasAttribute('to') or
+            internJID(element['to']).host == self.domain):
+            # This stanza is for local delivery
+            log.msg("Delivering locally: %r" % element.toXml())
+            self.xmlstream.dispatch(element)
+        else:
+            # This stanza is for remote routing
+            log.msg("Routing remotely: %r" % element.toXml())
+            XMPPHandler.send(self, element)
+
+
+    def deliverStanza(self, element, recipient):
+        session = self.lookupSession(recipient)
+        session.receive(element)

wokkel/test/test_client.py

@@ -7 +7 @@
 
 from base64 import b64encode
 
-from zope.interface import implements
+from zope.interface import implements, verify
 
 from twisted.cred.portal import IRealm, Portal
 from twisted.cred.checkers import InMemoryUsernamePasswordDatabaseDontUse
@@ -601 +601 @@
 
 
 
+
 class XMPPClientListenAuthenticatorTest(unittest.TestCase):
     """
     Tests for L{client.XMPPClientListenAuthenticator}.
@@ -670 +671 @@
                          "to='example.com' "
                          "version='1.0'>")
         self.xmlstream.assertStreamError(self, condition='host-unknown')
+
+
+
+class UserSessionTest(unittest.TestCase):
+
+    def setUp(self):
+        self.session = client.UserSession(JID('user@example.org'))
+
+
+    def test_interface(self):
+        verify.verifyObject(client.IUserSession, self.session)
+
+
+
+class SessionManagerTest(unittest.TestCase):
+
+    def setUp(self):
+        accounts = {'user': None}
+        self.sessionManager = client.SessionManager('example.org', accounts)
+
+
+    def test_interface(self):
+        verify.verifyObject(IRealm, self.sessionManager)