def should_terminate(self):
if self.stopping_start is None:
self.stopping_start = default_timer()
return False
else:
dt = default_timer() - self.stopping_start
return dt if dt >= ACTOR_ACTION_TIMEOUT else False
def should_terminate(self):
if self.stopping_start is None:
self.stopping_start = default_timer()
return False
else:
dt = default_timer() - self.stopping_start
return dt if dt >= ACTOR_ACTION_TIMEOUT else False
def test_timeout(self):
q = Queue()
self.assertEqual(q.qsize(), 0)
start = default_timer()
try:
item = yield q.get(timeout=0.5)
except Empty:
pass
self.assertTrue(default_timer() - start >= 0.5)
self.assertEqual(q.qsize(), 0)
def test_maxsize(self):
q = Queue(maxsize=2)
self.assertEqual(q.maxsize, 2)
yield self. async .assertEqual(q.put('hello'), None)
yield self. async .assertEqual(q.put('ciao'), None)
self.assertEqual(q.qsize(), 2)
self.assertTrue(q.full())
start = default_timer()
yield self. async .assertRaises(Full, q.put, 'ciao', timeout=0.5)
self.assertTrue(default_timer() - start >= 0.5)
def test_timeout(self):
q = Queue()
self.assertEqual(q.qsize(), 0)
start = default_timer()
try:
item = yield q.get(timeout=0.5)
except Empty:
pass
self.assertTrue(default_timer()-start >= 0.5)
self.assertEqual(q.qsize(), 0)
def test_maxsize(self):
q = Queue(maxsize=2)
self.assertEqual(q.maxsize, 2)
yield self.async.assertEqual(q.put('hello'), None)
yield self.async.assertEqual(q.put('ciao'), None)
self.assertEqual(q.qsize(), 2)
self.assertTrue(q.full())
start = default_timer()
yield self.async.assertRaises(Full, q.put, 'ciao', timeout=0.5)
self.assertTrue(default_timer()-start >= 0.5)
def test_start_hook(self):
proxy = yield self.spawn(start=create_echo_server(('127.0.0.1', 0)))
address = None
start = default_timer()
while not address:
info = yield send(proxy, 'info')
address = info['extra'].get('echo-address')
if default_timer() - start > 3:
break
self.assertTrue(address)
echo = Echo().client(address)
result = yield echo(b'Hello')
self.assertEqual(result, b'Hello')
yield self.stop_actors(proxy)
def test_start_hook(self):
proxy = yield self.spawn(start=create_echo_server(('127.0.0.1', 0)))
address = None
start = default_timer()
while not address:
info = yield send(proxy, 'info')
address = info['extra'].get('echo-address')
if default_timer() - start > 3:
break
self.assertTrue(address)
echo = Echo().client(address)
result = yield echo(b'Hello')
self.assertEqual(result, b'Hello')
yield self.stop_actors(proxy)
def _():
start = default_timer()
di = 0.1
interval = 0
result = while_clause(*args)
while result:
interval = min(interval + di, MAX_ASYNC_WHILE)
try:
yield Deferred(timeout=interval)
except CancelledError:
pass
if timeout and default_timer() - start >= timeout:
break
result = while_clause(*args)
yield result
def monitor_start(self, monitor):
'''When the monitor starts load all test classes into the queue'''
# Create a datastore for this test suite
if not self.cfg.task_backend:
server = PulsarDS(bind='127.0.0.1:0',
workers=0,
key_value_save=[],
name='%s_store' % self.name)
yield server()
address = 'pulsar://%s:%s' % server.cfg.addresses[0]
else:
address = self.cfg.task_backend
store = create_store(address, pool_size=2, loop=monitor._loop)
self.get_backend(store)
loader = self.loader
tags = self.cfg.labels
exclude_tags = self.cfg.exclude_labels
if self.cfg.show_leaks:
show = show_leaks if self.cfg.show_leaks == 1 else hide_leaks
self.cfg.set('when_exit', show)
arbiter = pulsar.arbiter()
arbiter.cfg.set('when_exit', show)
try:
tests = []
loader.runner.on_start()
for tag, testcls in loader.testclasses(tags, exclude_tags):
suite = loader.runner.loadTestsFromTestCase(testcls)
if suite and suite._tests:
tests.append((tag, testcls))
self._time_start = None
if tests:
self.logger.info('loading %s test classes', len(tests))
monitor.cfg.set('workers', min(self.cfg.workers, len(tests)))
self._time_start = default_timer()
queued = []
self._tests_done = set()
self._tests_queued = None
#
# Bind to the task_done event
self.backend.bind_event('task_done',
partial(self._test_done, monitor))
for tag, testcls in tests:
r = self.backend.queue_task('test',
testcls=testcls,
tag=tag)
queued.append(r)
queued = yield multi_async(queued)
self.logger.debug('loaded %s test classes', len(tests))
self._tests_queued = set(queued)
yield self._test_done(monitor)
else: # pragma nocover
raise ExitTest('Could not find any tests.')
except ExitTest as e: # pragma nocover
monitor.stream.writeln(str(e))
monitor._loop.stop()
except Exception: # pragma nocover
monitor.logger.critical('Error occurred while starting tests',
exc_info=True)
monitor._loop.call_soon(self._exit, 3)
def monitor_start(self, monitor):
'''When the monitor starts load all test classes into the queue'''
# Create a datastore for this test suite
if not self.cfg.task_backend:
server = PulsarDS(bind='127.0.0.1:0', workers=0,
key_value_save=[],
name='%s_store' % self.name)
yield server()
address = 'pulsar://%s:%s' % server.cfg.addresses[0]
else:
address = self.cfg.task_backend
store = create_store(address, pool_size=2, loop=monitor._loop)
self.get_backend(store)
loader = self.loader
tags = self.cfg.labels
exclude_tags = self.cfg.exclude_labels
if self.cfg.show_leaks:
show = show_leaks if self.cfg.show_leaks == 1 else hide_leaks
self.cfg.set('when_exit', show)
arbiter = pulsar.arbiter()
arbiter.cfg.set('when_exit', show)
try:
tests = []
loader.runner.on_start()
for tag, testcls in loader.testclasses(tags, exclude_tags):
suite = loader.runner.loadTestsFromTestCase(testcls)
if suite and suite._tests:
tests.append((tag, testcls))
self._time_start = None
if tests:
self.logger.info('loading %s test classes', len(tests))
monitor.cfg.set('workers', min(self.cfg.workers, len(tests)))
self._time_start = default_timer()
queued = []
self._tests_done = set()
self._tests_queued = None
#
# Bind to the task_done event
self.backend.bind_event('task_done',
partial(self._test_done, monitor))
for tag, testcls in tests:
r = self.backend.queue_task('test', testcls=testcls,
tag=tag)
queued.append(r)
queued = yield multi_async(queued)
self.logger.debug('loaded %s test classes', len(tests))
self._tests_queued = set(queued)
yield self._test_done(monitor)
else: # pragma nocover
raise ExitTest('Could not find any tests.')
except ExitTest as e: # pragma nocover
monitor.stream.writeln(str(e))
monitor.arbiter.stop()
except Exception: # pragma nocover
monitor.logger.critical('Error occurred while starting tests',
exc_info=True)
monitor._loop.call_soon(self._exit, 3)
def lock(self):
'''Lock the :class:`MultiDeferred` so that no new items can be added.
If it was alread :attr:`locked` a runtime exception occurs.'''
if self._locked:
raise RuntimeError(self.__class__.__name__ +
' cannot be locked twice.')
self._time_locked = default_timer()
self._locked = True
if not self._deferred:
self._finish()
return self
def _finish(self):
if not self._locked:
raise RuntimeError(self.__class__.__name__ +
' cannot finish until completed.')
if self._deferred:
raise RuntimeError(self.__class__.__name__ +
' cannot finish whilst waiting for '
'dependents %r' % self._deferred)
self._time_finished = default_timer()
if self.raise_on_error and self._failures:
self.callback(self._failures[0])
else:
self.callback(self._stream)
def _check_queue(self):
runner = self.runner
tests = yield self.backend.get_tasks(status=tasks.READY_STATES)
if len(tests) == len(self.local.tests):
self.logger.info('All tests have finished.')
time_taken = default_timer() - self._time_start
for task in tests:
runner.add(task.result)
runner.on_end()
runner.printSummary(time_taken)
# Shut down the arbiter
if runner.result.errors or runner.result.failures:
exit_code = 2
else:
exit_code = 0
raise pulsar.HaltServer(exit_code=exit_code)
def __init__(self,
data=None,
type=None,
raise_on_error=True,
mute_failures=False,
**kwargs):
self._deferred = {}
self._failures = []
self._mute_failures = mute_failures
self._raise_on_error = raise_on_error
if not type:
type = data.__class__ if data is not None else list
if not issubclass(type, (list, Mapping)):
type = list
self._stream = type()
super(MultiDeferred, self).__init__(**kwargs)
self._time_start = default_timer()
if data:
self.update(data)
def _test_done(self, monitor, task_id=None, exc=None):
runner = self.runner
if task_id:
self._tests_done.add(to_string(task_id))
if self._tests_queued is not None:
left = self._tests_queued.difference(self._tests_done)
if not left:
tests = yield self.backend.get_tasks(self._tests_done)
self.logger.info('All tests have finished.')
time_taken = default_timer() - self._time_start
for task in tests:
runner.add(task.get('result'))
runner.on_end()
runner.printSummary(time_taken)
# Shut down the arbiter
if runner.result.errors or runner.result.failures:
exit_code = 2
else:
exit_code = 0
monitor._loop.call_soon(self._exit, exit_code)
def _test_done(self, monitor, task_id=None, exc=None):
runner = self.runner
if task_id:
self._tests_done.add(to_string(task_id))
if self._tests_queued is not None:
left = self._tests_queued.difference(self._tests_done)
if not left:
tests = yield self.backend.get_tasks(self._tests_done)
self.logger.info('All tests have finished.')
time_taken = default_timer() - self._time_start
for task in tests:
runner.add(task.get('result'))
runner.on_end()
runner.printSummary(time_taken)
# Shut down the arbiter
if runner.result.errors or runner.result.failures:
exit_code = 2
else:
exit_code = 0
monitor._loop.call_soon(self._exit, exit_code)
def monitor_start(self, monitor):
'''When the monitor starts load all test classes into the queue'''
super(TestSuite, self).monitor_start(monitor)
loader = self.local.loader
tags = self.cfg.labels
exclude_tags = self.cfg.exclude_labels
if self.cfg.show_leaks:
show = show_leaks if self.cfg.show_leaks == 1 else hide_leaks
self.cfg.set('when_exit', show)
arbiter = pulsar.arbiter()
arbiter.cfg.set('when_exit', show)
try:
self.local.tests = tests = []
self.runner.on_start()
for tag, testcls in loader.testclasses(tags, exclude_tags):
suite = self.runner.loadTestsFromTestCase(testcls)
if suite and suite._tests:
tests.append((tag, testcls))
self._time_start = None
if tests:
self.logger.info('loaded %s test classes', len(tests))
self.fire_event('tests', tests=tests)
monitor.cfg.set('workers', min(self.cfg.workers, len(tests)))
self._time_start = default_timer()
for tag, testcls in self.local.tests:
self.backend.run('test', testcls, tag)
monitor.event_loop.call_repeatedly(1, self._check_queue)
else: # pragma nocover
raise ExitTest('Could not find any tests.')
except ExitTest as e: # pragma nocover
monitor.stream.writeln(str(e))
monitor.arbiter.stop()
except Exception: # pragma nocover
self.logger.critical('Error occurred before starting tests',
exc_info=True)
monitor.arbiter.stop()
def timeout(start):
return default_timer() - start > 1.5*ACTOR_ACTION_TIMEOUT
def wait(actor, period=0.5):
start = default_timer()
yield pulsar.async_sleep(period)
yield default_timer() - start
def should_be_alive(self):
if not self.mailbox:
return default_timer() - self.spawning_start > ACTOR_ACTION_TIMEOUT
else:
return True
def start(self):
'''Start the remote actor.
'''
self.spawning_start = default_timer()
self.impl.start()
def timeout(start):
return default_timer() - start > 1.5 * ACTOR_ACTION_TIMEOUT
def should_be_alive(self):
if not self.mailbox:
return default_timer() - self.spawning_start > ACTOR_ACTION_TIMEOUT
else:
return True
def start(self):
'''Start the remote actor.
'''
self.spawning_start = default_timer()
self.impl.start()
