def update(schedule_id, delta): """ Updates the schedule with unique ID schedule_id. This only allows updating of fields in ScheduledCall.USER_UPDATE_FIELDS. :param schedule_id: a unique ID for a schedule :type schedule_id: basestring :param delta: a dictionary of keys with values that should be modified on the schedule. :type delta: dict :return: instance of ScheduledCall representing the post-update state :rtype ScheduledCall :raise exceptions.UnsupportedValue :raise exceptions.MissingResource """ unknown_keys = set(delta.keys()) - ScheduledCall.USER_UPDATE_FIELDS if unknown_keys: raise exceptions.UnsupportedValue(list(unknown_keys)) delta['last_updated'] = time.time() try: spec = {'_id': ObjectId(schedule_id)} except InvalidId: raise exceptions.InvalidValue(['schedule_id']) schedule = ScheduledCall.get_collection().find_and_modify( query=spec, update={'$set': delta}, safe=True, new=True) if schedule is None: raise exceptions.MissingResource(schedule_id=schedule_id) return ScheduledCall.from_db(schedule)
def post(self, request, repo_id, distributor_id): """ Create a new scheduled publish. :param request: WSGI request object :type request: django.core.handlers.wsgi.WSGIRequest :param repo_id: id of the repository :type repo_id: str :param distributor_id: id of the distributor :type distributor_id: str :return: Response containing a dict for the new scheduled publish :rtype : django.http.HttpResponse :raises exceptions.UnsupportedValue: if unsupported fields are included in body """ manager = manager_factory.repo_publish_schedule_manager() publish_options = {'override_config': request.body_as_json.pop('override_config', {})} schedule = request.body_as_json.pop('schedule', None) failure_threshold = request.body_as_json.pop('failure_threshold', None) enabled = request.body_as_json.pop('enabled', True) if request.body_as_json: raise exceptions.UnsupportedValue(request.body_as_json.keys()) schedule = manager.create(repo_id, distributor_id, publish_options, schedule, failure_threshold, enabled) ret = schedule.for_display() ret['_href'] = reverse('repo_publish_schedule_resource', kwargs={ 'repo_id': repo_id, 'distributor_id': distributor_id, 'schedule_id': schedule.id }) response = generate_json_response_with_pulp_encoder(ret) return generate_redirect_response(response, ret['_href'])
def validate_updated_schedule_options(options): """ Validate updated schedule options. :param options: updated options for a scheduled call :type options: dict :raises: pulp.server.exceptions.UnsupportedValue if unsupported schedule options are passed in :raises: pulp.server.exceptions.InvalidValue if any of the options are invalid """ unknown_options = _find_unknown_options(options, ScheduledCall.USER_UPDATE_FIELDS) if unknown_options: raise exceptions.UnsupportedValue(unknown_options) invalid_options = [] if 'iso_schedule' in options and not _is_valid_schedule(options['iso_schedule']): invalid_options.append('iso_schedule') if 'failure_threshold' in options and not _is_valid_failure_threshold( options['failure_threshold']): invalid_options.append('failure_threshold') if 'remaining_runs' in options and not _is_valid_remaining_runs(options['remaining_runs']): invalid_options.append('remaining_runs') if 'enabled' in options and not _is_valid_enabled_flag(options['enabled']): invalid_options.append('enabled') if not invalid_options: return raise exceptions.InvalidValue(invalid_options)
def post(self, request, repo_id, importer_id): """ Create a new scheduled sync. :param request: WSGI request object :type request: django.core.handlers.wsgi.WSGIRequest :param repo_id: id of the repository :type repo_id: str :param importer_id: create a new scheduled sync for this importer :type importer_id: str :return: Response containing a serialized dict of the new scheduled sync :rtype : django.http.HttpResponse :raises exceptions.UnsupportedValue: if there are unsupported request body params """ manager = manager_factory.repo_sync_schedule_manager() sync_options = {'override_config': request.body_as_json.pop('override_config', {})} schedule = request.body_as_json.pop('schedule', None) failure_threshold = request.body_as_json.pop('failure_threshold', None) enabled = request.body_as_json.pop('enabled', True) if request.body_as_json: raise exceptions.UnsupportedValue(request.body_as_json.keys()) scheduled_call = manager.create(repo_id, importer_id, sync_options, schedule, failure_threshold, enabled) display_call = scheduled_call.for_display() display_call['_href'] = reverse( 'repo_sync_schedule_resource', kwargs={'repo_id': repo_id, 'importer_id': importer_id, 'schedule_id': scheduled_call['id']} ) response = generate_json_response(display_call) return generate_redirect_response(response, display_call['_href'])
def validate_schedule_updates(updates): """ Validate the updates to an existing schedule @param updates: @return: """ invalid_keys = get_invalid_keys(updates, SCHEDULE_MUTABLE_FIELDS) if invalid_keys: raise pulp_exceptions.UnsupportedValue(invalid_keys) invalid_values = [] if 'schedule' in updates and not is_valid_schedule(updates['schedule']): invalid_values.append('schedule') if 'failure_threshold' in updates and not is_valid_failure_threshold(updates['failure_threshold']): invalid_values.append('failure_threshold') if 'remaining_runs' in updates and not is_valid_remaining_runs(updates['remaining_runs']): invalid_values.append('remaining_runs') if 'enabled' in updates and not is_valid_enabled(updates['enabled']): invalid_values.append('enabled') if not invalid_values: return raise pulp_exceptions.InvalidValue(invalid_values)
def validate_schedule_options(schedule, options): """ Validate the options for a new schedule. @param schedule: new schedule @type schedule: basestring @param options: new schedule options @type options: dict @raise: L{pulp_exceptions.UnsupportedValue} @raise: L{pulp_exceptions.InvalidValue} """ invalid_keys = get_invalid_keys(options, SCHEDULE_OPTIONS_FIELDS) if invalid_keys: raise pulp_exceptions.UnsupportedValue(invalid_keys) invalid_values = [] if not is_valid_schedule(schedule): invalid_values.append('schedule') if 'failure_threshold' in options and not is_valid_failure_threshold(options['failure_threshold']): invalid_values.append('failure_threshold') if 'enabled' in options and not is_valid_enabled(options['enabled']): invalid_values.append('enabled') if not invalid_values: return raise pulp_exceptions.InvalidValue(invalid_values)
def POST(self, repo_id, importer_id): manager = manager_factory.repo_sync_schedule_manager() params = self.params() sync_options = {'override_config': params.pop('override_config', {})} schedule = params.pop('schedule', None) failure_threshold = params.pop('failure_threshold', None) enabled = params.pop('enabled', True) if params: raise exceptions.UnsupportedValue(params.keys()) scheduled_call = manager.create(repo_id, importer_id, sync_options, schedule, failure_threshold, enabled) ret = scheduled_call.for_display() ret.update(serialization.link.child_link_obj(scheduled_call.id)) return self.created(ret['_href'], ret)
def update(schedule_id, delta): """ Updates the schedule with unique ID schedule_id. This only allows updating of fields in ScheduledCall.USER_UPDATE_FIELDS. :param schedule_id: a unique ID for a schedule :type schedule_id: basestring :param delta: a dictionary of keys with values that should be modified on the schedule. :type delta: dict :return: instance of ScheduledCall representing the post-update state :rtype ScheduledCall :raise exceptions.UnsupportedValue :raise exceptions.MissingResource """ unknown_keys = set(delta.keys()) - ScheduledCall.USER_UPDATE_FIELDS if unknown_keys: raise exceptions.UnsupportedValue(list(unknown_keys)) delta['last_updated'] = time.time() # bz 1139703 - if we update iso_schedule, update the pickled object as well if 'iso_schedule' in delta: interval, start_time, occurrences = dateutils.parse_iso8601_interval( delta['iso_schedule']) delta['schedule'] = pickle.dumps(CelerySchedule(interval)) # set first_run and next_run so that the schedule update will take effect new_schedule_call = ScheduledCall(delta['iso_schedule'], 'dummytaskname') delta['first_run'] = new_schedule_call.first_run delta['next_run'] = new_schedule_call.next_run try: spec = {'_id': ObjectId(schedule_id)} except InvalidId: # During schedule update, MissingResource should be raised even if # schedule_id is invalid object_id. raise exceptions.MissingResource(schedule_id=schedule_id) schedule = ScheduledCall.get_collection().find_and_modify( query=spec, update={'$set': delta}, safe=True, new=True) if schedule is None: raise exceptions.MissingResource(schedule_id=schedule_id) return ScheduledCall.from_db(schedule)