async def main(kafka_topic=KAFKA_TOPIC, sites=SITES, run_total=None):
ssl_context = None
security_protocol = 'PLAINTEXT'
if KAFKA_SSL_CA is not None:
ssl_context = create_ssl_context(cafile=KAFKA_SSL_CA,
certfile=KAFKA_SSL_CERT,
keyfile=KAFKA_SSL_KEY)
security_protocol = 'SSL'
producer = AIOKafkaProducer(bootstrap_servers=KAFKA_HOST,
value_serializer=serializer,
security_protocol=security_protocol,
ssl_context=ssl_context)
msh = Scheduler()
try:
for site in sites:
url = site['url']
log.info(f'Monitoring {url}')
msh.add_job(
CronJob(run_total=run_total,
name=f'check_{url}').every().second.go(
check_site, producer, site, kafka_topic))
await producer.start()
await msh.start()
except Exception as e:
log.error(f'Got error starting scheduler: {e}')
raise e
finally:
await producer.stop()
def run(self):
self.backend = Backend().init()
if not self.backend:
return
if not Auth().init():
return
Launchy.attach_loop(self.loop)
worker = Worker()
self.task_worker = asyncio.ensure_future(worker.run())
backend_worker = BackendWorker()
self.task_backend_worker = asyncio.ensure_future(backend_worker.run())
aptly_worker = AptlyWorker()
self.task_aptly_worker = asyncio.ensure_future(aptly_worker.run())
notification_worker = NotificationWorker()
self.task_notification_worker = asyncio.ensure_future(notification_worker.run())
cfg = Configuration()
daily_cleanup = cfg.aptly.get("daily_cleanup")
if daily_cleanup is False or daily_cleanup == "off" or daily_cleanup == "disabled":
return
if not daily_cleanup:
daily_cleanup = "04:00"
cleanup_sched = Scheduler(locale="en_US")
cleanup_job = CronJob(name='cleanup').every().day.at(daily_cleanup).go(self.cleanup_task)
cleanup_sched.add_job(cleanup_job)
self.task_cron = asyncio.ensure_future(cleanup_sched.start())
app.set_context_functions(MoliorServer.create_cirrina_context, MoliorServer.destroy_cirrina_context)
app.run(self.host, self.port, logger=self.logger, debug=self.debug)
def __init__(self, allowed_usernames, callback):
threading.Thread.__init__(self)
self.crons = {}
self.allowed_usernames = allowed_usernames
self.callback = callback
self.loop = asyncio.get_event_loop()
self.scheduler = Scheduler(loop=self.loop)
self.loop.create_task(self.scheduler.start())
self.start()
def __init__(self, *args, **kwargs):
logger.warning("Lo Sgargabot is starting...")
super().__init__(*args,
**kwargs,
command_prefix=config.PREFIX,
description=config.DESCRIPTION)
self.scheduler = Scheduler(locale=config.SCHEDULER_LOCALE)
self.loaded_cogs = LoadedCogs(self)
self.db = mongoengine.connect(
db=config.MONGODB_MAIN,
host="mongodb://" + config.MONGODB_USER + ":" +
config.MONGODB_PASSWORD + "@" + config.MONGODB_HOST + ":" +
str(config.MONGODB_PORT) + "/?authSource=admin",
tz_aware=True)
self.loop.create_task(self.scheduler.start())
import asyncio
from async_cron.job import CronJob
from async_cron.schedule import Scheduler
from async_cron.job_loader import FileJobLoader
async def test(*args, **kwargs):
print(args, kwargs)
def tt(*args, **kwargs):
print(args, kwargs)
msh = Scheduler(locale="zh_CN")
myjob = CronJob(name='test', run_total=3).every(5).second.go(test, (1, 2, 3),
name=123)
job2 = CronJob(name='exact', tolerance=100).at("2019-01-15 16:12").go(tt, (5),
age=99)
job3 = CronJob(name='very_hour').every().hour.at(":44").go(tt, (5), age=99)
# add timezone infomation using at func, such as : UTC/GMT+08:00, time_shift=8
job3 = CronJob(name='hour').every().hour.at(
":06", time_shift=8).from_hour(18).to_hour(20).go(tt, (5), age=99)
job4 = CronJob(name='minute').every(1).minute.go(tt, (5), age=99)
job5 = CronJob(name='weekday').weekday(2).at("11:18").go(tt, (5), age=99)
job6 = CronJob(name='monthday').monthday(16).at("11:22").go(tt, (5), age=99)
job7 = CronJob(name='monthday').every(5).monthday(16).at("11:22").go(tt, (5),
age=99)
def __init__(self, *args, **kwargs):
super(SchedulerKernel, self).__init__(*args, **kwargs)
self.sch = Scheduler()
import asyncio
import os
from async_cron.job import CronJob
from async_cron.schedule import Scheduler
from pypi_tools.tracker import tracker
import sentry_sdk
scheduler = Scheduler(locale="en_US")
#sentry_sdk.init(os.environ["SENTRY_PATH"])
tracker_job = CronJob(name='track_packages').every(3).minute.go(tracker)
#scheduler.add_job(tracker_job)
if __name__ == '__main__':
# Execute broadcaster
try:
asyncio.get_event_loop().run_until_complete(scheduler.start())
except KeyboardInterrupt:
print('Scheduler exit')
except Exception as e:
sentry_sdk.capture_exception(e)
import asyncio
import logging
import shutil
from asgiref.sync import sync_to_async
from async_cron.job import CronJob
from async_cron.schedule import Scheduler
from starlette.applications import Starlette
from starlette.responses import PlainTextResponse
from starlette.routing import Route
from ..mc import rcon
log = logging.getLogger(__name__)
rootlog = logging.getLogger(None)
scheduler = Scheduler()
DELAY = 5 * 60 # Seconds
FREQUENCY = 60 * 60
@sync_to_async
def copy_dirs(src, dst):
shutil.copytree(src, dst, dirs_exist_ok=True)
async def capture_exceptions(func):
try:
await func()
except Exception:
await verify_error_proxy_task()
await update_squid_task()
@cron_wait
async def fetch_new_proxy_task():
logger.info("run fetch_new_proxy_task")
await spider.run_spider()
await verifier.verify_new_proxy()
# await verify_error_proxy_task()
await update_squid_task()
if __name__ == '__main__':
logger.info("start")
loop = asyncio.get_event_loop()
loop.run_until_complete(update_squid_task())
msh = Scheduler()
msh.add_job(CronJob().every(10).minute.go(verify_ok_proxy_task))
msh.add_job(CronJob().every(30).minute.go(fetch_new_proxy_task))
try:
loop.run_until_complete(asyncio.wait([
msh.start(),
run_api_server(),
]))
loop.run_forever()
except KeyboardInterrupt:
print('exit')
class GtmHubScheduler(threading.Thread):
days_list = {
'0': _('Monday'),
'1': _('Tuesday'),
'2': _('Wednesday'),
'3': _('Thursday'),
'4': _('Friday'),
'5': _('Saturday'),
'6': _('Sunday')
}
def __init__(self, allowed_usernames, callback):
threading.Thread.__init__(self)
self.crons = {}
self.allowed_usernames = allowed_usernames
self.callback = callback
self.loop = asyncio.get_event_loop()
self.scheduler = Scheduler(loop=self.loop)
self.loop.create_task(self.scheduler.start())
self.start()
def run(self):
self.loop.run_forever()
@staticmethod
def is_valid_day(day):
return day in GtmHubScheduler.days_list.keys()
@staticmethod
def is_valid_hour(hour):
try:
time.strptime(hour, '%H:%M')
return True
except ValueError:
return False
def is_valid_username(self, username):
return username in self.allowed_usernames
def has_cron(self, peer_id):
return peer_id in self.crons.keys()
def need_params(self, peer_id):
return self.has_cron(
peer_id) and not self.crons[peer_id].is_configured()
def create_cron(self, peer_id):
if self.has_cron(peer_id):
raise InputException(_('You have a reminder curently'))
self.crons[peer_id] = Cron(peer_id)
def set_value(self, peer_id, value):
if not self.has_cron(peer_id):
raise InputException(_('You have not a reminder to configure'))
if self.crons[peer_id].is_configured():
raise InputException(_('Your reminder is already configured'))
if self.crons[peer_id].day is None:
if not GtmHubScheduler.is_valid_day(value):
raise InputException(_('Invalid day'))
self.crons[peer_id].day = value
elif self.crons[peer_id].hour is None:
if not GtmHubScheduler.is_valid_hour(value):
raise InputException(_('Invalid hour'))
self.crons[peer_id].hour = value
else:
if not self.is_valid_username(value):
raise InputException(
_('Invalid username\nAvailable usernames : {}').format(
'\n' + '\n'.join(self.allowed_usernames)))
self.crons[peer_id].username = value
def enable_cron(self, peer_id):
day = int(self.crons[peer_id].day)
hour = self.crons[peer_id].hour
username = self.crons[peer_id].username
job = CronJob(name=peer_id, loop=self.loop).weekday(day).at(hour).go(
self.callback, peer_id, username)
self.scheduler.add_job(job)
def cancel_cron(self, peer_id):
try:
self.scheduler.del_job(peer_id)
del self.crons[peer_id]
except KeyError:
InputException(_("You don't have a reminder currently"))