Example #1
0
 def buildProtocol(self, addr):
     router = Router()
     proto = self.protocol(router)
     proto.factory = self
     default = router.bindRoute(proto, None)
     default.connectTo(None)
     return proto
Example #2
0
 def indirect(self, interface):
     """
     Create a L{Router} to handle AMP boxes received over an AMP connection.
     """
     if interface is IBoxReceiver:
         router = Router()
         connector = self.connectorFactory(router)
         router.bindRoute(connector, None).connectTo(None)
         return router
     raise NotImplementedError()
Example #3
0
 def setUp(self):
     """
     Create sender, router, receiver, and route objects.
     """
     self.sender = CollectingSender()
     self.router = Router()
     self.router.startReceivingBoxes(self.sender)
     self.receiver = SomeReceiver()
     self.route = self.router.bindRoute(self.receiver)
     self.route.connectTo("foo")
Example #4
0
 def setUp(self):
     """
     Create a route attached to a stub sender.
     """
     self.receiver = SomeReceiver()
     self.sender = CollectingSender()
     self.localName = "foo"
     self.remoteName = "bar"
     self.router = Router()
     self.router.startReceivingBoxes(self.sender)
     self.route = self.router.bindRoute(self.receiver, self.localName)
Example #5
0
 def test_ampBoxReceivedDefaultRoute(self):
     """
     L{Router.ampBoxReceived} delivers boxes with no route to the default
     box receiver.
     """
     sender = CollectingSender()
     receiver = SomeReceiver()
     router = Router()
     router.startReceivingBoxes(sender)
     router.bindRoute(receiver, None).start()
     router.ampBoxReceived({'foo': 'bar'})
     self.assertEqual(receiver.boxes, [{'foo': 'bar'}])
Example #6
0
def main(reactor, username, password):
    startLogging(stdout)
    router = Router()
    proto = AMP(router)
    router.bindRoute(proto, None).connectTo(None)
    cc = ClientCreator(reactor, lambda: proto)
    d = cc.connectTCP(username.split('@')[1], 7805)
    d.addCallback(login, UsernamePassword(username, password))
    d.addCallback(connectRoute, router, BoxPrinter(),
                  u'http://divmod.org/ns/echo')
    d.addCallback(sendBox)
    return d
Example #7
0
 def test_bindBeforeStartFinishAfterStart(self):
     """
     If a L{Route} is created with L{Router.connect} before the L{Router} is
     started with L{Router.startReceivingBoxes} but the Deferred returned by
     the connect thunk does not fire until after the router is started, the
     L{IBoxReceiver} associated with the route is not started until that
     Deferred fires and the route is associated with a remote route name.
     """
     router = Router()
     receiver = SomeReceiver()
     route = router.bindRoute(receiver)
     sender = CollectingSender()
     router.startReceivingBoxes(sender)
     self.assertFalse(receiver.started)
     route.connectTo("remoteName")
     self.assertTrue(receiver.started)
     receiver.sender.sendBox({'foo': 'bar'})
     self.assertEqual(sender.boxes, [{_ROUTE: 'remoteName', 'foo': 'bar'}])
Example #8
0
 def test_bindBeforeStart(self):
     """
     If a L{Route} is created with L{Router.bind} before the L{Router} is
     started with L{Router.startReceivingBoxes}, the L{Route} is created
     unstarted and only started when the L{Router} is started.
     """
     router = Router()
     receiver = SomeReceiver()
     route = router.bindRoute(receiver)
     route.connectTo('quux')
     self.assertFalse(receiver.started)
     sender = CollectingSender()
     router.startReceivingBoxes(sender)
     self.assertTrue(receiver.started)
     route.sendBox({'foo': 'bar'})
     self.assertEqual(
         sender.boxes, [{_ROUTE: route.remoteRouteName, 'foo': 'bar'}])
     router.ampBoxReceived({_ROUTE: route.localRouteName, 'baz': 'quux'})
     self.assertEqual(receiver.boxes, [{'baz': 'quux'}])
Example #9
0
    def test_stopReceivingBoxes(self):
        """
        L{Router.stopReceivingBoxes} calls the C{stop} method of each connected
        route.
        """
        sender = CollectingSender()
        router = Router()
        router.startReceivingBoxes(sender)
        receiver = SomeReceiver()
        router.bindRoute(receiver)

        class DummyException(Exception):
            pass

        self.assertFalse(receiver.stopped)

        router.stopReceivingBoxes(Failure(DummyException()))

        self.assertTrue(receiver.stopped)
        receiver.reason.trap(DummyException)
Example #10
0
def main(reactor):
    router = Router()
    cc = ClientCreator(reactor, AMP, router)
    d = cc.connectTCP('localhost', 7805)
    d.addCallback(makeRoutes, router)
    return d