source: ralphm-patches/session_manager.patch @ 54:03ec57713c90

wokkel/client.py

@@ -13 +13 @@
 import base64
 
 from twisted.application import service
-from twisted.internet import reactor
+from twisted.internet import defer, reactor
 from twisted.names.srvconnect import SRVConnector
+from twisted.python import log, randbytes
 from twisted.words.protocols.jabber import client, error, sasl, xmlstream
+from twisted.words.protocols.jabber.jid import JID, internJID
 from twisted.words.xish import domish, utility
 
 from wokkel import generic
-from wokkel.subprotocols import StreamManager
 from wokkel.compat import XmlStreamServerFactory
+from wokkel.subprotocols import StreamManager, XMPPHandler
 
 NS_CLIENT = 'jabber:client'
 
@@ -442 +444 @@
         else:
             raise RecipientUnavailable(u"There is no connection for %s" %
                                        recipient.full())
+
+
+class Session(object):
+    def __init__(self, entity):
+        self.entity = entity
+        self.connected = False
+        self.interested = False
+        self.presence = None
+
+
+
+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}).
+    """
+
+    def __init__(self, domain, accounts):
+        XMPPHandler.__init__(self)
+        self.domain = domain
+        self.accounts = accounts
+
+        self.connectionManager = None
+        self.sessions = {}
+        self.clientStream = utility.EventDispatcher()
+        self.clientStream.addObserver('/*', self.routeOrDeliver, -1)
+
+
+    def bindResource(self, localpart, domain, resource):
+        if domain != self.domain:
+            raise Exception("I don't host this domain!")
+
+        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=(localpart, domain, resource))
+        session = Session(entity)
+        session.connected = True
+        userSessions[resource] = session
+
+        return defer.succeed(entity)
+
+
+    def unbindResource(self, localpart, domain, resource, reason=None):
+        try:
+            session = self.sessions[localpart][resource]
+        except KeyError:
+            pass
+        else:
+            session.connected = False
+            del self.sessions[localpart][resource]
+            if not self.sessions[localpart]:
+                del self.sessions[localpart]
+
+        return defer.succeed(None)
+
+
+    def onElement(self, element, sender):
+        # Make sure each stanza has a sender address
+        if (element.name == 'presence' and
+            element.getAttribute('type') in ('subscribe', 'subscribed',
+                                             'unsubscribe', 'unsubscribed')):
+            element['from'] = sender.userhost()
+        else:
+            element['from'] = sender.full()
+
+        self.clientStream.dispatch(element)
+
+
+    def routeOrDeliver(self, element):
+        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())
+            self.xmlstream.send(element)
+
+
+    def deliverStanza(self, element, recipient):
+        if self.connectionManager:
+            self.connectionManager.deliverStanza(element, recipient)
+        else:
+            raise Exception("No connection manager set")