def add_startup_jobs(cluster_id, odb, jobs, stats_enabled): """ Adds internal jobs to the ODB. Note that it isn't being added directly to the scheduler because we want users to be able to fine-tune the job's settings. """ with closing(odb.session()) as session: for item in jobs: if not stats_enabled and item['name'].startswith('zato.stats'): continue try: service_id = get_service_by_name(session, cluster_id, item['service'])[0] now = datetime.utcnow() job = Job(None, item['name'], True, 'interval_based', now, item.get('extra', '').encode('utf-8'), cluster_id=cluster_id, service_id=service_id) kwargs = {} for name in('seconds', 'minutes'): if name in item: kwargs[name] = item[name] ib_job = IntervalBasedJob(None, job, **kwargs) session.add(job) session.add(ib_job) session.commit() except(IntegrityError, ProgrammingError), e: session.rollback() logger.debug('Caught an expected error, carrying on anyway, e:[%s]', format_exc(e).decode('utf-8'))
def add_startup_jobs(cluster_id, odb, stats_jobs): """ Adds one of the interval jobs to the ODB. Note that it isn't being added directly to the scheduler because we want users to be able to fine-tune the job's settings. """ with closing(odb.session()) as session: for item in stats_jobs: try: service_id = get_service_by_name(session, cluster_id, item['service'])[0] now = datetime.utcnow().strftime(scheduler_date_time_format) job = Job(None, item['name'], True, 'interval_based', now, item.get('extra', '').encode('utf-8'), cluster_id=cluster_id, service_id=service_id) kwargs = {} for name in('seconds', 'minutes'): if name in item: kwargs[name] = item[name] ib_job = IntervalBasedJob(None, job, **kwargs) session.add(job) session.add(ib_job) session.commit() except IntegrityError, e: session.rollback() msg = 'Caught an IntegrityError, carrying on anyway, e:[{}]]'.format(format_exc(e)) logger.debug(msg)
def _create_edit(action, cid, input, payload, logger, session, broker_client, response): """ Creating and updating a job requires a series of very similar steps so they've been all put here and depending on the 'action' parameter (be it 'create'/'edit') some additional operations are performed. """ job_type = input.job_type cluster_id = input.cluster_id name = input.name service_name = input.service if job_type not in (SCHEDULER.JOB_TYPE.ONE_TIME, SCHEDULER.JOB_TYPE.INTERVAL_BASED, SCHEDULER.JOB_TYPE.CRON_STYLE): msg = 'Unrecognized job type [{0}]'.format(job_type) logger.error(msg) raise ZatoException(cid, msg) # For finding out if we don't have a job of that name already defined. existing_one_base = session.query(Job).\ filter(Cluster.id==cluster_id).\ filter(Job.name==name) if action == 'create': existing_one = existing_one_base.first() else: job_id = input.id existing_one = existing_one_base.filter(Job.id != job_id).first() if existing_one: raise ZatoException( cid, 'Job [{0}] already exists on this cluster'.format(name)) # Is the service's name correct? service = session.query(Service).\ filter(Cluster.id==cluster_id).\ filter(Service.cluster_id==Cluster.id).\ filter(Service.name==service_name).first() if not service: msg = 'Service [{0}] does not exist on this cluster'.format( service_name) logger.error(msg) raise ZatoException(cid, msg) # We can create/edit a base Job object now and - optionally - another one # if the job type's is either interval-based or Cron-style. The base # instance will be enough if it's a one-time job. extra = input.extra.encode('utf-8') is_active = input.is_active start_date = parse(input.start_date) if action == 'create': job = Job(None, name, is_active, job_type, start_date, extra, cluster_id=cluster_id, service=service) else: job = session.query(Job).filter_by(id=job_id).one() old_name = job.name job.name = name job.is_active = is_active job.start_date = start_date job.service = service job.extra = extra try: # Add but don't commit yet. session.add(job) if job_type == SCHEDULER.JOB_TYPE.INTERVAL_BASED: ib_params = ('weeks', 'days', 'hours', 'minutes', 'seconds') if not any(input[key] for key in ib_params): msg = "At least one of ['weeks', 'days', 'hours', 'minutes', 'seconds'] must be given" logger.error(msg) raise ZatoException(cid, msg) if action == 'create': ib_job = IntervalBasedJob(None, job) else: ib_job = session.query(IntervalBasedJob).filter_by( id=job.interval_based.id).one() for param in ib_params + ('repeats', ): value = input[param] or None if value != ZATO_NONE: setattr(ib_job, param, value) value = input['repeats'] or None if value != ZATO_NONE: setattr(ib_job, 'repeats', value) session.add(ib_job) elif job_type == SCHEDULER.JOB_TYPE.CRON_STYLE: cron_definition = input.cron_definition.strip() # Just to make sure it's syntactically correct CronTab(cron_definition).next() if action == 'create': cs_job = CronStyleJob(None, job) else: cs_job = session.query(CronStyleJob).filter_by( id=job.cron_style.id).one() cs_job.cron_definition = cron_definition session.add(cs_job) # We can commit it all now. session.commit() # Now send it to the broker, but only if the job is active. if is_active: msg_action = SCHEDULER_MSG.CREATE.value if action == 'create' else SCHEDULER_MSG.EDIT.value msg = { 'action': msg_action, 'job_type': job_type, 'is_active': is_active, 'start_date': start_date.isoformat(), 'extra': extra, 'service': service.name, 'id': job.id, 'name': name } if action == 'edit': msg['old_name'] = old_name if job_type == SCHEDULER.JOB_TYPE.INTERVAL_BASED: for param in ib_params + ('repeats', ): value = input[param] msg[param] = int(value) if value else 0 elif job_type == SCHEDULER.JOB_TYPE.CRON_STYLE: msg['cron_definition'] = cron_definition else: msg = {'action': SCHEDULER_MSG.DELETE.value, 'name': name} broker_client.publish(msg, MESSAGE_TYPE.TO_SCHEDULER) except Exception, e: session.rollback() msg = 'Could not complete the request, e:[{e}]'.format(e=format_exc(e)) logger.error(msg) raise
def index(req): try: jobs = [] # Build a list of schedulers for a given Zato cluster. if req.zato.cluster_id and req.method == 'GET': # We have a server to pick the schedulers from, try to invoke it now. response = req.zato.client.invoke( 'zato.scheduler.job.get-list', {'cluster_id': req.zato.cluster_id}) if response.has_data: for job_elem in response.data: id = job_elem.id name = job_elem.name is_active = job_elem.is_active job_type = job_elem.job_type start_date = job_elem.start_date service_name = job_elem.service_name extra = job_elem.extra job_type_friendly = job_type_friendly_names[job_type] job = Job(id, name, is_active, job_type, from_utc_to_user(start_date + '+00:00', req.zato.user_profile), extra, service_name=service_name, job_type_friendly=job_type_friendly) if job_type == SCHEDULER.JOB_TYPE.ONE_TIME: definition_text = _one_time_job_def( req.zato.user_profile, start_date) elif job_type == SCHEDULER.JOB_TYPE.INTERVAL_BASED: definition_text = _interval_based_job_def( req.zato.user_profile, _get_start_date(job_elem.start_date), job_elem.repeats, job_elem.weeks, job_elem.days, job_elem.hours, job_elem.minutes, job_elem.seconds) weeks = job_elem.weeks or '' days = job_elem.days or '' hours = job_elem.hours or '' minutes = job_elem.minutes or '' seconds = job_elem.seconds or '' repeats = job_elem.repeats or '' ib_job = IntervalBasedJob(None, None, weeks, days, hours, minutes, seconds, repeats) job.interval_based = ib_job elif job_type == SCHEDULER.JOB_TYPE.CRON_STYLE: cron_definition = job_elem.cron_definition or '' definition_text = _cron_style_job_def( req.zato.user_profile, start_date, cron_definition) cs_job = CronStyleJob(None, None, cron_definition) job.cron_style = cs_job else: msg = 'Unrecognized job type, name:[{0}], type:[{1}]'.format( name, job_type) logger.error(msg) raise ZatoException(msg) job.definition_text = definition_text jobs.append(job) else: logger.info('No jobs found, response:[{}]'.format(response)) if req.method == 'POST': action = req.POST.get('zato_action', '') if not action: msg = 'req.POST contains no [zato_action] parameter.' logger.error(msg) return HttpResponseServerError(msg) job_type = req.POST.get('job_type', '') if action != 'execute' and not job_type: msg = 'req.POST contains no [job_type] parameter.' logger.error(msg) return HttpResponseServerError(msg) job_name = req.POST['{0}-{1}-name'.format(action, job_type)] # Try to match the action and a job type with an action handler.. handler_name = '_' + action if action != 'execute': handler_name += '_' + job_type handler = globals().get(handler_name) if not handler: msg = ('No handler found for action [{0}], job_type:[{1}], ' 'req.POST:[{2}], req.GET:[{3}].'.format( action, job_type, pprint(req.POST), pprint(req.GET))) logger.error(msg) return HttpResponseServerError(msg) # .. invoke the action handler. try: response = handler(req.zato.client, req.zato.user_profile, req.zato.cluster, req.POST) response = response if response else '' if response: response['message'] = _get_success_message( action, job_type, job_name) response = dumps(response) return HttpResponse(response, content_type='application/javascript') except Exception, e: msg = ('Could not invoke action [%s], job_type:[%s], e:[%s]' 'req.POST:[%s], req.GET:[%s]') % ( action, job_type, format_exc(), pprint( req.POST), pprint(req.GET)) logger.error(msg) return HttpResponseServerError(msg) return_data = { 'zato_clusters': req.zato.clusters, 'cluster_id': req.zato.cluster_id, 'choose_cluster_form': req.zato.choose_cluster_form, 'jobs': jobs, 'friendly_names': job_type_friendly_names.items(), 'create_one_time_form': OneTimeSchedulerJobForm(create_one_time_prefix, req), 'create_interval_based_form': IntervalBasedSchedulerJobForm(create_interval_based_prefix, req), 'create_cron_style_form': CronStyleSchedulerJobForm(create_cron_style_prefix, req), 'edit_one_time_form': OneTimeSchedulerJobForm(edit_one_time_prefix, req), 'edit_interval_based_form': IntervalBasedSchedulerJobForm(edit_interval_based_prefix, req), 'edit_cron_style_form': CronStyleSchedulerJobForm(edit_cron_style_prefix, req), 'sample_dt': get_sample_dt(req.zato.user_profile), } return_data.update(get_js_dt_format(req.zato.user_profile)) return TemplateResponse(req, 'zato/scheduler.html', return_data)