class RunScheduledQueueTaskGroup(Task):
@classmethod
def full_classname(cls):
return class_path(cls)
def run(self, *args, **kwargs):
scheduled = ScheduledQueueTaskGroup.objects.get(
id=kwargs['scheduled_id']
)
scheduled.run()
celery_app.register_task(RunScheduledQueueTaskGroup())
class BaseQueueMultipleTask(BaseQueueTask):
tasks = []
task_run_prefix = '_run_'
@classmethod
def get_extra_form_fields(cls):
fields = {}
for task in cls.get_tasks():
fields[f'{cls.task_run_prefix}{task.__name__}'] = forms.BooleanField(
label=f'Run {task.task_name}',
required=False,
initial=True
)
)
class ScheduleRecurringNudge(BinnedScheduleMessageBaseTask): # lint-amnesty, pylint: disable=missing-class-docstring
num_bins = resolvers.RECURRING_NUDGE_NUM_BINS
enqueue_config_var = 'enqueue_recurring_nudge'
log_prefix = RECURRING_NUDGE_LOG_PREFIX
resolver = resolvers.RecurringNudgeResolver
async_send_task = _recurring_nudge_schedule_send
def make_message_type(self, day_offset):
return message_types.RecurringNudge(abs(day_offset))
# Save the task instance on the class object so that it's accessible via the cls argument to enqueue
ScheduleRecurringNudge.task_instance = current_app.register_task(
ScheduleRecurringNudge())
ScheduleRecurringNudge = ScheduleRecurringNudge.task_instance
class ScheduleUpgradeReminder(BinnedScheduleMessageBaseTask): # lint-amnesty, pylint: disable=missing-class-docstring
num_bins = resolvers.UPGRADE_REMINDER_NUM_BINS
enqueue_config_var = 'enqueue_upgrade_reminder'
log_prefix = UPGRADE_REMINDER_LOG_PREFIX
resolver = resolvers.UpgradeReminderResolver
async_send_task = _upgrade_reminder_schedule_send
def make_message_type(self, day_offset):
return message_types.UpgradeReminder()
# Save the task instance on the class object so that it's accessible via the cls argument to enqueue
from pivo import celery_app
from beer.models import Beer
from beer.service.add_beer_image import add_beer_image
from celery import current_app
@celery_app.task()
def add_beer_image_task(beer_id):
add_beer_image(beer_id)
current_app.register_task(add_beer_image_task)
def load_and_register_alerts(self):
existing_alert_schedules = self.fetch_schedule_dict()
alert_schedules = {}
for alert_name, params in ALERTS.items():
# Register alerts in celery
try:
alert_tokens = alert_name.split(".")
alert_module_name = alert_tokens[0]
alert_classname = alert_tokens[-1]
alert_module = import_module(alert_module_name)
alert_class = getattr(alert_module, alert_classname)
current_app.register_task(alert_class())
except ImportError as e:
logger.exception("Error importing {0}: {1}".format(
alert_name, e))
pass
except Exception as e:
logger.exception("Generic error registering {0}: {1}".format(
alert_name, e))
pass
alert_schedule = {
"name": alert_name,
"task": alert_name,
"enabled": True,
}
if 'args' in params:
alert_schedule['args'] = params['args']
if 'kwargs' in params:
alert_schedule['kwargs'] = params['kwargs']
if isinstance(params['schedule'], timedelta):
alert_schedule['schedule_type'] = 'interval'
alert_schedule['celery_schedule'] = {
"every": params['schedule'].total_seconds(),
"period": "seconds"
}
elif isinstance(params['schedule'], crontab):
alert_schedule['schedule_type'] = 'crontab'
alert_schedule['celery_schedule'] = {
"minute": params['schedule']._orig_minute,
"hour": params['schedule']._orig_hour,
"day_of_week": params['schedule']._orig_day_of_week,
"day_of_month": params['schedule']._orig_day_of_month,
"month_of_year": params['schedule']._orig_month_of_year,
}
if alert_name not in existing_alert_schedules:
logger.debug("Inserting schedule for {0} into mongodb".format(
alert_name))
updated_alert_schedule = alert_schedule
else:
existing_schedule = existing_alert_schedules[alert_name]
logger.debug(
"Updating existing schedule ({0}) with new information into mongodb"
.format(alert_name))
existing_schedule['schedule_type'] = alert_schedule[
'schedule_type']
existing_schedule['celery_schedule'] = alert_schedule[
'celery_schedule']
updated_alert_schedule = existing_schedule
alert_schedules[alert_name] = PeriodicTask(
**updated_alert_schedule).to_dict()
self.update_schedules(alert_schedules)
def load_and_register_alerts(self):
existing_alert_schedules = self.fetch_schedule_dict()
alert_schedules = {}
for alert_name, params in ALERTS.items():
# Register alerts in celery
try:
alert_tokens = alert_name.split(".")
alert_module_name = alert_tokens[0]
alert_classname = alert_tokens[-1]
alert_module = import_module(alert_module_name)
alert_class = getattr(alert_module, alert_classname)
current_app.register_task(alert_class())
except ImportError as e:
logger.exception("Error importing {0}: {1}".format(
alert_name, e))
pass
except Exception as e:
logger.exception("Generic error registering {0}: {1}".format(
alert_name, e))
pass
full_path_name = "{0}.{1}".format(alert_module_name,
alert_classname)
alert_schedule = {
"_id": str(ObjectId()),
"_cls": "PeriodicTask",
"name": full_path_name,
"task": full_path_name,
"enabled": True,
"args": [],
"kwargs": {},
}
if 'args' in params:
alert_schedule['args'] = params['args']
if 'kwargs' in params:
alert_schedule['kwargs'] = params['kwargs']
if isinstance(params['schedule'], timedelta):
alert_schedule['schedule_type'] = 'interval'
alert_schedule['interval'] = {
"every": params['schedule'].total_seconds(),
"period": "seconds"
}
alert_schedule['schedule_string'] = "{0} {1}".format(
params['schedule'].total_seconds(), "seconds")
elif isinstance(params['schedule'], crontab):
alert_schedule['schedule_type'] = 'crontab'
alert_schedule['crontab'] = {
"minute": params['schedule']._orig_minute,
"hour": params['schedule']._orig_hour,
"day_of_week": params['schedule']._orig_day_of_week,
"day_of_month": params['schedule']._orig_day_of_month,
"month_of_year": params['schedule']._orig_month_of_year,
}
alert_schedule[
'schedule_string'] = "{0} {1} {2} {3} {4}".format(
params['schedule']._orig_minute,
params['schedule']._orig_hour,
params['schedule']._orig_day_of_week,
params['schedule']._orig_day_of_month,
params['schedule']._orig_month_of_year,
)
if alert_name not in existing_alert_schedules:
logger.debug("Inserting schedule for {0} into mongodb".format(
full_path_name))
updated_alert_schedule = alert_schedule
else:
# Update schedule if it differs from file to api
del existing_alert_schedules[alert_name][
existing_alert_schedules[alert_name]['schedule_type']]
existing_alert_schedules[alert_name][
'schedule_type'] = alert_schedule['schedule_type']
existing_alert_schedules[alert_name][
alert_schedule['schedule_type']] = alert_schedule[
alert_schedule['schedule_type']]
existing_alert_schedules[alert_name][
'schedule_string'] = alert_schedule['schedule_string']
updated_alert_schedule = existing_alert_schedules[alert_name]
alert_schedules[alert_name] = updated_alert_schedule
resp = requests.post(url=RESTAPI_URL + "/updatealertschedules",
data=json.dumps(alert_schedules),
auth=self._restapi_jwt)
if not resp.ok:
raise Exception(
"Received error {0} from rest api when updating alerts schedules"
.format(resp.status_code))
errors = []
for test in self.tests:
try:
remote_exec(ssh, test, reuse_sftp=sftp)
except RemoteExecTimeout as e:
logger.warning("Timeout when running test: %s" % e)
raise
except RemoteExecException as e:
msg = e.args[0]
hint = msg.decode() if isinstance(msg, bytes) else str(msg)
if hint:
errors.append(hint)
else:
score += 1
sftp.close()
return {
'status': 'CHECK_PROGRESS_COMPLETE',
'pass': score,
'total': len(self.tests),
'errors': errors
}
LaunchStackTask = current_app.register_task(LaunchStackTask())
SuspendStackTask = current_app.register_task(SuspendStackTask())
DeleteStackTask = current_app.register_task(DeleteStackTask())
CheckStudentProgressTask = current_app.register_task(
CheckStudentProgressTask())
