def _reached_tolerance(self, current_time):
if not self.args.sizing:
return False
if current_time - get_timer() > 60:
# we need to reset the tolerance counters
set_timer(current_time)
self.results['MINUTE_OK'].value = 0
self.results['MINUTE_FAILED'].value = 0
return False
OK = self.results['MINUTE_OK'].value
FAILED = self.results['MINUTE_FAILED'].value
if OK + FAILED < 100:
# we don't have enough samples
return False
current_ratio = float(FAILED) / float(OK) * 100.
reached = current_ratio > self.args.sizing_tolerance
if reached:
self.results['REACHED'].value = 1
self.results['RATIO'].value = int(current_ratio * 100)
return reached
def _process(self):
set_timer()
if self.args.processes > 1:
signal.signal(signal.SIGINT, self._shutdown)
signal.signal(signal.SIGTERM, self._shutdown)
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
if self.args.debug:
self.console.print('**** RUNNING IN DEBUG MODE == SLOW ****')
self.loop.set_debug(True)
self._set_statsd()
if self.args.original_pid == os.getpid():
self._tasks.append(self.ensure_future(self._send_workers_event(1)))
if not self.args.quiet:
fut = self._display_results(self.args.console_update)
update = self.ensure_future(fut)
display = self.ensure_future(self.console.display())
display = self.gather(update, display)
self._tasks.append(display)
workers = self.gather(*self._runner())
workers.add_done_callback(lambda fut: stop())
self._tasks.append(workers)
try:
self.loop.run_until_complete(self.gather(*self._tasks))
finally:
self._kill_tasks()
if self.statsd is not None:
self.statsd.close()
self.loop.close()
def _process(self):
set_timer()
# coroutine that will kill everything when duration is up
if self.args.duration and self.args.force_shutdown:
async def _duration_killer():
cancelled = object()
res = await cancellable_sleep(self.args.duration,
result=cancelled)
if res is cancelled or (res and not res.canceled()):
self._shutdown(None, None)
await asyncio.sleep(0)
_duration_killer = self.ensure_future(_duration_killer())
else:
_duration_killer = None
if self.args.processes > 1:
signal.signal(signal.SIGINT, self._shutdown)
signal.signal(signal.SIGTERM, self._shutdown)
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
if self.args.debug:
self.console.print("**** RUNNING IN DEBUG MODE == SLOW ****")
self.loop.set_debug(True)
self._set_statsd()
if self.statsd is not None:
self._tasks.append(self.ensure_future(self.statsd.connect()))
if self.args.original_pid == os.getpid():
self._tasks.append(self.ensure_future(self._send_workers_event(1)))
if not self.args.quiet:
fut = self._display_results(self.args.console_update)
update = self.ensure_future(fut)
display = self.ensure_future(self.console.display())
display = self.gather(update, display)
self._tasks.append(display)
workers = self.gather(*self._runner())
def _stop(cb):
if _duration_killer is not None:
if not _duration_killer.done():
_duration_killer.cancel()
stop()
workers.add_done_callback(_stop)
self._tasks.append(workers)
try:
self.loop.run_until_complete(self.gather(*self._tasks))
finally:
if self.statsd is not None:
self.loop.run_until_complete(
self.ensure_future(self.statsd.close()))
self._kill_tasks()
self.loop.close()
def _process(self):
set_timer()
# coroutine that will kill everything when duration is up
if self.args.duration and self.args.force_shutdown:
async def _duration_killer():
cancelled = object()
res = await cancellable_sleep(self.args.duration,
result=cancelled)
if res is cancelled or (res and not res.canceled()):
self._shutdown(None, None)
await asyncio.sleep(0)
_duration_killer = self.ensure_future(_duration_killer())
else:
_duration_killer = None
if self.args.processes > 1:
signal.signal(signal.SIGINT, self._shutdown)
signal.signal(signal.SIGTERM, self._shutdown)
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
if self.args.debug:
self.console.print('**** RUNNING IN DEBUG MODE == SLOW ****')
self.loop.set_debug(True)
self._set_statsd()
if self.args.original_pid == os.getpid():
self._tasks.append(self.ensure_future(self._send_workers_event(1)))
if not self.args.quiet:
fut = self._display_results(self.args.console_update)
update = self.ensure_future(fut)
display = self.ensure_future(self.console.display())
display = self.gather(update, display)
self._tasks.append(display)
workers = self.gather(*self._runner())
def _stop(cb):
if _duration_killer is not None:
if not _duration_killer.done():
_duration_killer.cancel()
stop()
workers.add_done_callback(_stop)
self._tasks.append(workers)
try:
self.loop.run_until_complete(self.gather(*self._tasks))
finally:
self._kill_tasks()
if self.statsd is not None:
self.statsd.close()
self.loop.run_until_complete(self.ensure_future(asyncio.sleep(0)))
self.loop.close()
async def sizer(session):
if session.worker_id == 200 and not _RES2['messed']:
# worker 2 will mess with the timer
# since we're faking all timers, the current
# time in the test is always around 0
# so to have now() - get_timer() > 60
# we need to set a negative value here
# to trick it
set_timer(-61)
_RES2['messed'] = True
_RES2['fail'] = _RES2['succ'] = 0
if session.worker_id > 100:
# starting to introduce errors passed the 100th
if random.randint(0, 10) == 1:
_RES2['fail'] += 1
raise AssertionError()
else:
_RES2['succ'] += 1
# forces a switch
await asyncio.sleep(0)
async def sizer(session):
if session.worker_id == 200 and not _RES2['messed']:
# worker 2 will mess with the timer
# since we're faking all timers, the current
# time in the test is always around 0
# so to have now() - get_timer() > 60
# we need to set a negative value here
# to trick it
set_timer(-61)
_RES2['messed'] = True
_RES2['fail'] = _RES2['succ'] = 0
if session.worker_id > 100:
# starting to introduce errors passed the 100th
if random.randint(0, 10) == 1:
_RES2['fail'] += 1
raise AssertionError()
else:
_RES2['succ'] += 1
# forces a switch
await asyncio.sleep(0)
