Changeset 39:a9e354f69018 for wokkel

Timestamp:

Oct 11, 2008, 10:41:03 PM (14 years ago)

Author:

Ralph Meijer <ralphm@…>

Branch:

default

Convert:

svn:b33ecbfc-034c-dc11-8662-000475d9059e/trunk@106

Message:

Add Internal Component service that connects to a router in-process.

Author: ralphm.
Fixes #31.

Location:

wokkel

Files:

• component.py (modified) (2 diffs)
• test/test_component.py (modified) (2 diffs)

wokkel/component.py

@@ -15 +15 @@
 from twisted.words.xish import domish
 
+from wokkel.generic import XmlPipe
 from wokkel.subprotocols import StreamManager
 
@@ -63 +64 @@
     def _getConnection(self):
         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.
+    """
+
+    def __init__(self, router, domain):
+        xmlstream.XMPPHandlerCollection.__init__(self)
+        self.router = router
+        self.domain = 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
+        self.router.addRoute(self.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)
+
+        self.router.removeRoute(self.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)
 
 

wokkel/test/test_component.py

@@ -6 +6 @@
 """
 
+from zope.interface.verify import verifyObject
+
+from twisted.internet import defer
 from twisted.python import failure
 from twisted.trial import unittest
-from twisted.words.protocols.jabber import xmlstream
+from twisted.words.protocols.jabber import ijabber, xmlstream
 from twisted.words.protocols.jabber.jid import JID
 from twisted.words.xish import domish
@@ -14 +17 @@
 from wokkel import component
 from wokkel.generic import XmlPipe
+
+class InternalComponentTest(unittest.TestCase):
+    """
+    Tests for L{component.InternalComponent}.
+    """
+
+    def setUp(self):
+        self.router = component.RouterService()
+        self.component = component.InternalComponent(self.router, 'component')
+
+
+    def test_interface(self):
+        """
+        L{component.InternalComponent} implements
+        L{ijabber.IXMPPHandlerCollection}.
+        """
+        verifyObject(ijabber.IXMPPHandlerCollection, self.component)
+
+
+    def test_startService(self):
+        """
+        Starting the service creates a new route and hooks up handlers.
+        """
+
+        events = []
+
+        class TestHandler(xmlstream.XMPPHandler):
+
+            def connectionInitialized(self):
+                fn = lambda obj: events.append(obj)
+                self.xmlstream.addObserver('//event/test', fn)
+
+        TestHandler().setHandlerParent(self.component)
+
+        self.assertFalse(self.component.running)
+
+        self.component.startService()
+
+        self.assertTrue(self.component.running)
+        self.assertIn('component', self.router.routes)
+
+        self.assertEquals([], events)
+        self.component.xmlstream.dispatch(None, '//event/test')
+        self.assertEquals([None], events)
+
+
+    def test_stopService(self):
+        """
+        Stopping the service removes the route and disconnects handlers.
+        """
+
+        events = []
+
+        class TestHandler(xmlstream.XMPPHandler):
+
+            def connectionLost(self, reason):
+                events.append(reason)
+
+        TestHandler().setHandlerParent(self.component)
+
+        self.component.startService()
+        self.component.stopService()
+
+        self.assertFalse(self.component.running)
+        self.assertEquals(1, len(events))
+        self.assertNotIn('component', self.router.routes)
+
+
+    def test_addHandler(self):
+        """
+        Adding a handler connects it to the stream.
+        """
+        events = []
+
+        class TestHandler(xmlstream.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.component.startService()
+        self.router.routes['component'].addObserver('/message', fn)
+        self.component.send(message)
+
+        self.assertEquals([message], events)
+
+
 
 class RouterServiceTest(unittest.TestCase):