class ReactorTwoCallLaterTest(unittest.TestCase): def setUp(self): self._reactor = TornadoReactor(IOLoop()) def test_callLater(self): self._later1Called = False self._later2Called = False self._now = self._reactor.seconds() self._timeout1 = 0.0005 dc1 = self._reactor.callLater(self._timeout1, self.callLaterCallback1) self._timeout2 = 0.001 dc2 = self._reactor.callLater(self._timeout2, self.callLaterCallback2) self.assertTrue(self._reactor.getDelayedCalls() == [dc1, dc2] or self._reactor.getDelayedCalls() == [dc2, dc1]) self._reactor.run() self.assertTrue(self._later1Called) self.assertTrue(self._later2Called) self.assertTrue(self._called1 - self._now > self._timeout1) self.assertTrue(self._called2 - self._now > self._timeout2) self.assertEqual(self._reactor.getDelayedCalls(), []) def callLaterCallback1(self): self._later1Called = True self._called1 = self._reactor.seconds() def callLaterCallback2(self): self._later2Called = True self._called2 = self._reactor.seconds() self._reactor.stop()
class ReactorTwoCallLaterTest(unittest.TestCase): def setUp(self): self._reactor = TornadoReactor(IOLoop()) def test_callLater(self): self._later1Called = False self._later2Called = False self._now = self._reactor.seconds() self._timeout1 = 0.0005 dc1 = self._reactor.callLater(self._timeout1, self.callLaterCallback1) self._timeout2 = 0.001 dc2 = self._reactor.callLater(self._timeout2, self.callLaterCallback2) self.assertTrue(self._reactor.getDelayedCalls() == [dc1, dc2] or self._reactor.getDelayedCalls() == [dc2, dc1]) self._reactor.run() self.assertTrue(self._later1Called) self.assertTrue(self._later2Called) self.assertTrue(self._called1 - self._now > self._timeout1) self.assertTrue(self._called2 - self._now > self._timeout2) self.assertEqual(self._reactor.getDelayedCalls(), []) def callLaterCallback1(self): self._later1Called = True self._called1 = self._reactor.seconds() def callLaterCallback2(self): self._later2Called = True self._called2 = self._reactor.seconds() self._reactor.stop()
class ReactorCallLaterTest(unittest.TestCase): def setUp(self): self._reactor = TornadoReactor(IOLoop()) def test_callLater(self): self._laterCalled = False self._now = self._reactor.seconds() self._timeout = 0.001 dc = self._reactor.callLater(self._timeout, self.callLaterCallback) self.assertEqual(self._reactor.getDelayedCalls(), [dc]) self._reactor.run() self.assertTrue(self._laterCalled) self.assertTrue(self._called - self._now > self._timeout) self.assertEqual(self._reactor.getDelayedCalls(), []) def callLaterCallback(self): self._laterCalled = True self._called = self._reactor.seconds() self._reactor.stop()
class ReactorCallLaterTest(unittest.TestCase): def setUp(self): self._reactor = TornadoReactor(IOLoop()) def test_callLater(self): self._laterCalled = False self._now = self._reactor.seconds() self._timeout = 0.001 dc = self._reactor.callLater(self._timeout, self.callLaterCallback) self.assertEqual(self._reactor.getDelayedCalls(), [dc]) self._reactor.run() self.assertTrue(self._laterCalled) self.assertTrue(self._called - self._now > self._timeout) self.assertEqual(self._reactor.getDelayedCalls(), []) def callLaterCallback(self): self._laterCalled = True self._called = self._reactor.seconds() self._reactor.stop()
class WAMPFrontend(pykka.ThreadingActor, core.CoreListener): ''' Web Application Messaging Protocol frontend for Mopidy. On startup an additional thread running a local Tornado IOLoop will be created ''' def __init__(self, config, core): ''' initialize the frontend `config` is a dict holding Mopidy configuration values `core` is a Mopidy core actor proxy ''' super(WAMPFrontend, self).__init__() self.core = core self.config = config self._loop = None self._reactor = None self._session = None self._ioloop_thread = None def on_start(self): ''' start up the WAMP frontend by creating a session factory and running a local IOLoop''' logger.info("WAMPFrontend started successfully") if self.config["wampfrontend"]["enable_twisted_log"]: log.startLogging(sys.stdout) self._loop = IOLoop.instance() self._reactor = TornadoReactor(self._loop) self.schedule( self.client_connect ) def on_stop(self): logger.info("WAMPFrontend stopping ...") def on_event(self, event, **kwargs): ''' Schedule an incoming mopidy event to be published ''' if self._session._client: self.schedule( self._session._client.on_event, event, **kwargs ) logger.debug("WAMPFrontend: scheduled event publishing for %s" % event) def schedule(self, function, *args, **kwargs): ''' Schedule a function to be called during the next IOLoop iteration ''' assert self._loop, \ 'WAMPFrontend has not been started yet. Unable to run IOLoop' assert isinstance(self._loop, IOLoop), \ 'WAMPFrontend: Invalid local IO-loop type: %s' % type(self._loop) logger.debug('WAMPFrontend: scheduled call for IOLoop: %s' % function) self._loop.add_callback( function, *args, **kwargs ) def client_connect(self): client = clientFromString(self._reactor, url_to_client_string(self.config['wampfrontend']["router"])) transport = self._prepare_transport() logger.info('WAMPFrontend: connecting client (from thread: %s)' % currentThread()) d = client.connect(transport) def on_success(result): pass def on_error(result): logger.warn("WAMPFrontend: %s" % result) self._reactor.callLater(2, self.client_connect) d.addCallbacks(on_success, on_error) def _prepare_transport(self): ''' Prepare a transport factory ''' assert self._reactor, \ 'WAMPFrontend: cannot create transport without an IOLoop and a TornadoReactor' config = types.ComponentConfig( realm = self.config['wampfrontend']['realm'], extra = { 'name': self.config['wampfrontend']['name'], 'core': self.core, 'frontend': self }) session = wamp.ApplicationSessionFactory(config=config) session.session = WAMPFrontendComponent # Add a reference toe the frontend object (ourself) session._frontend = self # Add a reference the the ApplicationSession created # since we are a client, there will be only one session at all session._client = None # Now also store a reference to the session factory for us self._session = session transport = MyClientFactory( session, url = self.config['wampfrontend']['router'], debug = self.config['wampfrontend']['debug_autobahn'], debug_wamp = self.config['wampfrontend']['debug_wamp']) return transport
class ReactorReaderWriterTest(unittest.TestCase): def _set_nonblocking(self, fd): flags = fcntl.fcntl(fd, fcntl.F_GETFL) fcntl.fcntl(fd, fcntl.F_SETFL, flags | os.O_NONBLOCK) def setUp(self): self._reactor = TornadoReactor(IOLoop()) r, w = os.pipe() self._set_nonblocking(r) self._set_nonblocking(w) set_close_exec(r) set_close_exec(w) self._p1 = os.fdopen(r, "rb", 0) self._p2 = os.fdopen(w, "wb", 0) def _testReadWrite(self): """ In this test the writer writes an 'x' to its fd. The reader reads it, check the value and ends the test. """ self.shouldWrite = True def checkReadInput(fd): self.assertEquals(fd.read(), 'x') self._reactor.stop() def writeOnce(fd): if self.shouldWrite: self.shouldWrite = False fd.write('x') self._reader = Reader(self._p1, checkReadInput) self._writer = Writer(self._p2, writeOnce) self._reactor.addWriter(self._writer) # Test that adding the reader twice adds it only once to # IOLoop. self._reactor.addReader(self._reader) self._reactor.addReader(self._reader) def testReadWrite(self): self._reactor.callWhenRunning(self._testReadWrite) self._reactor.run() def _testNoWriter(self): """ In this test we have no writer. Make sure the reader doesn't read anything. """ def checkReadInput(fd): self.fail("Must not be called.") def stopTest(): # Close the writer here since the IOLoop doesn't know # about it. self._writer.close() self._reactor.stop() self._reader = Reader(self._p1, checkReadInput) # We create a writer, but it should never be invoked. self._writer = Writer(self._p2, lambda fd: fd.write('x')) # Test that adding and removing the writer leaves us with no writer. self._reactor.addWriter(self._writer) self._reactor.removeWriter(self._writer) # Test that adding and removing the reader doesn't cause # unintended effects. self._reactor.addReader(self._reader) # Wake up after a moment and stop the test self._reactor.callLater(0.001, stopTest) def testNoWriter(self): self._reactor.callWhenRunning(self._testNoWriter) self._reactor.run()
class ReactorReaderWriterTest(unittest.TestCase): def _set_nonblocking(self, fd): flags = fcntl.fcntl(fd, fcntl.F_GETFL) fcntl.fcntl(fd, fcntl.F_SETFL, flags | os.O_NONBLOCK) def setUp(self): self._reactor = TornadoReactor(IOLoop()) r, w = os.pipe() self._set_nonblocking(r) self._set_nonblocking(w) set_close_exec(r) set_close_exec(w) self._p1 = os.fdopen(r, "rb", 0) self._p2 = os.fdopen(w, "wb", 0) def _testReadWrite(self): """ In this test the writer writes an 'x' to its fd. The reader reads it, check the value and ends the test. """ self.shouldWrite = True def checkReadInput(fd): self.assertEquals(fd.read(), 'x') self._reactor.stop() def writeOnce(fd): if self.shouldWrite: self.shouldWrite = False fd.write('x') self._reader = Reader(self._p1, checkReadInput) self._writer = Writer(self._p2, writeOnce) self._reactor.addWriter(self._writer) # Test that adding the reader twice adds it only once to # IOLoop. self._reactor.addReader(self._reader) self._reactor.addReader(self._reader) def testReadWrite(self): self._reactor.callWhenRunning(self._testReadWrite) self._reactor.run() def _testNoWriter(self): """ In this test we have no writer. Make sure the reader doesn't read anything. """ def checkReadInput(fd): self.fail("Must not be called.") def stopTest(): # Close the writer here since the IOLoop doesn't know # about it. self._writer.close() self._reactor.stop() self._reader = Reader(self._p1, checkReadInput) # We create a writer, but it should never be invoked. self._writer = Writer(self._p2, lambda fd: fd.write('x')) # Test that adding and removing the writer leaves us with no writer. self._reactor.addWriter(self._writer) self._reactor.removeWriter(self._writer) # Test that adding and removing the reader doesn't cause # unintended effects. self._reactor.addReader(self._reader) # Wake up after a moment and stop the test self._reactor.callLater(0.001, stopTest) def testNoWriter(self): self._reactor.callWhenRunning(self._testNoWriter) self._reactor.run()