source: ralphm-patches/c2s_server_factory.patch @ 56:fa1511cccfe2

wokkel/client.py

@@ -16 +16 @@
 from twisted.internet import reactor
 from twisted.names.srvconnect import SRVConnector
 from twisted.words.protocols.jabber import client, error, sasl, xmlstream
+from twisted.words.xish import domish, utility
 
 from wokkel import generic
 from wokkel.subprotocols import StreamManager
+from wokkel.compat import XmlStreamServerFactory
 
 NS_CLIENT = 'jabber:client'
 
@@ -345 +347 @@
 
 
 
+class RecipientUnavailable(Exception):
+    """
+    The addressed entity is not, or no longer, available.
+    """
+
+
+
+class XMPPC2SServerFactory(XmlStreamServerFactory):
+
+    def __init__(self, service):
+        self.service = service
+
+        def authenticatorFactory():
+            return XMPPClientListenAuthenticator(service)
+
+        XmlStreamServerFactory.__init__(self, authenticatorFactory)
+        self.addBootstrap(xmlstream.STREAM_CONNECTED_EVENT,
+                          self.onConnectionMade)
+        self.addBootstrap(xmlstream.STREAM_AUTHD_EVENT,
+                          self.onAuthenticated)
+
+        self.serial = 0
+        self.streams = {}
+
+
+    def onConnectionMade(self, xs):
+        """
+        Called when a client-to-server connection was made.
+
+        This enables traffic debugging on incoming streams.
+        """
+        xs.serial = self.serial
+        self.serial += 1
+
+        log.msg("Client connection %d made" % xs.serial)
+
+        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):
+        log.msg("Client connection %d authenticated" % xs.serial)
+
+        xs.addObserver(xmlstream.STREAM_END_EVENT, self.onConnectionLost,
+                                                   0, xs)
+        xs.addObserver('/*', self.onElement, 0, xs)
+
+        # Record this stream as bound to the authenticated JID
+        self.streams[xs.otherEntity] = xs
+
+
+    def onConnectionLost(self, xs, reason):
+        log.msg("Client connection %d disconnected" % xs.serial)
+
+        entity = xs.otherEntity
+        self.service.unbindResource(entity.user,
+                                    entity.host,
+                                    entity.resource,
+                                    reason)
+
+        # If the lost connections had been bound, remove the reference
+        if xs.otherEntity in self.streams:
+            del self.streams[xs.otherEntity]
+
+
+    def onError(self, reason):
+        log.err(reason, "Stream Error")
+
+
+    def onElement(self, xs, stanza):
+        """
+        Called when an element was received from one of the connected streams.
+
+        """
+        if stanza.handled:
+            return
+        else:
+            self.service.onElement(stanza, xs.otherEntity)
+
+
+    def deliverStanza(self, element, recipient):
+        if recipient in self.streams:
+            self.streams[recipient].send(element)
+        else:
+            raise RecipientUnavailable(u"There is no connection for %s" %
+                                       recipient.full())