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
