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()
