def run(): def shutdown_by_signal(sig): logger.info(f'Got {sig} signal. Shutting down..') loop.stop() init_logging() logger.info('Running hackfollow service') loop = asyncio.get_event_loop() loop.set_debug(settings.debug) for sig_name in 'SIGINT', 'SIGTERM': loop.add_signal_handler(getattr(signal, sig_name), shutdown_by_signal, sig_name) scheduler = AsyncIOScheduler() app = web.Application() setup_routes(app) async def main(run_scheduler=True): session = aiohttp.ClientSession() # todo close if run_scheduler: scheduler.start() scheduler.add_job(check, 'interval', (session, ), seconds=settings.interval, next_run_time=datetime.datetime.now()) asyncio.create_task( web._run_app(app, host=settings.host, port=settings.port)) loop.run_until_complete(main()) loop.run_forever() scheduler.shutdown() _cancel_all_tasks(loop) loop.run_until_complete(loop.shutdown_asyncgens()) logger.success('Service has been stopped')
def event_loop(): from asyncio import runners uvloop.install() loop = asyncio.new_event_loop() yield loop # Right way to close event_loop # copied from asyncio.run # noinspection PyUnresolvedReferences,PyProtectedMember runners._cancel_all_tasks(loop) loop.run_until_complete(loop.shutdown_asyncgens()) loop.close()
def run(): # tracemalloc.start(25) def shutdown_by_signal(sig): logger.info(f'Got {sig} signal. Shutting down..') loop.stop() init_logging() logger.info('Running getcam service') loop = asyncio.get_event_loop() loop.set_debug(conf.debug) for sig_name in 'SIGINT', 'SIGTERM': loop.add_signal_handler(getattr(signal, sig_name), shutdown_by_signal, sig_name) agent = GooglePhotosManager() vk_manager = VKManager() bot = CamBot(agent=agent, manager=vk_manager) scheduler = AsyncIOScheduler() handlers = [ CamHandler(cam, bot.session, agent) for cam in conf.cameras_list ] async def main(): await agent.start() await vk_manager.start() scheduler.start() for handler in handlers: scheduler.add_job(handler.get_img_and_sync, 'interval', seconds=handler.cam.interval, next_run_time=datetime.datetime.now()) scheduler.add_job(agent.refresh_token, 'interval', minutes=30) scheduler.add_job(bot.daily_movie_group, 'cron', hour=0, minute=2) scheduler.add_job(bot.daily_photo_group, 'cron', hour=10, minute=10) # asyncio.create_task(mem_trace()) asyncio.create_task(bot.loop()) asyncio.create_task(agent.loop()) await bot.notify_admins('Ready! Use /menu, /stats') loop.run_until_complete(main()) loop.run_forever() loop.run_until_complete(bot.notify_admins('Going to restart services..')) bot.stop() scheduler.shutdown() loop.run_until_complete(agent.stop()) _cancel_all_tasks(loop) loop.run_until_complete(loop.shutdown_asyncgens()) logger.success('Service has been stopped')
def run(self, result=None): # pylint: disable=R0915 orig_result = result if result is None: result = self.defaultTestResult() startTestRun = getattr(result, 'startTestRun', None) # pylint: disable=C0103 if startTestRun is not None: startTestRun() result.startTest(self) testMethod = getattr(self, self._testMethodName) # pylint: disable=C0103 if (getattr(self.__class__, "__unittest_skip__", False) or getattr(testMethod, "__unittest_skip__", False)): # If the class or method was skipped. try: skip_why = ( getattr(self.__class__, '__unittest_skip_why__', '') or getattr(testMethod, '__unittest_skip_why__', '')) self._addSkip(result, self, skip_why) finally: result.stopTest(self) return expecting_failure_method = getattr(testMethod, "__unittest_expecting_failure__", False) expecting_failure_class = getattr(self, "__unittest_expecting_failure__", False) expecting_failure = expecting_failure_class or expecting_failure_method outcome = _Outcome(result) self.loop = asyncio.new_event_loop() # pylint: disable=W0201 asyncio.set_event_loop(self.loop) self.loop.set_debug(True) try: self._outcome = outcome with outcome.testPartExecutor(self): self.setUp() self.loop.run_until_complete(self.asyncSetUp()) if outcome.success: outcome.expecting_failure = expecting_failure with outcome.testPartExecutor(self, isTest=True): maybe_coroutine = testMethod() if asyncio.iscoroutine(maybe_coroutine): self.loop.run_until_complete(maybe_coroutine) outcome.expecting_failure = False with outcome.testPartExecutor(self): self.loop.run_until_complete(self.asyncTearDown()) self.tearDown() self.doAsyncCleanups() try: _cancel_all_tasks(self.loop) self.loop.run_until_complete(self.loop.shutdown_asyncgens()) finally: asyncio.set_event_loop(None) self.loop.close() for test, reason in outcome.skipped: self._addSkip(result, test, reason) self._feedErrorsToResult(result, outcome.errors) if outcome.success: if expecting_failure: if outcome.expectedFailure: self._addExpectedFailure(result, outcome.expectedFailure) else: self._addUnexpectedSuccess(result) else: result.addSuccess(self) return result finally: result.stopTest(self) if orig_result is None: stopTestRun = getattr(result, 'stopTestRun', None) # pylint: disable=C0103 if stopTestRun is not None: stopTestRun() # pylint: disable=E1102 # explicitly break reference cycles: # outcome.errors -> frame -> outcome -> outcome.errors # outcome.expectedFailure -> frame -> outcome -> outcome.expectedFailure outcome.errors.clear() outcome.expectedFailure = None # clear the outcome, no more needed self._outcome = None