def unregister(consumer_id):
"""
Unregisters given consumer.
:param consumer_id: identifies the consumer being unregistered
:type consumer_id: str
:raises MissingResource: if the given consumer does not exist
:raises OperationFailed: if any part of the unregister process fails; the exception
will contain information on which sections failed
:raises PulpExecutionException: if error during updating database collection
"""
ConsumerManager.get_consumer(consumer_id)
# Remove associate bind
manager = factory.consumer_bind_manager()
manager.consumer_deleted(consumer_id)
# Remove associated profiles
manager = factory.consumer_profile_manager()
manager.consumer_deleted(consumer_id)
# Notify agent
agent_consumer = factory.consumer_agent_manager()
agent_consumer.unregistered(consumer_id)
# remove from consumer groups
group_manager = factory.consumer_group_manager()
group_manager.remove_consumer_from_groups(consumer_id)
# delete any scheduled unit installs
schedule_manager = factory.consumer_schedule_manager()
for schedule in schedule_manager.get(consumer_id):
# using "delete" on utils skips validation that the consumer exists.
schedule_utils.delete(schedule.id)
# Database Updates
try:
Consumer.get_collection().remove({'id': consumer_id}, safe=True)
except Exception:
_logger.exception(
'Error updating database collection while removing consumer [%s]'
% consumer_id)
raise PulpExecutionException(
"database-error"), None, sys.exc_info()[2]
# remove the consumer from any groups it was a member of
group_manager = factory.consumer_group_manager()
group_manager.remove_consumer_from_groups(consumer_id)
factory.consumer_history_manager().record_event(
consumer_id, 'consumer_unregistered')
def unregister(self, consumer_id):
"""
Unregisters given consumer.
@param consumer_id: identifies the consumer being unregistered
@type consumer_id: str
@raises MissingResource: if the given consumer does not exist
@raises OperationFailed: if any part of the unregister process fails;
the exception will contain information on which sections failed
@raises PulpExecutionException: if error during updating database collection
"""
self.get_consumer(consumer_id)
# Remove associate bind
manager = factory.consumer_bind_manager()
manager.consumer_deleted(consumer_id)
# Remove associated profiles
manager = factory.consumer_profile_manager()
manager.consumer_deleted(consumer_id)
# Notify agent
agent_consumer = factory.consumer_agent_manager()
agent_consumer.unregistered(consumer_id)
# remove from consumer groups
group_manager = factory.consumer_group_manager()
group_manager.remove_consumer_from_groups(consumer_id)
# delete any scheduled unit installs
schedule_manager = factory.schedule_manager()
schedule_manager.delete_all_unit_install_schedules(consumer_id)
schedule_manager.delete_all_unit_update_schedules(consumer_id)
schedule_manager.delete_all_unit_uninstall_schedules(consumer_id)
# Database Updates
try:
Consumer.get_collection().remove({'id' : consumer_id}, safe=True)
except Exception:
_LOG.exception('Error updating database collection while removing '
'consumer [%s]' % consumer_id)
raise PulpExecutionException("database-error"), None, sys.exc_info()[2]
# remove the consumer from any groups it was a member of
group_manager = factory.consumer_group_manager()
group_manager.remove_consumer_from_groups(consumer_id)
factory.consumer_history_manager().record_event(consumer_id, 'consumer_unregistered')
def unregister(consumer_id):
"""
Unregisters given consumer.
:param consumer_id: identifies the consumer being unregistered
:type consumer_id: str
:raises MissingResource: if the given consumer does not exist
:raises OperationFailed: if any part of the unregister process fails; the exception
will contain information on which sections failed
:raises PulpExecutionException: if error during updating database collection
"""
ConsumerManager.get_consumer(consumer_id)
# Remove associate bind
manager = factory.consumer_bind_manager()
manager.consumer_deleted(consumer_id)
# Remove associated profiles
manager = factory.consumer_profile_manager()
manager.consumer_deleted(consumer_id)
# Notify agent
agent_consumer = factory.consumer_agent_manager()
agent_consumer.unregister(consumer_id)
# remove from consumer groups
group_manager = factory.consumer_group_manager()
group_manager.remove_consumer_from_groups(consumer_id)
# delete any scheduled unit installs
schedule_manager = factory.consumer_schedule_manager()
for schedule in schedule_manager.get(consumer_id):
# using "delete" on utils skips validation that the consumer exists.
schedule_utils.delete(schedule.id)
# Database Updates
try:
Consumer.get_collection().remove({'id': consumer_id})
except Exception:
_logger.exception(
'Error updating database collection while removing consumer [%s]' % consumer_id)
raise PulpExecutionException("database-error"), None, sys.exc_info()[2]
# remove the consumer from any groups it was a member of
group_manager = factory.consumer_group_manager()
group_manager.remove_consumer_from_groups(consumer_id)
factory.consumer_history_manager().record_event(consumer_id, 'consumer_unregistered')
def populate(self):
consumer_manager = factory.consumer_manager()
consumer_manager.register(self.CONSUMER_ID1)
consumer_manager.register(self.CONSUMER_ID2)
consumer_group_manager = factory.consumer_group_manager()
consumer_group_manager.create_consumer_group(group_id=self.GROUP_ID,
consumer_ids = [self.CONSUMER_ID1, self.CONSUMER_ID2])
def post(self, request):
"""
Create a consumer group and return a serialized object containing just created group.
:param request: WSGI request object
:type request: django.core.handlers.wsgi.WSGIRequest
:return: Response containing the consumer group
:rtype: django.http.HttpResponse
:raises: MissingValue if group ID is not provided
:raises: InvalidValue if some parameters are invalid
"""
params = request.body_as_json
group_id = params.pop('id', None)
if group_id is None:
raise pulp_exceptions.MissingValue(['id'])
display_name = params.pop('display_name', None)
description = params.pop('description', None)
consumer_ids = params.pop('consumer_ids', None)
notes = params.pop('notes', None)
if params:
raise pulp_exceptions.InvalidValue(params.keys())
manager = factory.consumer_group_manager()
group = manager.create_consumer_group(group_id, display_name, description, consumer_ids,
notes)
link = {"_href": reverse('consumer_group_resource',
kwargs={'consumer_group_id': group['id']})}
group.update(link)
response = generate_json_response_with_pulp_encoder(group)
response_redirect = generate_redirect_response(response, link['_href'])
return response_redirect
def uninstall(self, consumer_group_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 id: A consumer ID.
@type id: str
@return: TBD
@rtype: dict
"""
body = self.params()
units = body.get('units')
options = body.get('options')
resources = {
dispatch_constants.RESOURCE_CONSUMER_TYPE:
{consumer_group_id:dispatch_constants.RESOURCE_READ_OPERATION},
}
args = [
consumer_group_id,
units,
options,
]
manager = managers_factory.consumer_group_manager()
call_request = CallRequest(
manager.uninstall_content,
args,
resources=resources,
weight=0,
asynchronous=True,
archive=True,)
result = execution.execute_async(self, call_request)
return 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):
"""
Create a consumer group and return a serialized object containing just created group.
:param request: WSGI request object
:type request: django.core.handlers.wsgi.WSGIRequest
:return: Response containing the consumer group
:rtype: django.http.HttpResponse
:raises: MissingValue if group ID is not provided
:raises: InvalidValue if some parameters are invalid
"""
params = request.body_as_json
group_id = params.pop('id', None)
if group_id is None:
raise pulp_exceptions.MissingValue(['id'])
display_name = params.pop('display_name', None)
description = params.pop('description', None)
consumer_ids = params.pop('consumer_ids', None)
notes = params.pop('notes', None)
if params:
raise pulp_exceptions.InvalidValue(params.keys())
manager = factory.consumer_group_manager()
group = manager.create_consumer_group(group_id, display_name, description, consumer_ids,
notes)
link = {"_href": reverse('consumer_group_resource',
kwargs={'consumer_group_id': group['id']})}
group.update(link)
response = generate_json_response_with_pulp_encoder(group)
response_redirect = generate_redirect_response(response, link['_href'])
return response_redirect
def POST(self):
group_data = self.params()
group_id = group_data.pop('id', None)
if group_id is None:
raise pulp_exceptions.MissingValue(['id'])
display_name = group_data.pop('display_name', None)
description = group_data.pop('description', None)
consumer_ids = group_data.pop('consumer_ids', None)
notes = group_data.pop('notes', None)
if group_data:
raise pulp_exceptions.InvalidValue(group_data.keys())
manager = managers_factory.consumer_group_manager()
weight = pulp_config.config.getint('tasks', 'create_weight')
tags = [
resource_tag(dispatch_constants.RESOURCE_CONSUMER_GROUP_TYPE,
group_id)
]
call_request = CallRequest(
manager.create_consumer_group,
[group_id, display_name, description, consumer_ids, notes],
weight=weight,
tags=tags)
call_request.creates_resource(
dispatch_constants.RESOURCE_CONSUMER_GROUP_TYPE, group_id)
group = execution.execute_sync(call_request)
group.update(serialization.link.child_link_obj(group['id']))
return self.created(group['_href'], group)
def DELETE(self, consumer_group_id):
manager = managers_factory.consumer_group_manager()
tags = [resource_tag(dispatch_constants.RESOURCE_CONSUMER_GROUP_TYPE, consumer_group_id)]
call_request = CallRequest(manager.delete_consumer_group,
[consumer_group_id],
tags=tags)
call_request.deletes_resource(dispatch_constants.RESOURCE_CONSUMER_GROUP_TYPE, consumer_group_id)
return execution.execute_ok(self, call_request)
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 populate(self):
consumer_manager = factory.consumer_manager()
consumer_manager.register(self.CONSUMER_ID1)
consumer_manager.register(self.CONSUMER_ID2)
consumer_group_manager = factory.consumer_group_manager()
consumer_group_manager.create_consumer_group(
group_id=self.GROUP_ID,
consumer_ids=[self.CONSUMER_ID1, self.CONSUMER_ID2])
def populate(self):
manager = managers.consumer_manager()
for consumer_id in CONSUMER_IDS:
manager.register(consumer_id)
manager = managers.consumer_group_manager()
manager.create_consumer_group(GROUP_ID)
for consumer_id in CONSUMER_IDS:
criteria = Criteria(filters={'id': consumer_id}, fields=['id'])
manager.associate(GROUP_ID, criteria)
def populate(self):
manager = managers.consumer_manager()
for consumer_id in CONSUMER_IDS:
manager.register(consumer_id)
manager = managers.consumer_group_manager()
manager.create_consumer_group(GROUP_ID)
for consumer_id in CONSUMER_IDS:
criteria = Criteria(filters={'id': consumer_id}, fields=['id'])
manager.associate(GROUP_ID, criteria)
def DELETE(self, consumer_group_id):
manager = managers_factory.consumer_group_manager()
tags = [resource_tag(dispatch_constants.RESOURCE_CONSUMER_GROUP_TYPE, consumer_group_id)]
call_request = CallRequest(manager.delete_consumer_group,
[consumer_group_id],
tags=tags)
call_request.deletes_resource(dispatch_constants.RESOURCE_CONSUMER_GROUP_TYPE, consumer_group_id)
result = execution.execute(call_request)
return self.ok(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)
matched = execution.execute(call_request)
return self.ok(matched)
def PUT(self, consumer_group_id):
update_data = self.params()
manager = managers_factory.consumer_group_manager()
tags = [resource_tag(dispatch_constants.RESOURCE_CONSUMER_GROUP_TYPE, consumer_group_id)]
call_request = CallRequest(manager.update_consumer_group,
args=[consumer_group_id],
kwargs=update_data,
tags=tags)
call_request.updates_resource(dispatch_constants.RESOURCE_CONSUMER_GROUP_TYPE, consumer_group_id)
group = execution.execute(call_request)
group.update(serialization.link.current_link_obj())
return self.ok(group)
def PUT(self, consumer_group_id):
update_data = self.params()
manager = managers_factory.consumer_group_manager()
tags = [resource_tag(dispatch_constants.RESOURCE_CONSUMER_GROUP_TYPE, consumer_group_id)]
call_request = CallRequest(manager.update_consumer_group,
args=[consumer_group_id],
kwargs=update_data,
tags=tags)
call_request.updates_resource(dispatch_constants.RESOURCE_CONSUMER_GROUP_TYPE, consumer_group_id)
group = execution.execute(call_request)
group.update(serialization.link.current_link_obj())
return self.ok(group)
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, 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 delete(self, request, consumer_group_id):
"""
Delete a specified consumer 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: An empty response
:rtype: django.http.HttpResponse
"""
manager = factory.consumer_group_manager()
result = manager.delete_consumer_group(consumer_group_id)
return generate_json_response(result)
def delete(self, request, consumer_group_id):
"""
Delete a specified consumer 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: An empty response
:rtype: django.http.HttpResponse
"""
manager = factory.consumer_group_manager()
result = manager.delete_consumer_group(consumer_group_id)
return generate_json_response(result)
def put(self, request, consumer_group_id):
"""
Update a specified consumer 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 representing the updated group
:rtype: django.http.HttpResponse
"""
update_data = request.body_as_json
manager = factory.consumer_group_manager()
group = manager.update_consumer_group(consumer_group_id, **update_data)
return generate_json_response_with_pulp_encoder(serialize(group))
def put(self, request, consumer_group_id):
"""
Update a specified consumer 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 representing the updated group
:rtype: django.http.HttpResponse
"""
update_data = request.body_as_json
manager = factory.consumer_group_manager()
group = manager.update_consumer_group(consumer_group_id, **update_data)
return generate_json_response_with_pulp_encoder(serialize(group))
def populate(self):
manager = managers.consumer_manager()
for consumer_id in CONSUMER_IDS:
manager.register(consumer_id)
manager = managers.consumer_group_manager()
manager.create_consumer_group(GROUP_ID)
for consumer_id in CONSUMER_IDS:
criteria = Criteria(filters={'id': consumer_id}, fields=['id'])
manager.associate(GROUP_ID, criteria)
manager = managers.repo_manager()
manager.create_repo(REPO_ID)
manager = managers.repo_distributor_manager()
manager.add_distributor(REPO_ID,
DISTRIBUTOR_TYPE_ID, {},
True,
distributor_id=DISTRIBUTOR_ID)
def POST(self):
group_data = self.params()
group_id = group_data.pop('id', None)
if group_id is None:
raise pulp_exceptions.MissingValue(['id'])
display_name = group_data.pop('display_name', None)
description = group_data.pop('description', None)
consumer_ids = group_data.pop('consumer_ids', None)
notes = group_data.pop('notes', None)
if group_data:
raise pulp_exceptions.InvalidValue(group_data.keys())
manager = managers_factory.consumer_group_manager()
group = manager.create_consumer_group(group_id, display_name,
description, consumer_ids, notes)
group.update(serialization.link.child_link_obj(group['id']))
return self.created(group['_href'], group)
def uninstall(self, consumer_group_id):
"""
Uninstall content (units) from the consumers in a consumer group.
Expected body: {units:[], options:<dict>}
where unit is: {type_id:<str>, unit_key={}} and the
options is a dict of uninstall options.
@param consumer_group_id: A consumer group ID.
@type consumer_group_id: str
@return: list of call requests
@rtype: list
"""
body = self.params()
units = body.get('units')
options = body.get('options')
task = managers_factory.consumer_group_manager().uninstall_content(
consumer_group_id, units, options)
raise pulp_exceptions.OperationPostponed(task)
def uninstall(self, consumer_group_id):
"""
Uninstall content (units) from the consumers in a consumer group.
Expected body: {units:[], options:<dict>}
where unit is: {type_id:<str>, unit_key={}} and the
options is a dict of uninstall options.
@param consumer_group_id: A consumer group ID.
@type consumer_group_id: str
@return: list of call requests
@rtype: list
"""
body = self.params()
units = body.get('units')
options = body.get('options')
task = managers_factory.consumer_group_manager().uninstall_content(consumer_group_id,
units, options)
raise pulp_exceptions.OperationPostponed(task)
def POST(self):
group_data = self.params()
group_id = group_data.pop('id', None)
if group_id is None:
raise pulp_exceptions.MissingValue(['id'])
display_name = group_data.pop('display_name', None)
description = group_data.pop('description', None)
consumer_ids = group_data.pop('consumer_ids', None)
notes = group_data.pop('notes', None)
if group_data:
raise pulp_exceptions.InvalidValue(group_data.keys())
manager = managers_factory.consumer_group_manager()
group = manager.create_consumer_group(group_id, display_name, description, consumer_ids,
notes)
group.update(serialization.link.child_link_obj(group['id']))
return self.created(group['_href'], group)
def POST(self, consumer_group_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 itempotent so only MissingResource is expected to
be raised by manager.
@param consumer_group_id: The consumer to bind.
@type consumer_group_id: str
@return: The created bind model object:
{consumer_group_id:<str>, repo_id:<str>, distributor_id:<str>}
@rtype: dict
"""
body = self.params()
repo_id = body.get('repo_id')
distributor_id = body.get('distributor_id')
collection = ConsumerGroup.get_collection()
consumer_group = collection.find_one({'id': consumer_group_id})
resources = {
dispatch_constants.RESOURCE_CONSUMER_TYPE:
{consumer_group_id:dispatch_constants.RESOURCE_READ_OPERATION},
dispatch_constants.RESOURCE_REPOSITORY_TYPE:
{repo_id:dispatch_constants.RESOURCE_READ_OPERATION},
dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE:
{distributor_id:dispatch_constants.RESOURCE_READ_OPERATION},
}
args = [
consumer_group_id,
repo_id,
distributor_id,
]
manager = managers_factory.consumer_group_manager()
call_request = CallRequest(
manager.bind,
args,
resources=resources,
weight=0)
link = serialization.link.child_link_obj(
consumer_group_id,
repo_id,
distributor_id)
result = execution.execute_sync_created(self, call_request, link)
return result
def POST(self, consumer_group_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 itempotent so only MissingResource is expected to
be raised by manager.
@param consumer_group_id: The consumer to bind.
@type consumer_group_id: str
@return: The created bind model object:
{consumer_group_id:<str>, repo_id:<str>, distributor_id:<str>}
@rtype: dict
"""
body = self.params()
repo_id = body.get('repo_id')
distributor_id = body.get('distributor_id')
collection = ConsumerGroup.get_collection()
consumer_group = collection.find_one({'id': consumer_group_id})
resources = {
dispatch_constants.RESOURCE_CONSUMER_TYPE: {
consumer_group_id: dispatch_constants.RESOURCE_READ_OPERATION
},
dispatch_constants.RESOURCE_REPOSITORY_TYPE: {
repo_id: dispatch_constants.RESOURCE_READ_OPERATION
},
dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE: {
distributor_id: dispatch_constants.RESOURCE_READ_OPERATION
},
}
args = [
consumer_group_id,
repo_id,
distributor_id,
]
manager = managers_factory.consumer_group_manager()
call_request = CallRequest(manager.bind,
args,
resources=resources,
weight=0)
link = serialization.link.child_link_obj(consumer_group_id, repo_id,
distributor_id)
result = execution.execute_sync_created(self, call_request, link)
return result
def DELETE(self, consumer_group_id, repo_id, distributor_id):
"""
Delete a bind association between the specified
consumer and repo-distributor. Designed to be idempotent.
@param consumer_group_id: A consumer ID.
@type consumer_group_id: str
@param repo_id: A repo ID.
@type repo_id: str
@param distributor_id: A distributor ID.
@type distributor_id: str
@return: The deleted bind model object:
{consumer_group_id:<str>, repo_id:<str>, distributor_id:<str>}
Or, None if bind does not exist.
@rtype: dict
"""
manager = managers_factory.consumer_group_manager()
resources = {
dispatch_constants.RESOURCE_CONSUMER_TYPE: {
consumer_group_id: dispatch_constants.RESOURCE_READ_OPERATION
},
dispatch_constants.RESOURCE_REPOSITORY_TYPE: {
repo_id: dispatch_constants.RESOURCE_READ_OPERATION
},
dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE: {
distributor_id: dispatch_constants.RESOURCE_READ_OPERATION
},
}
args = [
consumer_group_id,
repo_id,
distributor_id,
]
tags = [
resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE,
consumer_group_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id),
resource_tag(
dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE,
distributor_id),
action_tag('unbind')
]
call_request = CallRequest(manager.unbind,
args=args,
resources=resources,
tags=tags)
return self.ok(execution.execute(call_request))
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 put(self, request, consumer_group_id):
"""
Update a specified consumer 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 representing the updated group
:rtype: django.http.HttpResponse
"""
update_data = request.body_as_json
manager = factory.consumer_group_manager()
group = manager.update_consumer_group(consumer_group_id, **update_data)
link = {"_href": reverse('consumer_group_resource',
kwargs={'consumer_group_id': group['id']})}
group.update(link)
return generate_json_response_with_pulp_encoder(group)
def populate(self):
manager = managers.consumer_manager()
for consumer_id in CONSUMER_IDS:
manager.register(consumer_id)
manager = managers.consumer_group_manager()
manager.create_consumer_group(GROUP_ID)
for consumer_id in CONSUMER_IDS:
criteria = Criteria(filters={'id': consumer_id}, fields=['id'])
manager.associate(GROUP_ID, criteria)
manager = managers.repo_manager()
manager.create_repo(REPO_ID)
manager = managers.repo_distributor_manager()
manager.add_distributor(
REPO_ID,
DISTRIBUTOR_TYPE_ID,
{},
True,
distributor_id=DISTRIBUTOR_ID)
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 uninstall(self, request, consumer_group_id):
"""
Uninstall content (units) from the consumers in a consumer group.
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_group_id: A consumer group ID.
:type consumer_group_id: str
:raises: OperationPostponed when an async operation is performed
"""
body = request.body_as_json
units = body.get('units')
options = body.get('options')
task = factory.consumer_group_manager().uninstall_content(
consumer_group_id, units, options)
raise pulp_exceptions.OperationPostponed(task)
def uninstall(self, request, consumer_group_id):
"""
Uninstall content (units) from the consumers in a consumer group.
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_group_id: A consumer group ID.
:type consumer_group_id: str
:raises: OperationPostponed when an async operation is performed
"""
body = request.body_as_json
units = body.get('units')
options = body.get('options')
task = factory.consumer_group_manager().uninstall_content(consumer_group_id,
units, options)
raise pulp_exceptions.OperationPostponed(task)
def DELETE(self, consumer_group_id, repo_id, distributor_id):
"""
Delete a bind association between the specified
consumer and repo-distributor. Designed to be idempotent.
@param consumer_group_id: A consumer ID.
@type consumer_group_id: str
@param repo_id: A repo ID.
@type repo_id: str
@param distributor_id: A distributor ID.
@type distributor_id: str
@return: The deleted bind model object:
{consumer_group_id:<str>, repo_id:<str>, distributor_id:<str>}
Or, None if bind does not exist.
@rtype: dict
"""
manager = managers_factory.consumer_group_manager()
resources = {
dispatch_constants.RESOURCE_CONSUMER_TYPE:
{consumer_group_id:dispatch_constants.RESOURCE_READ_OPERATION},
dispatch_constants.RESOURCE_REPOSITORY_TYPE:
{repo_id:dispatch_constants.RESOURCE_READ_OPERATION},
dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE:
{distributor_id:dispatch_constants.RESOURCE_READ_OPERATION},
}
args = [
consumer_group_id,
repo_id,
distributor_id,
]
tags = [
resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE,
consumer_group_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE, distributor_id),
action_tag('unbind')
]
call_request = CallRequest(manager.unbind,
args=args,
resources=resources,
tags=tags)
return self.ok(execution.execute(call_request))
def POST(self):
group_data = self.params()
group_id = group_data.pop('id', None)
if group_id is None:
raise pulp_exceptions.MissingValue(['id'])
display_name = group_data.pop('display_name', None)
description = group_data.pop('description', None)
consumer_ids = group_data.pop('consumer_ids', None)
notes = group_data.pop('notes', None)
if group_data:
raise pulp_exceptions.InvalidValue(group_data.keys())
manager = managers_factory.consumer_group_manager()
weight = pulp_config.config.getint('tasks', 'create_weight')
tags = [resource_tag(dispatch_constants.RESOURCE_CONSUMER_GROUP_TYPE, group_id)]
call_request = CallRequest(manager.create_consumer_group,
[group_id, display_name, description, consumer_ids, notes],
weight=weight, tags=tags)
call_request.creates_resource(dispatch_constants.RESOURCE_CONSUMER_GROUP_TYPE, group_id)
group = execution.execute_sync(call_request)
group.update(serialization.link.child_link_obj(group['id']))
return self.created(group['_href'], group)
def test_factory(self):
try:
managers_factory.consumer_group_manager()
except:
self.fail(traceback.format_exc())
def DELETE(self, consumer_group_id):
manager = managers_factory.consumer_group_manager()
result = manager.delete_consumer_group(consumer_group_id)
return self.ok(result)
def setUp(self):
super(ConsumerGroupAssociationTests, self).setUp()
self.manager = managers.consumer_group_manager()
def setUp(self):
super(ConsumerGroupAssociationTests, self).setUp()
self.manager = managers.consumer_group_manager()
def PUT(self, consumer_group_id):
update_data = self.params()
manager = managers_factory.consumer_group_manager()
group = manager.update_consumer_group(consumer_group_id, **update_data)
group.update(serialization.link.current_link_obj())
return self.ok(group)
def DELETE(self, consumer_group_id):
manager = managers_factory.consumer_group_manager()
result = manager.delete_consumer_group(consumer_group_id)
return self.ok(result)
def test_factory(self):
try:
managers_factory.consumer_group_manager()
except:
self.fail(traceback.format_exc())
def PUT(self, consumer_group_id):
update_data = self.params()
manager = managers_factory.consumer_group_manager()
group = manager.update_consumer_group(consumer_group_id, **update_data)
group.update(serialization.link.current_link_obj())
return self.ok(group)
