def POST(self):
"""
Determine content applicability.
body {
consumer_criteria:<dict> or None,
repo_criteria:<dict> or None,
unit_criteria: <dict of type_id : unit_criteria> or None,
override_config: <dict> or None
}
:return:
When report_style is 'by_consumer' -
A dict of applicability reports keyed by consumer ID.
Each consumer report is:
{ <unit_type_id1> : [<ApplicabilityReport>],
<unit_type_id1> : [<ApplicabilityReport>]},
}
When report_style is 'by_units' -
A dict of <unit_type_id1>: [<ApplicabilityReport>]
where applicability_report.summary contains a list of applicable consumer ids.
:rtype: dict
"""
body = self.params()
consumer_criteria = body.get('consumer_criteria', None)
repo_criteria = body.get('repo_criteria', None)
units = body.get('unit_criteria', None)
override_config = body.get('override_config', None)
if consumer_criteria:
consumer_criteria = Criteria.from_client_input(consumer_criteria)
if repo_criteria:
repo_criteria = Criteria.from_client_input(repo_criteria)
unit_criteria = {}
if units:
for type_id, criteria in units.items():
# process if criteria is not empty
if criteria:
unit_criteria[type_id] = Criteria.from_client_input(criteria)
else:
unit_criteria[type_id] = criteria
manager = managers.consumer_applicability_manager()
report = manager.find_applicable_units(consumer_criteria, repo_criteria, unit_criteria, override_config)
for unit_type_id, applicability_reports in report.items():
if isinstance(applicability_reports, list):
report[unit_type_id] = [serialization.consumer.applicability_report(r) for r in applicability_reports]
else:
for consumer_id, report_list in applicability_reports.items():
report[unit_type_id][consumer_id] = [serialization.consumer.applicability_report(r) for r in report_list]
return self.ok(report)
def _get_query_results_from_get(self, ignore_fields=None):
"""
Looks for query parameters that define a Criteria, and returns the
results of a search based on that Criteria.
@param ignore_fields: Field names to ignore. All other fields will be
used in an attempt to generate a Criteria
instance, which will fail if unexpected field
names are present.
@type ignore_fields: list
@return: list of documents from the DB that match the given criteria
for the collection associated with this controller
@rtype: list
"""
input = web.input(field=[])
if ignore_fields:
for field in ignore_fields:
input.pop(field, None)
# rename this to 'fields' within the dict, and omit it if empty so we
# default to getting all fields
fields = input.pop('field')
if fields:
if 'id' not in fields and u'id' not in fields:
fields.append('id')
input['fields'] = fields
criteria = Criteria.from_client_input(input)
return list(self.query_method(criteria))
def post(self, request):
"""
Creates an async task to regenerate content applicability data for given consumers.
body {consumer_criteria:<dict>}
:param request: WSGI request object
:type request: django.core.handlers.wsgi.WSGIRequest
:raises MissingValue: if some parameters are missing
:raises InvalidValue: if some parameters are invalid
:raises OperationPostponed: when an async operation is performed.
"""
body = request.body_as_json
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 POST(self, consumer_group_id):
criteria = Criteria.from_client_input(self.params().get('criteria', {}))
manager = managers_factory.consumer_group_manager()
manager.unassociate(consumer_group_id, criteria)
query_manager = managers_factory.consumer_group_query_manager()
group = query_manager.get_group(consumer_group_id)
return self.ok(group['consumer_ids'])
def post(self, request):
"""
Creates an async task to regenerate content applicability data for given consumers.
body {consumer_criteria:<dict>}
:param request: WSGI request object
:type request: django.core.handlers.wsgi.WSGIRequest
:raises MissingValue: if some parameters are missing
:raises InvalidValue: if some parameters are invalid
:raises OperationPostponed: when an async operation is performed.
"""
body = request.body_as_json
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 post(self, request):
"""
Dispatch a task to regenerate content applicability data for repositories that match
the criteria passed in the body.
:param request: WSGI request object
:type request: django.core.handlers.wsgi.WSGIRequest
:raises exceptions.MissingValue: if repo_critera is not a body parameter
:raises exceptions.InvalidValue: if repo_critera (dict) has unsupported keys,
the manager will raise an InvalidValue for the
specific keys. Here, we create a parent exception
for repo_criteria and include the specific keys as
child exceptions.
:raises exceptions.OperationPostponed: dispatch a task
"""
class GroupCallReport(dict):
def serialize(self):
return self
repo_criteria_body = request.body_as_json.get('repo_criteria', None)
parallel = request.body_as_json.get('parallel', False)
if repo_criteria_body is None:
raise exceptions.MissingValue('repo_criteria')
try:
repo_criteria = Criteria.from_client_input(repo_criteria_body)
except exceptions.InvalidValue, e:
invalid_criteria = exceptions.InvalidValue('repo_criteria')
invalid_criteria.add_child_exception(e)
raise invalid_criteria
def post(self, request):
"""
Dispatch a task to regenerate content applicability data for repositories that match
the criteria passed in the body.
:param request: WSGI request object
:type request: django.core.handlers.wsgi.WSGIRequest
:raises exceptions.MissingValue: if repo_critera is not a body parameter
:raises exceptions.InvalidValue: if repo_critera (dict) has unsupported keys,
the manager will raise an InvalidValue for the
specific keys. Here, we create a parent exception
for repo_criteria and include the specific keys as
child exceptions.
:raises exceptions.OperationPostponed: dispatch a task
"""
class GroupCallReport(dict):
def serialize(self):
return self
repo_criteria_body = request.body_as_json.get('repo_criteria', None)
if repo_criteria_body is None:
raise exceptions.MissingValue('repo_criteria')
try:
repo_criteria = Criteria.from_client_input(repo_criteria_body)
except exceptions.InvalidValue, e:
invalid_criteria = exceptions.InvalidValue('repo_criteria')
invalid_criteria.add_child_exception(e)
raise invalid_criteria
def test_no_exception_for_profiler_notfound(self):
# Setup
self.populate()
# Test
user_specified_unit_criteria = {
'rpm': {
"filters": {
"name": {
"$in": ['zsh']
}
}
},
'xxx': {
"filters": {
"name": {
"$in": ['abc']
}
}
}
}
unit_criteria = {}
for type_id, criteria in user_specified_unit_criteria.items():
unit_criteria[type_id] = Criteria.from_client_input(criteria)
manager = factory.consumer_applicability_manager()
result = manager.find_applicable_units(self.CONSUMER_CRITERIA,
self.REPO_CRITERIA,
unit_criteria)
self.assertTrue(result == {})
def test_profiler_no_exception(self):
# Setup
self.populate()
profiler, cfg = plugins.get_profiler_by_type('rpm')
profiler.find_applicable_units = Mock(side_effect=KeyError)
# Test
user_specified_unit_criteria = {
'rpm': {
"filters": {
"name": {
"$in": ['zsh', 'ksh']
}
}
},
'mock-type': {
"filters": {
"name": {
"$in": ['abc', 'def']
}
}
}
}
unit_criteria = {}
for type_id, criteria in user_specified_unit_criteria.items():
unit_criteria[type_id] = Criteria.from_client_input(criteria)
manager = factory.consumer_applicability_manager()
result = manager.find_applicable_units(self.CONSUMER_CRITERIA,
self.REPO_CRITERIA,
unit_criteria)
self.assertTrue(result == {})
def POST(self):
"""
Creates an async task to regenerate content applicability data for given updated
repositories.
body {repo_criteria:<dict>}
"""
body = self.params()
repo_criteria = body.get('repo_criteria', None)
if repo_criteria is None:
raise exceptions.MissingValue('repo_criteria')
try:
repo_criteria = Criteria.from_client_input(repo_criteria)
except:
raise exceptions.InvalidValue('repo_criteria')
manager = manager_factory.applicability_regeneration_manager()
regeneration_tag = action_tag('applicability_regeneration')
call_request = CallRequest(manager.regenerate_applicability_for_repos,
[repo_criteria],
tags = [regeneration_tag])
# allow only one applicability regeneration task at a time
call_request.updates_resource(dispatch_constants.RESOURCE_REPOSITORY_PROFILE_APPLICABILITY_TYPE,
dispatch_constants.RESOURCE_ANY_ID)
return execution.execute_async(self, call_request)
def POST(self, repo_group_id):
criteria = Criteria.from_client_input(self.params().get('criteria', {}))
manager = managers_factory.repo_group_manager()
manager.unassociate(repo_group_id, criteria)
collection = RepoGroup.get_collection()
group = collection.find_one({'id': repo_group_id})
return self.ok(group['repo_ids'])
def POST(self, consumer_group_id):
criteria = Criteria.from_client_input(self.params().get(
'criteria', {}))
manager = managers_factory.consumer_group_manager()
manager.unassociate(consumer_group_id, criteria)
query_manager = managers_factory.consumer_group_query_manager()
group = query_manager.get_group(consumer_group_id)
return self.ok(group['consumer_ids'])
def POST(self, consumer_group_id):
criteria = Criteria.from_client_input(self.params().get('criteria', {}))
manager = managers_factory.consumer_group_manager()
tags = [resource_tag(dispatch_constants.RESOURCE_CONSUMER_GROUP_TYPE, consumer_group_id),
action_tag('consumer_group_unassociate')]
call_request = CallRequest(manager.unassociate,
[consumer_group_id, criteria],
tags=tags)
call_request.updates_resource(dispatch_constants.RESOURCE_CONSUMER_GROUP_TYPE, consumer_group_id)
matched = execution.execute(call_request)
return self.ok(matched)
def GET(self):
valid_filters = ['tag']
filters = self.filters(valid_filters)
criteria_filters = {}
tags = filters.get('tag', [])
if tags:
criteria_filters['tags'] = {'$all': filters.get('tag', [])}
criteria = Criteria.from_client_input({'filters': criteria_filters})
serialized_task_statuses = []
for task in TaskStatusManager.find_by_criteria(criteria):
task.update(serialization.dispatch.spawned_tasks(task))
serialized_task_statuses.append(task)
return self.ok(serialized_task_statuses)
def POST(self, repo_group_id):
criteria = Criteria.from_client_input(self.params().get('criteria', {}))
manager = managers_factory.repo_group_manager()
tags = [resource_tag(dispatch_constants.RESOURCE_REPOSITORY_GROUP_TYPE, repo_group_id),
action_tag('repo_group_unassociate')]
call_request = CallRequest(manager.unassociate,
[repo_group_id, criteria],
tags=tags)
call_request.updates_resource(dispatch_constants.RESOURCE_REPOSITORY_GROUP_TYPE, repo_group_id)
execution.execute(call_request)
collection = RepoGroup.get_collection()
group = collection.find_one({'id': repo_group_id})
return self.ok(group['repo_ids'])
def test_no_exception_for_profiler_notfound(self):
# Setup
self.populate()
# Test
user_specified_unit_criteria = {'rpm': {"filters": {"name": {"$in":['zsh']}}},
'xxx': {"filters": {"name": {"$in":['abc']}}}
}
unit_criteria = {}
for type_id, criteria in user_specified_unit_criteria.items():
unit_criteria[type_id] = Criteria.from_client_input(criteria)
manager = factory.consumer_applicability_manager()
result = manager.find_applicable_units(self.CONSUMER_CRITERIA, self.REPO_CRITERIA, unit_criteria)
self.assertTrue(result == {})
def POST(self, consumer_group_id):
criteria = Criteria.from_client_input(self.params().get('criteria', {}))
manager = managers_factory.consumer_group_manager()
tags = [resource_tag(dispatch_constants.RESOURCE_CONSUMER_GROUP_TYPE, consumer_group_id),
action_tag('consumer_group_unassociate')]
call_request = CallRequest(manager.unassociate,
[consumer_group_id, criteria],
tags=tags)
call_request.updates_resource(dispatch_constants.RESOURCE_CONSUMER_GROUP_TYPE, consumer_group_id)
execution.execute(call_request)
query_manager = managers_factory.consumer_group_query_manager()
group = query_manager.get_group(consumer_group_id)
return self.ok(group['consumer_ids'])
def POST(self, repo_group_id):
criteria = Criteria.from_client_input(self.params().get('criteria', {}))
manager = managers_factory.repo_group_manager()
tags = [resource_tag(dispatch_constants.RESOURCE_REPOSITORY_GROUP_TYPE, repo_group_id),
action_tag('repo_group_unassociate')]
call_request = CallRequest(manager.unassociate,
[repo_group_id, criteria],
tags=tags)
call_request.updates_resource(dispatch_constants.RESOURCE_REPOSITORY_GROUP_TYPE, repo_group_id)
execution.execute(call_request)
collection = RepoGroup.get_collection()
group = collection.find_one({'id': repo_group_id})
return self.ok(group['repo_ids'])
def POST(self, consumer_group_id):
criteria = Criteria.from_client_input(self.params().get('criteria', {}))
manager = managers_factory.consumer_group_manager()
tags = [resource_tag(dispatch_constants.RESOURCE_CONSUMER_GROUP_TYPE, consumer_group_id),
action_tag('consumer_group_associate')]
call_request = CallRequest(manager.associate,
[consumer_group_id, criteria],
tags=tags)
call_request.updates_resource(dispatch_constants.RESOURCE_CONSUMER_GROUP_TYPE, consumer_group_id)
execution.execute(call_request)
collection = ConsumerGroup.get_collection()
group = collection.find_one({'id': consumer_group_id})
return self.ok(group['consumer_ids'])
def GET(self):
valid_filters = ['tag']
filters = self.filters(valid_filters)
criteria_filters = {}
tags = filters.get('tag', [])
if tags:
criteria_filters['tags'] = {'$all': filters.get('tag', [])}
criteria = Criteria.from_client_input({'filters': criteria_filters})
serialized_task_statuses = []
for task in TaskStatusManager.find_by_criteria(criteria):
task.update(serialization.dispatch.spawned_tasks(task))
task.update(serialization.dispatch.task_result_href(task))
serialized_task_statuses.append(task)
return self.ok(serialized_task_statuses)
def POST(self):
"""
Determine content applicability.
body {
consumer_criteria:<dict> or None,
repo_criteria:<dict> or None,
units: {<type_id1> : [{<unit1>}, {<unit2}, ..]
<type_id2> : [{<unit1>}, {<unit2}, ..]} or None
}
:return: A dict of applicability reports keyed by consumer ID.
Each consumer report is:
{ <unit_type_id1> : [<ApplicabilityReport>],
<unit_type_id1> : [<ApplicabilityReport>]},
}
:rtype: dict
"""
body = self.params()
consumer_criteria = body.get('consumer_criteria', None)
repo_criteria = body.get('repo_criteria', None)
units = body.get('units', None)
if consumer_criteria:
consumer_criteria = Criteria.from_client_input(consumer_criteria)
if repo_criteria:
repo_criteria = Criteria.from_client_input(repo_criteria)
manager = managers.consumer_applicability_manager()
report = manager.units_applicable(consumer_criteria, repo_criteria, units)
for consumer_report in report.values():
for unit_type_id, report_list in consumer_report.items():
consumer_report[unit_type_id] = [serialization.consumer.applicability_report(r) for r in report_list]
return self.ok(report)
def test_profiler_no_exception(self):
# Setup
self.populate()
profiler, cfg = plugins.get_profiler_by_type('rpm')
profiler.find_applicable_units = Mock(side_effect=KeyError)
# Test
user_specified_unit_criteria = {'rpm': {"filters": {"name": {"$in":['zsh','ksh']}}},
'mock-type': {"filters": {"name": {"$in":['abc','def']}}}
}
unit_criteria = {}
for type_id, criteria in user_specified_unit_criteria.items():
unit_criteria[type_id] = Criteria.from_client_input(criteria)
manager = factory.consumer_applicability_manager()
result = manager.find_applicable_units(self.CONSUMER_CRITERIA, self.REPO_CRITERIA, unit_criteria)
self.assertTrue(result == {})
def _get_consumer_criteria(self):
"""
Process the POST data, finding the criteria given by the user, and resolve it to Criteria
object.
:return: A Criteria object
:rtype: pulp.server.db.model.criteria.Criteria
"""
body = self.params()
try:
consumer_criteria = body.get('criteria')
except AttributeError:
raise InvalidValue('The input to this method must be a JSON object with a '
"'criteria' key.")
consumer_criteria = Criteria.from_client_input(consumer_criteria)
return consumer_criteria
def _get_query_results_from_post(self):
"""
Looks for a Criteria passed as a POST parameter on ket 'criteria', and
returns the results of a search based on that Criteria.
@return: list of documents from the DB that match the given criteria
for the collection associated with this controller
@rtype: list
"""
try:
criteria_param = self.params()['criteria']
except KeyError:
raise exceptions.MissingValue(['criteria'])
criteria = Criteria.from_client_input(criteria_param)
if criteria.fields and 'id' not in criteria.fields and u'id' not in criteria.fields:
criteria.fields.append('id')
return list(self.query_method(criteria))
def post(self, request, consumer_group_id):
"""
Associate a consumer to the group.
:param request: WSGI request object
:type request: django.core.handlers.wsgi.WSGIRequest
:param consumer_group_id: id for the requested group
:type consumer_group_id: str
:return: Response containing consumers bound to the group
:rtype: django.http.HttpResponse
"""
params = request.body_as_json
criteria = Criteria.from_client_input(params.get('criteria', {}))
manager = factory.consumer_group_manager()
manager.associate(consumer_group_id, criteria)
query_manager = factory.consumer_group_query_manager()
group = query_manager.get_group(consumer_group_id)
return generate_json_response_with_pulp_encoder(group['consumer_ids'])
def post(self, request, consumer_group_id):
"""
Unassociate a consumer from the group.
:param request: WSGI request object
:type request: django.core.handlers.wsgi.WSGIRequest
:param consumer_group_id: id for the requested group
:type consumer_group_id: str
:return: Response containing consumers bound to the group
:rtype: django.http.HttpResponse
"""
params = request.body_as_json
criteria = Criteria.from_client_input(params.get('criteria', {}))
manager = factory.consumer_group_manager()
manager.unassociate(consumer_group_id, criteria)
query_manager = factory.consumer_group_query_manager()
group = query_manager.get_group(consumer_group_id)
return generate_json_response_with_pulp_encoder(group['consumer_ids'])
def post(self, request, repo_group_id):
"""
Unassociate repos that match criteria specified in the body to the specified repo group.
Call is idempotent.
:param request: WSGI request object
:type request: django.core.handlers.wsgi.WSGIRequest
:param repo_group_id: matching repos are unassociated with this repo group
:type repo_group_id: str
:return: Response containing a serialized list of unassociated repository names
:rtype: django.http.HttpResponse
"""
criteria = Criteria.from_client_input(request.body_as_json.get('criteria', {}))
manager = managers_factory.repo_group_manager()
manager.unassociate(repo_group_id, criteria)
collection = RepoGroupModel.get_collection()
group = collection.find_one({'id': repo_group_id})
return generate_json_response(group['repo_ids'])
def _get_query_results_from_post(self, is_user_search=False):
"""
Looks for a Criteria passed as a POST parameter on ket 'criteria', and
returns the results of a search based on that Criteria.
@return: list of documents from the DB that match the given criteria
for the collection associated with this controller
@rtype: list
"""
try:
criteria_param = self.params()['criteria']
except KeyError:
raise exceptions.MissingValue(['criteria'])
criteria = Criteria.from_client_input(criteria_param)
if criteria.fields:
if not is_user_search and 'id' not in criteria.fields and u'id' not in criteria.fields:
criteria.fields.append('id')
if is_user_search and 'login' not in criteria.fields and u'login' not in criteria.fields:
criteria.fields.append('login')
return list(self.query_method(criteria))
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 post(self, request, repo_group_id):
"""
Unassociate repos that match criteria specified in the body to the specified repo group.
Call is idempotent.
:param request: WSGI request object
:type request: django.core.handlers.wsgi.WSGIRequest
:param repo_group_id: matching repos are unassociated with this repo group
:type repo_group_id: str
:return: Response containing a serialized list of unassociated repository names
:rtype: django.http.HttpResponse
"""
criteria = Criteria.from_client_input(
request.body_as_json.get('criteria', {}))
manager = managers_factory.repo_group_manager()
manager.unassociate(repo_group_id, criteria)
collection = RepoGroupModel.get_collection()
group = collection.find_one({'id': repo_group_id})
return generate_json_response(group['repo_ids'])
def POST(self):
"""
Creates an async task to regenerate content applicability data for given updated
repositories.
body {repo_criteria:<dict>}
"""
body = self.params()
repo_criteria = body.get('repo_criteria', None)
if repo_criteria is None:
raise exceptions.MissingValue('repo_criteria')
try:
repo_criteria = Criteria.from_client_input(repo_criteria)
except:
raise exceptions.InvalidValue('repo_criteria')
regeneration_tag = tags.action_tag('content_applicability_regeneration')
async_result = regenerate_applicability_for_repos.apply_async_with_reservation(
tags.RESOURCE_REPOSITORY_PROFILE_APPLICABILITY_TYPE, tags.RESOURCE_ANY_ID,
(repo_criteria.as_dict(),), tags=[regeneration_tag])
raise exceptions.OperationPostponed(async_result)
def _get_consumer_criteria(self, request):
"""
Process the POST data, finding the criteria given by the user, and resolve it to Criteria
object.
:param request: WSGI request object
:type request: django.core.handlers.wsgi.WSGIRequest
:raises InvalidValue: if some parameters were invalid
:return: A Criteria object
:rtype: pulp.server.db.model.criteria.Criteria
"""
body = request.body_as_json
consumer_criteria = body.get('criteria')
if consumer_criteria is None:
raise InvalidValue("The input to this method must be a JSON object with a "
"'criteria' key.")
consumer_criteria = Criteria.from_client_input(consumer_criteria)
return consumer_criteria
def _get_query_results_from_get(self,
ignore_fields=None,
is_user_search=False):
"""
Looks for query parameters that define a Criteria, and returns the
results of a search based on that Criteria.
@param ignore_fields: Field names to ignore. All other fields will be
used in an attempt to generate a Criteria
instance, which will fail if unexpected field
names are present.
@type ignore_fields: list
@type is_user_search: True if executing a user search. This is basically to add
login by default to the fields instead of id
@type is_user_search
@return: list of documents from the DB that match the given criteria
for the collection associated with this controller
@rtype: list
"""
input = self._ensure_input_encoding(web.input(field=[]))
if ignore_fields:
for field in ignore_fields:
input.pop(field, None)
# rename this to 'fields' within the dict, and omit it if empty so we
# default to getting all fields
fields = input.pop('field')
if fields:
if not is_user_search and 'id' not in fields and u'id' not in fields:
fields.append('id')
if is_user_search and 'login' not in fields and u'login' not in fields:
fields.append('login')
input['fields'] = fields
criteria = Criteria.from_client_input(input)
return list(self.query_method(criteria))
def _get_consumer_criteria(self, request):
"""
Process the POST data, finding the criteria given by the user, and resolve it to Criteria
object.
:param request: WSGI request object
:type request: django.core.handlers.wsgi.WSGIRequest
:raises InvalidValue: if some parameters were invalid
:return: A Criteria object
:rtype: pulp.server.db.model.criteria.Criteria
"""
body = request.body_as_json
consumer_criteria = body.get('criteria')
if consumer_criteria is None:
raise InvalidValue("The input to this method must be a JSON object with a "
"'criteria' key.")
consumer_criteria = Criteria.from_client_input(consumer_criteria)
return consumer_criteria
def POST(self):
"""
Creates an async task to regenerate content applicability data for given updated
repositories.
body {repo_criteria:<dict>}
"""
body = self.params()
repo_criteria = body.get('repo_criteria', None)
if repo_criteria is None:
raise exceptions.MissingValue('repo_criteria')
try:
repo_criteria = Criteria.from_client_input(repo_criteria)
except:
raise exceptions.InvalidValue('repo_criteria')
regeneration_tag = tags.action_tag(
'content_applicability_regeneration')
async_result = regenerate_applicability_for_repos.apply_async_with_reservation(
tags.RESOURCE_REPOSITORY_PROFILE_APPLICABILITY_TYPE,
tags.RESOURCE_ANY_ID, (repo_criteria.as_dict(), ),
tags=[regeneration_tag])
raise exceptions.OperationPostponed(async_result)
def POST(self):
"""
Determine content applicability.
body {
consumer_criteria:<dict> or None,
repo_criteria:<dict> or None,
unit_criteria: <dict of type_id : unit_criteria> or None,
override_config: <dict> or None
}
:return:
When report_style is 'by_consumer' -
A dict of applicability reports keyed by consumer ID.
Each consumer report is:
{ <unit_type_id1> : [<ApplicabilityReport>],
<unit_type_id1> : [<ApplicabilityReport>]},
}
When report_style is 'by_units' -
A dict of <unit_type_id1>: [<ApplicabilityReport>]
where applicability_report.summary contains a list of applicable consumer ids.
:rtype: dict
"""
body = self.params()
consumer_criteria = body.get('consumer_criteria', None)
repo_criteria = body.get('repo_criteria', None)
units = body.get('unit_criteria', None)
override_config = body.get('override_config', None)
if consumer_criteria:
consumer_criteria = Criteria.from_client_input(consumer_criteria)
if repo_criteria:
repo_criteria = Criteria.from_client_input(repo_criteria)
# If unit_criteria is not specified, consider all units of all types
if not units:
units = {}
all_unit_type_ids = content_types_db.all_type_ids()
for unit_type_id in all_unit_type_ids:
units[unit_type_id] = {}
# Validate user defined criteria and convert them to Criteria objects
unit_criteria = {}
for type_id, criteria in units.items():
if criteria is None:
criteria = {}
unit_criteria[type_id] = Criteria.from_client_input(criteria)
manager = managers.consumer_applicability_manager()
report = manager.find_applicable_units(consumer_criteria,
repo_criteria, unit_criteria,
override_config)
for unit_type_id, applicability_reports in report.items():
if isinstance(applicability_reports, list):
report[unit_type_id] = [
serialization.consumer.applicability_report(r)
for r in applicability_reports
]
else:
for consumer_id, report_list in applicability_reports.items():
report[unit_type_id][consumer_id] = [
serialization.consumer.applicability_report(r)
for r in report_list
]
return self.ok(report)
def POST(self):
"""
Determine content applicability.
body {
consumer_criteria:<dict> or None,
repo_criteria:<dict> or None,
unit_criteria: <dict of type_id : unit_criteria> or None,
override_config: <dict> or None
}
:return:
When report_style is 'by_consumer' -
A dict of applicability reports keyed by consumer ID.
Each consumer report is:
{ <unit_type_id1> : [<ApplicabilityReport>],
<unit_type_id1> : [<ApplicabilityReport>]},
}
When report_style is 'by_units' -
A dict of <unit_type_id1>: [<ApplicabilityReport>]
where applicability_report.summary contains a list of applicable consumer ids.
:rtype: dict
"""
body = self.params()
consumer_criteria = body.get('consumer_criteria', None)
repo_criteria = body.get('repo_criteria', None)
units = body.get('unit_criteria', None)
override_config = body.get('override_config', None)
if consumer_criteria:
consumer_criteria = Criteria.from_client_input(consumer_criteria)
if repo_criteria:
repo_criteria = Criteria.from_client_input(repo_criteria)
# If unit_criteria is not specified, consider all units of all types
if not units:
units = {}
all_unit_type_ids = content_types_db.all_type_ids()
for unit_type_id in all_unit_type_ids:
units[unit_type_id] = {}
# Validate user defined criteria and convert them to Criteria objects
unit_criteria = {}
for type_id, criteria in units.items():
if criteria is None:
criteria = {}
unit_criteria[type_id] = Criteria.from_client_input(criteria)
manager = managers.consumer_applicability_manager()
report = manager.find_applicable_units(consumer_criteria, repo_criteria, unit_criteria, override_config)
for unit_type_id, applicability_reports in report.items():
if isinstance(applicability_reports, list):
report[unit_type_id] = [serialization.consumer.applicability_report(r) for r in applicability_reports]
else:
for consumer_id, report_list in applicability_reports.items():
report[unit_type_id][consumer_id] = [serialization.consumer.applicability_report(r) for r in report_list]
return self.ok(report)