def post(self, request): """ Dispatch a delete_orphan_by_id task. :param request: WSGI request object :type request: django.core.handlers.wsgi.WSGIRequest :raises: OperationPostponed when an async operation is performed """ all_orphans = request.body_as_json task_tags = [ tags.action_tag('delete_orphans'), tags.resource_tag(tags.RESOURCE_CONTENT_UNIT_TYPE, 'orphans') ] async_task = content_orphan.delete_orphans_by_id.apply_async( [all_orphans], tags=task_tags) raise OperationPostponed(async_task)
def refresh(request): """ Refresh all content sources :param request: WSGI request object, body contains bits to upload :type request: django.core.handlers.wsgi.WSGIRequest :raises: OperationPostponed when an async operation is performed """ container = ContentContainer() content_sources = [ tags.resource_tag(RESOURCE_CONTENT_SOURCE, id) for id in container.sources.keys() ] task_tags = [tags.action_tag(ACTION_REFRESH_ALL_CONTENT_SOURCES) ] + content_sources task_result = content.refresh_content_sources.apply_async( tags=task_tags) raise OperationPostponed(task_result)
def POST(self, consumer_id): """ Creates an async task to regenerate content applicability data for given consumer. :param consumer_id: The consumer ID. :type consumer_id: basestring """ consumer_query_manager = managers.consumer_query_manager() if consumer_query_manager.find_by_id(consumer_id) is None: raise MissingResource(consumer_id=consumer_id) consumer_criteria = Criteria(filters={'consumer_id': consumer_id}) task_tags = [tags.action_tag('consumer_content_applicability_regeneration')] async_result = regenerate_applicability_for_consumers.apply_async_with_reservation( tags.RESOURCE_CONSUMER_TYPE, consumer_id, (consumer_criteria.as_dict(),), tags=task_tags) raise OperationPostponed(async_result)
def delete(self, request, content_type): """ Dispatch a delete_orphans_by_type task. :param request: WSGI request object :type request: django.core.handlers.wsgi.WSGIRequest :param content_type: restrict the list of orphans to be deleted to this content type :type content_type: str :raises: OperationPostponed when an async operation is performed """ orphan_manager = factory.content_orphan_manager() orphan_manager.validate_type(content_type) task_tags = [ tags.resource_tag(tags.RESOURCE_CONTENT_UNIT_TYPE, 'orphans') ] async_task = content_orphan.delete_orphans_by_type.apply_async( (content_type, ), tags=task_tags) raise OperationPostponed(async_task)
def POST(self, repo_group_id): params = self.params() distributor_id = params.get('id', None) overrides = params.get('override_config', None) if distributor_id is None: raise MissingValue(['id']) task_tags = [tags.resource_tag(tags.RESOURCE_REPOSITORY_GROUP_TYPE, repo_group_id), tags.resource_tag(tags.RESOURCE_REPOSITORY_GROUP_DISTRIBUTOR_TYPE, distributor_id), tags.action_tag('publish')] async_result = publish.apply_async_with_reservation( tags.RESOURCE_REPOSITORY_GROUP_TYPE, repo_group_id, args=[repo_group_id, distributor_id], kwargs={'publish_config_override' : overrides}, tags=task_tags) raise OperationPostponed(async_result)
def POST(self): """ Creates an async task to regenerate content applicability data for given consumers. body {consumer_criteria:<dict>} """ body = self.params() consumer_criteria = body.get('consumer_criteria', None) if consumer_criteria is None: raise MissingValue('consumer_criteria') try: consumer_criteria = Criteria.from_client_input(consumer_criteria) except: raise InvalidValue('consumer_criteria') task_tags = [tags.action_tag('content_applicability_regeneration')] async_result = regenerate_applicability_for_consumers.apply_async_with_reservation( tags.RESOURCE_REPOSITORY_PROFILE_APPLICABILITY_TYPE, tags.RESOURCE_ANY_ID, (consumer_criteria.as_dict(),), tags=task_tags) raise OperationPostponed(async_result)
def delete(self, request, content_type, unit_id): """ Dispatch a delete_orphans_by_id task. :param request: WSGI request object :type request: django.core.handlers.wsgi.WSGIRequest :param content_type: content type of the requested orphan :type content_type: str :param unit_id: id of the requested orphan :type unit_id: str :raises: OperationPostponed when an async operation is performed """ unit_info = [{'content_type_id': content_type, 'unit_id': unit_id}] task_tags = [ tags.resource_tag(tags.RESOURCE_CONTENT_UNIT_TYPE, 'orphans') ] async_task = content_orphan.delete_orphans_by_id.apply_async( (unit_info, ), tags=task_tags) raise OperationPostponed(async_task)
def delete(self, request, consumer_id, repo_id, distributor_id): """ Delete a bind association between the specified consumer and repo-distributor. :param request: WSGI request object :type request: django.core.handlers.wsgi.WSGIRequest :param consumer_id: A consumer ID. :type consumer_id: str :param repo_id: A repo ID. :type repo_id: str :param distributor_id: A distributor ID. :type distributor_id: str :raises OperationPostponed: will dispatch a task if 'notify_agent' is set to True :raises InvalidValue: if some parameters are invalid :return: Response representing the deleted binding(in case 'notify agent' is set to False) :rtype: django.http.HttpResponse """ body = request.body_as_json forced = body.get('force', False) if not isinstance(forced, bool): raise InvalidValue(['force']) options = body.get('options', {}) if not isinstance(options, dict): raise InvalidValue(['options']) if forced: call_report = consumer_controller.force_unbind( consumer_id, repo_id, distributor_id, options) else: call_report = consumer_controller.unbind(consumer_id, repo_id, distributor_id, options) if call_report.spawned_tasks: raise OperationPostponed(call_report) else: return generate_json_response_with_pulp_encoder( call_report.serialize())
def post(self, request, consumer_id): """ Create a bind association between the specified consumer by id included in the URL path and a repo-distributor specified in the POST body: {repo_id:<str>, distributor_id:<str>}. Designed to be idempotent so only MissingResource is expected to be raised by manager. :param request: WSGI request object :type request: django.core.handlers.wsgi.WSGIRequest :param consumer_id: consumer to bind. :type consumer_id: str :raises OperationPostponed: will dispatch a task if 'notify_agent' is set to True :raises InvalidValue: if binding_config is invalid :return: Response representing the binding(in case 'notify agent' is set to False) :rtype: django.http.HttpResponse """ # get other options and validate them body = request.body_as_json repo_id = body.get('repo_id') distributor_id = body.get('distributor_id') binding_config = body.get('binding_config', {}) options = body.get('options', {}) notify_agent = body.get('notify_agent', True) if not isinstance(binding_config, dict): raise InvalidValue(['binding_config']) call_report = consumer_controller.bind(consumer_id, repo_id, distributor_id, notify_agent, binding_config, options) if call_report.spawned_tasks: raise OperationPostponed(call_report) else: return generate_json_response_with_pulp_encoder( call_report.serialize())
def uninstall(self, request, consumer_id, units, options): """ Uninstall content (units) on a consumer. Expected body: {units:[], options:<dict>} where unit is: {type_id:<str>, unit_key={}} and the options is a dict of uninstall options. :param request: WSGI request object :type request: django.core.handlers.wsgi.WSGIRequest :param consumer_id: A consumer ID. :type consumer_id: str :param units: units to install :type units: list :param options: install options :type options: dict :raises OperationPostponed: when an async operation is performed. """ agent_manager = factory.consumer_agent_manager() task = agent_manager.uninstall_content(consumer_id, units, options) raise OperationPostponed(TaskResult.from_task_status_dict(task))
def execute_created(controller, call_request, location): """ Execute a call request via the coordinator. @param controller: web services rest controller @type controller: pulp.server.webservices.controller.base.JSONController @param call_request: call request to execute @type call_request: pulp.server.dispatch.call.CallRequest @param location: the location of the created resource @type location: str @return: http server response @deprecated: create should always return an _href field which requires post return processing """ coordinator = dispatch_factory.coordinator() call_report = coordinator.execute_call(call_request) if call_report.response is dispatch_constants.CALL_REJECTED_RESPONSE: raise ConflictingOperation(call_report.reasons) # covers postponed and accepted if call_report.state in dispatch_constants.CALL_INCOMPLETE_STATES: raise OperationPostponed(call_report) if call_report.state is dispatch_constants.CALL_ERROR_STATE: raise call_report.exception, None, call_report.traceback return controller.created(location, call_report.result)
def uninstall(self, consumer_id): """ Uninstall content (units) on a consumer. Expected body: {units:[], options:<dict>} where unit is: {type_id:<str>, unit_key={}} and the options is a dict of uninstall options. @param consumer_id: A consumer ID. @type consumer_id: str """ body = self.params() missing_params = [] units = body.get('units') if units is None: missing_params.append('units') options = body.get('options') if options is None: missing_params.append('options') if len(missing_params) > 0: raise MissingValue(missing_params) agent_manager = managers.consumer_agent_manager() task = agent_manager.uninstall_content(consumer_id, units, options) raise OperationPostponed(TaskResult.from_task_status_dict(task))
def delete(self, request, content_type): """ Dispatch a delete_orphans_by_type task. :param request: WSGI request object :type request: django.core.handlers.wsgi.WSGIRequest :param content_type: restrict the list of orphans to be deleted to this content type :type content_type: str :raises: OperationPostponed when an async operation is performed :raises: MissingResource when the content type does not exist """ try: # this tests if the type exists units.get_unit_key_fields_for_type(content_type) except ValueError: raise MissingResource(content_type_id=content_type) task_tags = [ tags.resource_tag(tags.RESOURCE_CONTENT_UNIT_TYPE, 'orphans') ] async_task = content_orphan.delete_orphans_by_type.apply_async( (content_type, ), tags=task_tags) raise OperationPostponed(async_task)
def POST(self): orphans = self.params() task_tags = [tags.action_tag('delete_orphans'), tags.resource_tag(tags.RESOURCE_CONTENT_UNIT_TYPE, 'orphans')] async_task = orphan.delete_orphans_by_id.apply_async([orphans], tags=task_tags) raise OperationPostponed(async_task)
def DELETE(self, content_type, content_id): ids = [{'content_type_id': content_type, 'unit_id': content_id}] task_tags = [tags.resource_tag(tags.RESOURCE_CONTENT_UNIT_TYPE, 'orphans')] async_task = orphan.delete_orphans_by_id.apply_async((ids,), tags=task_tags) raise OperationPostponed(async_task)
def DELETE(self, content_type): task_tags = [tags.resource_tag(tags.RESOURCE_CONTENT_UNIT_TYPE, 'orphans')] async_task = orphan.delete_orphans_by_type.apply_async((content_type,), tags=tags) raise OperationPostponed(async_task)
def DELETE(self): task_tags = [tags.resource_tag(tags.RESOURCE_CONTENT_UNIT_TYPE, 'orphans')] async_task = orphan.delete_all_orphans.apply_async(tags=task_tags) raise OperationPostponed(async_task)