def POST(self, consumer_id):
consumer_manager = managers.consumer_manager()
consumer_manager.get_consumer(consumer_id)
schedule_data = self.params()
units = schedule_data.pop('units', None)
uninstall_options = {'options': schedule_data.pop('options', {})}
if not units:
raise MissingValue(['units'])
schedule_manager = managers.schedule_manager()
weight = pulp_config.config.getint('tasks', 'create_weight')
tags = [resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id),
action_tag('create_unit_uninstall_schedule')]
call_request = CallRequest(schedule_manager.create_unit_uninstall_schedule,
[consumer_id, units, uninstall_options, schedule_data],
weight=weight,
tags=tags,
archive=True)
call_request.reads_resource(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id)
schedule_id = execution.execute_sync(call_request)
scheduler = dispatch_factory.scheduler()
scheduled_call = scheduler.get(schedule_id)
scheduled_obj = serialization.dispatch.scheduled_unit_management_obj(scheduled_call)
scheduled_obj.update(serialization.link.child_link_obj(schedule_id))
return self.created(scheduled_obj['_href'], scheduled_obj)
def PUT(self, consumer_id, schedule_id):
consumer_manager = managers.consumer_manager()
consumer_manager.get_consumer(consumer_id)
schedule_data = self.params()
install_options = None
units = schedule_data.pop('units', None)
if 'options' in schedule_data:
install_options = {'options': schedule_data.pop('options')}
schedule_manager = managers.schedule_manager()
tags = [resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id),
resource_tag(dispatch_constants.RESOURCE_SCHEDULE_TYPE, schedule_id),
action_tag('update_unit_uninstall_schedule')]
call_request = CallRequest(schedule_manager.update_unit_uninstall_schedule,
[consumer_id, schedule_id, units, install_options, schedule_data],
tags=tags,
archive=True)
call_request.reads_resource(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id)
call_request.updates_resource(dispatch_constants.RESOURCE_SCHEDULE_TYPE, schedule_id)
execution.execute(call_request)
scheduler = dispatch_factory.scheduler()
scheduled_call = scheduler.get(schedule_id)
scheduled_obj = serialization.dispatch.scheduled_unit_management_obj(scheduled_call)
scheduled_obj.update(serialization.link.current_link_obj())
return self.ok(scheduled_obj)
def PUT(self, consumer_id, content_type):
"""
Update the association of a profile with a consumer by content type ID.
@param consumer_id: A consumer ID.
@type consumer_id: str
@param content_type: A content unit type ID.
@type content_type: str
@return: The updated model object:
{consumer_id:<str>, content_type:<str>, profile:<dict>}
@rtype: dict
"""
body = self.params()
profile = body.get('profile')
manager = managers.consumer_profile_manager()
tags = [resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id),
resource_tag(dispatch_constants.RESOURCE_CONTENT_UNIT_TYPE, content_type),
action_tag('profile_update')]
call_request = CallRequest(manager.update,
[consumer_id, content_type],
{'profile': profile},
tags=tags,
weight=0,
kwarg_blacklist=['profile'])
call_request.reads_resource(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id)
call_report = CallReport.from_call_request(call_request)
call_report.serialize_result = False
consumer = execution.execute_sync(call_request, call_report)
link = serialization.link.child_link_obj(consumer_id, content_type)
consumer.update(link)
return self.ok(consumer)
def POST(self, repo_id):
# Params
params = self.params()
query = params.get('criteria', {})
options = params.get('options', {})
timeout = params.get('timeout', 60)
try:
criteria = UnitAssociationCriteria.from_client_input(query)
except:
_LOG.error('Error parsing association criteria [%s]' % query)
raise exceptions.PulpDataException(), None, sys.exc_info()[2]
try:
timeout = int(timeout)
except ValueError:
raise exceptions.InvalidValue(['timeout']), None, sys.exc_info()[2]
# Coordinator configuration
tags = [resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id),
action_tag('resolve_dependencies')]
dependency_manager = manager_factory.dependency_manager()
call_request = CallRequest(dependency_manager.resolve_dependencies_by_criteria,
[repo_id, criteria, options],
tags=tags, archive=True)
call_request.reads_resource(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id)
return execution.execute_sync_ok(self, call_request, timeout=timedelta(seconds=timeout))
def POST(self):
# Params
params = self.params()
login = params.get('login', None)
resource = params.get('resource', None)
operation_names = params.get('operations', None)
_check_invalid_params({'login':login,
'resource':resource,
'operation_names':operation_names})
operations = _get_operations(operation_names)
# Grant permission synchronously
permission_manager = managers.permission_manager()
tags = [resource_tag(dispatch_constants.RESOURCE_PERMISSION_TYPE, resource),
resource_tag(dispatch_constants.RESOURCE_USER_TYPE, login),
action_tag('grant_permission_to_user')]
call_request = CallRequest(permission_manager.grant,
[resource, login, operations],
tags=tags)
call_request.reads_resource(dispatch_constants.RESOURCE_USER_TYPE, login)
call_request.updates_resource(dispatch_constants.RESOURCE_PERMISSION_TYPE, resource)
return self.ok(execution.execute_sync(call_request))
def DELETE(self, consumer_id, content_type):
"""
Delete an association between the specified
consumer and profile. Designed to be idempotent.
@param consumer_id: A consumer ID.
@type consumer_id: str
@param content_type: The content type ID.
@type content_type: str
@return: The deleted model object:
{consumer_id:<str>, content_type:<str>, profile:<dict>}
Or, None if bind does not exist.
@rtype: dict
"""
manager = managers.consumer_profile_manager()
args = [
consumer_id,
content_type,
]
tags = [
resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE,
consumer_id),
]
call_request = CallRequest(manager.delete, args=args, tags=tags)
call_request.reads_resource(dispatch_constants.RESOURCE_CONSUMER_TYPE,
consumer_id)
return self.ok(execution.execute(call_request))
def DELETE(self, consumer_id, schedule_id):
consumer_manager = managers.consumer_manager()
consumer_manager.get_consumer(consumer_id)
schedule_manager = managers.schedule_manager()
tags = [
resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE,
consumer_id),
resource_tag(dispatch_constants.RESOURCE_SCHEDULE_TYPE,
schedule_id),
action_tag('delete_unit_update_schedule')
]
call_request = CallRequest(
schedule_manager.delete_unit_update_schedule,
[consumer_id, schedule_id],
tags=tags,
archive=True)
call_request.reads_resource(dispatch_constants.RESOURCE_CONSUMER_TYPE,
consumer_id)
call_request.deletes_resource(
dispatch_constants.RESOURCE_SCHEDULE_TYPE, schedule_id)
result = execution.execute(call_request)
return self.ok(result)
def create_sync_schedule(self, repo_id, importer_id, sync_options, schedule_data):
"""
Create a new sync schedule for a given repository using the given importer.
@param repo_id:
@param importer_id:
@param sync_options:
@param schedule_data:
@return:
"""
# validate the input
self._validate_importer(repo_id, importer_id)
self._validate_keys(sync_options, _SYNC_OPTION_KEYS)
if 'schedule' not in schedule_data:
raise pulp_exceptions.MissingValue(['schedule'])
# build the sync call request
sync_manager = managers_factory.repo_sync_manager()
args = [repo_id]
kwargs = {'sync_config_override': sync_options['override_config']}
weight = pulp_config.config.getint('tasks', 'sync_weight')
tags = [resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_IMPORTER_TYPE, importer_id)]
call_request = CallRequest(sync_manager.sync, args, kwargs, weight=weight, tags=tags, archive=True)
call_request.reads_resource(dispatch_constants.RESOURCE_REPOSITORY_IMPORTER_TYPE, importer_id)
call_request.updates_resource(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id)
call_request.add_life_cycle_callback(dispatch_constants.CALL_ENQUEUE_LIFE_CYCLE_CALLBACK, sync_manager.prep_sync)
# schedule the sync
scheduler = dispatch_factory.scheduler()
schedule_id = scheduler.add(call_request, **schedule_data)
importer_manager = managers_factory.repo_importer_manager()
importer_manager.add_sync_schedule(repo_id, schedule_id)
return schedule_id
def DELETE(self, repo_id, distributor_id, schedule_id):
distributor_manager = manager_factory.repo_distributor_manager()
schedule_list = distributor_manager.list_publish_schedules(
repo_id, distributor_id)
if schedule_id not in schedule_list:
raise exceptions.MissingResource(repo=repo_id,
distributor=distributor_id,
publish_schedule=schedule_id)
schedule_manager = manager_factory.schedule_manager()
tags = [
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id),
resource_tag(
dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE,
distributor_id),
resource_tag(dispatch_constants.RESOURCE_SCHEDULE_TYPE,
schedule_id),
action_tag('delete_publish_schedule')
]
call_request = CallRequest(schedule_manager.delete_publish_schedule,
[repo_id, distributor_id, schedule_id],
tags=tags,
archive=True)
call_request.reads_resource(
dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id)
call_request.updates_resource(
dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE,
distributor_id)
call_request.deletes_resource(
dispatch_constants.RESOURCE_SCHEDULE_TYPE, schedule_id)
result = execution.execute(call_request)
return self.ok(result)
def POST(self):
# Params
params = self.params()
login = params.get('login', None)
resource = params.get('resource', None)
operation_names = params.get('operations', None)
_check_invalid_params({
'login': login,
'resource': resource,
'operation_names': operation_names
})
operations = _get_operations(operation_names)
# Grant permission synchronously
permission_manager = managers.permission_manager()
tags = [
resource_tag(dispatch_constants.RESOURCE_PERMISSION_TYPE,
resource),
resource_tag(dispatch_constants.RESOURCE_USER_TYPE, login),
action_tag('grant_permission_to_user')
]
call_request = CallRequest(permission_manager.grant,
[resource, login, operations],
tags=tags)
call_request.reads_resource(dispatch_constants.RESOURCE_USER_TYPE,
login)
call_request.updates_resource(
dispatch_constants.RESOURCE_PERMISSION_TYPE, resource)
return self.ok(execution.execute_sync(call_request))
def POST(self, repo_id, distributor_id):
distributor_manager = manager_factory.repo_distributor_manager()
distributor_manager.get_distributor(repo_id, distributor_id)
schedule_options = self.params()
publish_options = {'override_config': schedule_options.pop('override_config', {})}
schedule_manager = manager_factory.schedule_manager()
weight = pulp_config.config.getint('tasks', 'create_weight')
tags = [resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE, distributor_id),
action_tag('create_publish_schedule')]
call_request = CallRequest(schedule_manager.create_publish_schedule,
[repo_id, distributor_id, publish_options, schedule_options],
weight=weight,
tags=tags,
archive=True)
call_request.reads_resource(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id)
call_request.updates_resource(dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE, distributor_id)
schedule_id = execution.execute_sync(call_request)
scheduler = dispatch_factory.scheduler()
schedule = scheduler.get(schedule_id)
obj = serialization.dispatch.scheduled_publish_obj(schedule)
obj.update(serialization.link.child_link_obj(schedule_id))
return self.created(obj['_href'], obj)
def PUT(self, repo_id, distributor_id, schedule_id):
distributor_manager = manager_factory.repo_distributor_manager()
schedule_list = distributor_manager.list_publish_schedules(repo_id, distributor_id)
if schedule_id not in schedule_list:
raise exceptions.MissingResource(repo=repo_id, distributor=distributor_id, publish_schedule=schedule_id)
publish_update = {}
schedule_update = self.params()
if 'override_config' in schedule_update:
publish_update['override_config'] = schedule_update.pop('override_config')
schedule_manager = manager_factory.schedule_manager()
tags = [resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE, distributor_id),
resource_tag(dispatch_constants.RESOURCE_SCHEDULE_TYPE, schedule_id),
action_tag('update_publish_schedule')]
call_request = CallRequest(schedule_manager.update_publish_schedule,
[repo_id, distributor_id, schedule_id, publish_update, schedule_update],
tags=tags,
archive=True)
call_request.reads_resource(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id)
call_request.reads_resource(dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE, distributor_id)
call_request.updates_resource(dispatch_constants.RESOURCE_SCHEDULE_TYPE, schedule_id)
execution.execute(call_request)
scheduler = dispatch_factory.scheduler()
schedule = scheduler.get(schedule_id)
obj = serialization.dispatch.scheduled_publish_obj(schedule)
obj.update(serialization.link.current_link_obj())
return self.ok(obj)
def PUT(self, consumer_id, content_type):
"""
Update the association of a profile with a consumer by content type ID.
@param consumer_id: A consumer ID.
@type consumer_id: str
@param content_type: A content unit type ID.
@type content_type: str
@return: The updated model object:
{consumer_id:<str>, content_type:<str>, profile:<dict>}
@rtype: dict
"""
body = self.params()
profile = body.get('profile')
manager = managers.consumer_profile_manager()
tags = [resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id),
resource_tag(dispatch_constants.RESOURCE_CONTENT_UNIT_TYPE, content_type),
action_tag('profile_update')]
call_request = CallRequest(manager.update,
[consumer_id, content_type],
{'profile': profile},
tags=tags,
weight=0,
kwarg_blacklist=['profile'])
call_request.reads_resource(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id)
call_report = CallReport.from_call_request(call_request)
call_report.serialize_result = False
consumer = execution.execute_sync(call_request, call_report)
link = serialization.link.child_link_obj(consumer_id, content_type)
consumer.update(link)
return self.ok(consumer)
def POST(self, consumer_id):
consumer_manager = managers.consumer_manager()
consumer_manager.get_consumer(consumer_id)
schedule_data = self.params()
units = schedule_data.pop('units', None)
uninstall_options = {'options': schedule_data.pop('options', {})}
if not units:
raise MissingValue(['units'])
schedule_manager = managers.schedule_manager()
weight = pulp_config.config.getint('tasks', 'create_weight')
tags = [resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id),
action_tag('create_unit_uninstall_schedule')]
call_request = CallRequest(schedule_manager.create_unit_uninstall_schedule,
[consumer_id, units, uninstall_options, schedule_data],
weight=weight,
tags=tags,
archive=True)
call_request.reads_resource(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id)
schedule_id = execution.execute_sync(call_request)
scheduler = dispatch_factory.scheduler()
scheduled_call = scheduler.get(schedule_id)
scheduled_obj = serialization.dispatch.scheduled_unit_management_obj(scheduled_call)
scheduled_obj.update(serialization.link.child_link_obj(schedule_id))
return self.created(scheduled_obj['_href'], scheduled_obj)
def PUT(self, consumer_id, schedule_id):
consumer_manager = managers.consumer_manager()
consumer_manager.get_consumer(consumer_id)
schedule_data = self.params()
install_options = None
units = schedule_data.pop('units', None)
if 'options' in schedule_data:
install_options = {'options': schedule_data.pop('options')}
schedule_manager = managers.schedule_manager()
tags = [resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id),
resource_tag(dispatch_constants.RESOURCE_SCHEDULE_TYPE, schedule_id),
action_tag('update_unit_uninstall_schedule')]
call_request = CallRequest(schedule_manager.update_unit_uninstall_schedule,
[consumer_id, schedule_id, units, install_options, schedule_data],
tags=tags,
archive=True)
call_request.reads_resource(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id)
call_request.updates_resource(dispatch_constants.RESOURCE_SCHEDULE_TYPE, schedule_id)
execution.execute(call_request)
scheduler = dispatch_factory.scheduler()
scheduled_call = scheduler.get(schedule_id)
scheduled_obj = serialization.dispatch.scheduled_unit_management_obj(scheduled_call)
scheduled_obj.update(serialization.link.current_link_obj())
return self.ok(scheduled_obj)
def POST(self, repo_id, importer_id):
importer_manager = manager_factory.repo_importer_manager()
importer = importer_manager.get_importer(repo_id)
if importer_id != importer['id']:
raise exceptions.MissingResource(importer=importer_id)
schedule_options = self.params()
sync_options = {'override_config': schedule_options.pop('override_config', {})}
schedule_manager = manager_factory.schedule_manager()
weight = pulp_config.config.getint('tasks', 'create_weight')
tags = [resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_IMPORTER_TYPE, importer_id),
action_tag('create_sync_schedule')]
call_request = CallRequest(schedule_manager.create_sync_schedule,
[repo_id, importer_id, sync_options, schedule_options],
weight=weight,
tags=tags,
archive=True)
call_request.reads_resource(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id)
call_request.updates_resource(dispatch_constants.RESOURCE_REPOSITORY_IMPORTER_TYPE, importer_id)
schedule_id = execution.execute_sync(call_request)
scheduler = dispatch_factory.scheduler()
schedule = scheduler.get(schedule_id)
obj = serialization.dispatch.scheduled_sync_obj(schedule)
obj.update(serialization.link.child_link_obj(schedule_id))
return self.created(obj['_href'], obj)
def consumer_content_update_itinerary(consumer_id, units, options):
"""
Create an itinerary for consumer content update.
@param consumer_id: unique id of the consumer
@type consumer_id: str
@param units: units to update
@type units: list or tuple
@param options: options to pass to the update manager
@type options: dict or None
@return: list of call requests
@rtype: list
"""
manager = managers_factory.consumer_agent_manager()
args = [consumer_id]
kwargs = {'units': units, 'options': options}
weight = pulp_config.config.getint('tasks', 'consumer_content_weight')
tags = [
resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id),
action_tag('unit_update')
]
call_request = CallRequest(manager.update_content,
args,
kwargs,
weight=weight,
tags=tags,
archive=True,
asynchronous=True)
call_request.add_control_hook(dispatch_constants.CALL_CANCEL_CONTROL_HOOK,
cancel_agent_request)
call_request.reads_resource(dispatch_constants.RESOURCE_CONSUMER_TYPE,
consumer_id)
return [call_request]
def consumer_content_update_itinerary(consumer_id, units, options):
"""
Create an itinerary for consumer content update.
@param consumer_id: unique id of the consumer
@type consumer_id: str
@param units: units to update
@type units: list or tuple
@param options: options to pass to the update manager
@type options: dict or None
@return: list of call requests
@rtype: list
"""
manager = managers_factory.consumer_agent_manager()
args = [consumer_id]
kwargs = {'units': units, 'options': options}
weight = pulp_config.config.getint('tasks', 'consumer_content_weight')
tags = [resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id),
action_tag('unit_update')]
call_request = CallRequest(
manager.update_content,
args,
kwargs,
weight=weight,
tags=tags,
archive=True,
asynchronous=True,
kwarg_blacklist=['options'])
call_request.add_control_hook(dispatch_constants.CALL_CANCEL_CONTROL_HOOK, cancel_agent_request)
call_request.reads_resource(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id)
return [call_request]
def DELETE(self, consumer_id, content_type):
"""
Delete an association between the specified
consumer and profile. Designed to be idempotent.
@param consumer_id: A consumer ID.
@type consumer_id: str
@param content_type: The content type ID.
@type content_type: str
@return: The deleted model object:
{consumer_id:<str>, content_type:<str>, profile:<dict>}
Or, None if bind does not exist.
@rtype: dict
"""
manager = managers.consumer_profile_manager()
args = [
consumer_id,
content_type,
]
tags = [
resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id),
]
call_request = CallRequest(manager.delete,
args=args,
tags=tags)
call_request.reads_resource(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id)
return self.ok(execution.execute(call_request))
def create_publish_schedule(self, repo_id, distributor_id, publish_options, schedule_data):
"""
Create a new scheduled publish for the given repository and distributor.
@param repo_id:
@param distributor_id:
@param publish_options:
@param schedule_data:
@return:
"""
# validate the input
self._validate_distributor(repo_id, distributor_id)
self._validate_keys(publish_options, _PUBLISH_OPTION_KEYS)
if 'schedule' not in schedule_data:
raise pulp_exceptions.MissingValue(['schedule'])
# build the publish call
publish_manager = managers_factory.repo_publish_manager()
args = [repo_id, distributor_id]
kwargs = {'publish_config_override': publish_options['override_config']}
weight = pulp_config.config.getint('tasks', 'publish_weight')
tags = [resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE, distributor_id)]
call_request = CallRequest(publish_manager.publish, args, kwargs, weight=weight, tags=tags, archive=True)
call_request.reads_resource(dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE, distributor_id)
call_request.updates_resource(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id)
call_request.add_life_cycle_callback(dispatch_constants.CALL_ENQUEUE_LIFE_CYCLE_CALLBACK, publish_manager.prep_publish)
# schedule the publish
scheduler = dispatch_factory.scheduler()
schedule_id = scheduler.add(call_request, **schedule_data)
distributor_manager = managers_factory.repo_distributor_manager()
distributor_manager.add_publish_schedule(repo_id, distributor_id, schedule_id)
return schedule_id
def create_unit_install_schedule(self, consumer_id, units, install_options, schedule_data ):
"""
Create a schedule for installing content units on a consumer.
@param consumer_id: unique id for the consumer
@param units: list of unit type and unit key dicts
@param install_options: options to pass to the install manager
@param schedule_data: scheduling data
@return: schedule id
"""
self._validate_consumer(consumer_id)
self._validate_keys(install_options, _UNIT_INSTALL_OPTION_KEYS)
if 'schedule' not in schedule_data:
raise pulp_exceptions.MissingValue(['schedule'])
manager = managers_factory.consumer_agent_manager()
args = [consumer_id]
kwargs = {'units': units,
'options': install_options.get('options', {})}
weight = pulp_config.config.getint('tasks', 'consumer_content_weight')
tags = [resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id),
action_tag('unit_install'), action_tag('scheduled_unit_install')]
call_request = CallRequest(manager.install_content, args, kwargs, weight=weight, tags=tags, archive=True)
call_request.reads_resource(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id)
scheduler = dispatch_factory.scheduler()
schedule_id = scheduler.add(call_request, **schedule_data)
return schedule_id
def POST(self, repo_id):
# Params
params = self.params()
query = params.get('criteria', {})
options = params.get('options', {})
timeout = params.get('timeout', 60)
try:
criteria = UnitAssociationCriteria.from_client_input(query)
except:
_LOG.error('Error parsing association criteria [%s]' % query)
raise exceptions.PulpDataException(), None, sys.exc_info()[2]
try:
timeout = int(timeout)
except ValueError:
raise exceptions.InvalidValue(['timeout']), None, sys.exc_info()[2]
# Coordinator configuration
tags = [
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id),
action_tag('resolve_dependencies')
]
dependency_manager = manager_factory.dependency_manager()
call_request = CallRequest(
dependency_manager.resolve_dependencies_by_criteria,
[repo_id, criteria, options],
tags=tags,
archive=True)
call_request.reads_resource(
dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id)
return execution.execute_sync_ok(self,
call_request,
timeout=timedelta(seconds=timeout))
def DELETE(self, role_id, login):
role_manager = managers.role_manager()
tags = [resource_tag(dispatch_constants.RESOURCE_ROLE_TYPE, role_id),
action_tag('remove_user_from_role')]
call_request = CallRequest(role_manager.remove_user_from_role,
[role_id, login],
tags=tags,
archive=True)
call_request.updates_resource(dispatch_constants.RESOURCE_USER_TYPE, login)
call_request.reads_resource(dispatch_constants.RESOURCE_ROLE_TYPE, role_id)
return self.ok(execution.execute_sync(call_request))
def POST(self, dest_repo_id):
# Params
params = self.params()
source_repo_id = params.get('source_repo_id', None)
overrides = params.get('override_config', None)
if source_repo_id is None:
raise exceptions.MissingValue(['source_repo_id'])
# A 404 only applies to things in the URL, so the destination repo
# check allows the MissingResource to bubble up, but if the source
# repo doesn't exist, it's considered bad data.
repo_query_manager = manager_factory.repo_query_manager()
repo_query_manager.get_repository(dest_repo_id)
try:
repo_query_manager.get_repository(source_repo_id)
except exceptions.MissingResource:
raise exceptions.InvalidValue(['source_repo_id'])
criteria = params.get('criteria', None)
if criteria is not None:
try:
criteria = UnitAssociationCriteria.from_client_input(criteria)
except:
_LOG.error('Error parsing association criteria [%s]' %
criteria)
raise exceptions.PulpDataException(), None, sys.exc_info()[2]
association_manager = manager_factory.repo_unit_association_manager()
tags = [
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE,
dest_repo_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE,
source_repo_id),
action_tag('associate')
]
call_request = CallRequest(
association_manager.associate_from_repo,
[source_repo_id, dest_repo_id], {
'criteria': criteria,
'import_config_override': overrides
},
tags=tags,
archive=True,
kwarg_blacklist=['criteria', 'import_config_override'])
call_request.reads_resource(
dispatch_constants.RESOURCE_REPOSITORY_TYPE, source_repo_id)
call_request.updates_resource(
dispatch_constants.RESOURCE_REPOSITORY_TYPE, dest_repo_id)
return execution.execute_async(self, call_request)
def PUT(self, repo_id, distributor_id, schedule_id):
distributor_manager = manager_factory.repo_distributor_manager()
schedule_list = distributor_manager.list_publish_schedules(
repo_id, distributor_id)
if schedule_id not in schedule_list:
raise exceptions.MissingResource(repo=repo_id,
distributor=distributor_id,
publish_schedule=schedule_id)
publish_update = {}
schedule_update = self.params()
if 'override_config' in schedule_update:
publish_update['override_config'] = schedule_update.pop(
'override_config')
schedule_manager = manager_factory.schedule_manager()
tags = [
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id),
resource_tag(
dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE,
distributor_id),
resource_tag(dispatch_constants.RESOURCE_SCHEDULE_TYPE,
schedule_id),
action_tag('update_publish_schedule')
]
call_request = CallRequest(schedule_manager.update_publish_schedule, [
repo_id, distributor_id, schedule_id, publish_update,
schedule_update
],
tags=tags,
archive=True)
call_request.reads_resource(
dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id)
call_request.reads_resource(
dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE,
distributor_id)
call_request.updates_resource(
dispatch_constants.RESOURCE_SCHEDULE_TYPE, schedule_id)
execution.execute(call_request)
scheduler = dispatch_factory.scheduler()
schedule = scheduler.get(schedule_id)
obj = serialization.dispatch.scheduled_publish_obj(schedule)
obj.update(serialization.link.current_link_obj())
return self.ok(obj)
def DELETE(self, consumer_id, schedule_id):
consumer_manager = managers.consumer_manager()
consumer_manager.get_consumer(consumer_id)
schedule_manager = managers.schedule_manager()
tags = [resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id),
resource_tag(dispatch_constants.RESOURCE_SCHEDULE_TYPE, schedule_id),
action_tag('delete_unit_update_schedule')]
call_request = CallRequest(schedule_manager.delete_unit_update_schedule,
[consumer_id, schedule_id],
tags=tags,
archive=True)
call_request.reads_resource(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id)
call_request.deletes_resource(dispatch_constants.RESOURCE_SCHEDULE_TYPE, schedule_id)
result = execution.execute(call_request)
return self.ok(result)
def _create_schedule(self, management_method, management_action_name, consumer_id, units, options, schedule_data):
self._validate_consumer(consumer_id)
schedule_utils.validate_keys(options, _UNIT_OPTION_KEYS)
if 'schedule' not in schedule_data:
raise pulp_exceptions.MissingValue(['schedule'])
args = [consumer_id]
kwargs = {'units': units,
'options': options.get('options', {})}
weight = pulp_config.config.getint('tasks', 'consumer_content_weight')
tags = [resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id),
action_tag(management_action_name),
action_tag('scheduled_' + management_action_name)]
call_request = CallRequest(management_method, args, kwargs, weight=weight, tags=tags, archive=True)
call_request.reads_resource(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id)
scheduler = dispatch_factory.scheduler()
schedule_id = scheduler.add(call_request, **schedule_data)
return schedule_id
def POST(self, dest_repo_id):
# Params
params = self.params()
source_repo_id = params.get('source_repo_id', None)
overrides = params.get('override_config', None)
if source_repo_id is None:
raise exceptions.MissingValue(['source_repo_id'])
# A 404 only applies to things in the URL, so the destination repo
# check allows the MissingResource to bubble up, but if the source
# repo doesn't exist, it's considered bad data.
repo_query_manager = manager_factory.repo_query_manager()
repo_query_manager.get_repository(dest_repo_id)
try:
repo_query_manager.get_repository(source_repo_id)
except exceptions.MissingResource:
raise exceptions.InvalidValue(['source_repo_id'])
criteria = params.get('criteria', None)
if criteria is not None:
try:
criteria = UnitAssociationCriteria.from_client_input(criteria)
except:
_LOG.error('Error parsing association criteria [%s]' % criteria)
raise exceptions.PulpDataException(), None, sys.exc_info()[2]
association_manager = manager_factory.repo_unit_association_manager()
tags = [resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE, dest_repo_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE, source_repo_id),
action_tag('associate')]
call_request = CallRequest(association_manager.associate_from_repo,
[source_repo_id, dest_repo_id],
{'criteria': criteria, 'import_config_override': overrides},
tags=tags,
archive=True,
kwarg_blacklist=['criteria', 'import_config_override'])
call_request.reads_resource(dispatch_constants.RESOURCE_REPOSITORY_TYPE, source_repo_id)
call_request.updates_resource(dispatch_constants.RESOURCE_REPOSITORY_TYPE, dest_repo_id)
return execution.execute_async(self, call_request)
def DELETE(self, repo_id, distributor_id, schedule_id):
distributor_manager = manager_factory.repo_distributor_manager()
schedule_list = distributor_manager.list_publish_schedules(repo_id, distributor_id)
if schedule_id not in schedule_list:
raise exceptions.MissingResource(repo=repo_id, distributor=distributor_id, publish_schedule=schedule_id)
schedule_manager = manager_factory.schedule_manager()
tags = [resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE, distributor_id),
resource_tag(dispatch_constants.RESOURCE_SCHEDULE_TYPE, schedule_id),
action_tag('delete_publish_schedule')]
call_request = CallRequest(schedule_manager.delete_publish_schedule,
[repo_id, distributor_id, schedule_id],
tags=tags,
archive=True)
call_request.reads_resource(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id)
call_request.updates_resource(dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE, distributor_id)
call_request.deletes_resource(dispatch_constants.RESOURCE_SCHEDULE_TYPE, schedule_id)
result = execution.execute(call_request)
return self.ok(result)
def consumer_content_install_itinerary(consumer_id, units, options):
"""
Create an itinerary for consumer content installation.
@param consumer_id: unique id of the consumer
@type consumer_id: str
@param units: units to install
@type units: list or tuple
@param options: options to pass to the install manager
@type options: dict or None
@return: list of call requests
@rtype: list
"""
manager = managers_factory.consumer_agent_manager()
args = [consumer_id]
kwargs = {'units': units, 'options': options}
weight = pulp_config.config.getint('tasks', 'consumer_content_weight')
tags = [resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id),
action_tag('unit_install')]
call_request = CallRequest(manager.install_content, args, kwargs, weight=weight, tags=tags, archive=True, asynchronous=True)
call_request.reads_resource(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id)
return [call_request]
def POST(self, repo_id, importer_id):
importer_manager = manager_factory.repo_importer_manager()
importer = importer_manager.get_importer(repo_id)
if importer_id != importer['id']:
raise exceptions.MissingResource(importer=importer_id)
schedule_options = self.params()
sync_options = {
'override_config': schedule_options.pop('override_config', {})
}
schedule_manager = manager_factory.schedule_manager()
weight = pulp_config.config.getint('tasks', 'create_weight')
tags = [
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_IMPORTER_TYPE,
importer_id),
action_tag('create_sync_schedule')
]
call_request = CallRequest(
schedule_manager.create_sync_schedule,
[repo_id, importer_id, sync_options, schedule_options],
weight=weight,
tags=tags,
archive=True)
call_request.reads_resource(
dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id)
call_request.updates_resource(
dispatch_constants.RESOURCE_REPOSITORY_IMPORTER_TYPE, importer_id)
schedule_id = execution.execute_sync(call_request)
scheduler = dispatch_factory.scheduler()
schedule = scheduler.get(schedule_id)
obj = serialization.dispatch.scheduled_sync_obj(schedule)
obj.update(serialization.link.child_link_obj(schedule_id))
return self.created(obj['_href'], obj)
def POST(self, repo_id, distributor_id):
distributor_manager = manager_factory.repo_distributor_manager()
distributor_manager.get_distributor(repo_id, distributor_id)
schedule_options = self.params()
publish_options = {
'override_config': schedule_options.pop('override_config', {})
}
schedule_manager = manager_factory.schedule_manager()
weight = pulp_config.config.getint('tasks', 'create_weight')
tags = [
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id),
resource_tag(
dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE,
distributor_id),
action_tag('create_publish_schedule')
]
call_request = CallRequest(
schedule_manager.create_publish_schedule,
[repo_id, distributor_id, publish_options, schedule_options],
weight=weight,
tags=tags,
archive=True)
call_request.reads_resource(
dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id)
call_request.updates_resource(
dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE,
distributor_id)
schedule_id = execution.execute_sync(call_request)
scheduler = dispatch_factory.scheduler()
schedule = scheduler.get(schedule_id)
obj = serialization.dispatch.scheduled_publish_obj(schedule)
obj.update(serialization.link.child_link_obj(schedule_id))
return self.created(obj['_href'], obj)
def unbind_itinerary(consumer_id, repo_id, distributor_id, options):
"""
Get the unbind itinerary.
The tasks in the itinerary are as follows:
1. Mark the binding as (deleted) on the server.
2. Request that the consumer (agent) perform the unbind.
3. Delete the binding on the server.
@param consumer_id: A consumer ID.
@type consumer_id: str
@param repo_id: A repository ID.
@type repo_id: str
@param distributor_id: A distributor ID.
@type distributor_id: str
@param options: Unbind options passed to the agent handler.
@type options: dict
@return: A list of call_requests.
@rtype list
"""
call_requests = []
bind_manager = managers.consumer_bind_manager()
binding = bind_manager.get_bind(consumer_id, repo_id, distributor_id)
# agent not participating in the bind/unbind - always want a forced unbind.
if not binding['notify_agent']:
return forced_unbind_itinerary(consumer_id, repo_id, distributor_id, options)
# unbind
tags = [
resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE, distributor_id),
action_tag(ACTION_UNBIND)
]
args = [
consumer_id,
repo_id,
distributor_id,
]
unbind_request = CallRequest(
bind_manager.unbind,
args=args,
tags=tags)
unbind_request.reads_resource(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id)
call_requests.append(unbind_request)
# notify agent
tags = [
resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE, distributor_id),
action_tag(ACTION_AGENT_UNBIND)
]
args = [
consumer_id,
repo_id,
distributor_id,
options,
]
agent_manager = managers.consumer_agent_manager()
agent_request = CallRequest(
agent_manager.unbind,
args,
weight=0,
asynchronous=True,
archive=True,
tags=tags)
agent_request.add_life_cycle_callback(
dispatch_constants.CALL_SUCCESS_LIFE_CYCLE_CALLBACK,
unbind_succeeded)
agent_request.add_life_cycle_callback(
dispatch_constants.CALL_FAILURE_LIFE_CYCLE_CALLBACK,
unbind_failed)
call_requests.append(agent_request)
agent_request.depends_on(unbind_request.id)
# delete the binding
tags = [
resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE, distributor_id),
action_tag(ACTION_DELETE_BINDING)
]
args = [
consumer_id,
repo_id,
distributor_id
]
delete_request = CallRequest(bind_manager.delete, args=args, tags=tags)
unbind_request.reads_resource(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id)
call_requests.append(delete_request)
delete_request.depends_on(agent_request.id)
return call_requests
def bind_itinerary(consumer_id, repo_id, distributor_id, notify_agent, binding_config, agent_options):
"""
Get the bind itinerary:
1. Create the binding on the server.
2. Request that the consumer (agent) perform the bind.
@param consumer_id: A consumer ID.
@type consumer_id: str
@param repo_id: A repository ID.
@type repo_id: str
@param distributor_id: A distributor ID.
@type distributor_id: str
@param agent_options: Bind options passed to the agent handler.
@type agent_options: dict
@param notify_agent: indicates if the agent should be sent a message about the new binding
@type notify_agent: bool
@param binding_config: configuration options to use when generating the payload for this binding
@return: A list of call_requests.
@rtype list
"""
call_requests = []
bind_manager = managers.consumer_bind_manager()
agent_manager = managers.consumer_agent_manager()
# bind
tags = [
resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE, distributor_id),
action_tag(ACTION_BIND)
]
args = [
consumer_id,
repo_id,
distributor_id,
notify_agent,
binding_config,
]
bind_request = CallRequest(
bind_manager.bind,
args,
weight=0,
tags=tags)
bind_request.reads_resource(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id)
bind_request.reads_resource(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id)
bind_request.reads_resource(dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE, distributor_id)
call_requests.append(bind_request)
# notify agent
if notify_agent:
tags = [
resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE, distributor_id),
action_tag(ACTION_AGENT_BIND)
]
args = [
consumer_id,
repo_id,
distributor_id,
agent_options
]
agent_request = CallRequest(
agent_manager.bind,
args,
weight=0,
asynchronous=True,
archive=True,
tags=tags)
agent_request.add_life_cycle_callback(
dispatch_constants.CALL_SUCCESS_LIFE_CYCLE_CALLBACK,
bind_succeeded)
agent_request.add_life_cycle_callback(
dispatch_constants.CALL_FAILURE_LIFE_CYCLE_CALLBACK,
bind_failed)
call_requests.append(agent_request)
agent_request.depends_on(bind_request.id)
return call_requests
def forced_unbind_itinerary(consumer_id, repo_id, distributor_id, options):
"""
Get the unbind itinerary.
A forced unbind immediately deletes the binding instead
of marking it deleted and going through that lifecycle.
It is intended to be used to clean up orphaned bindings
caused by failed/unconfirmed unbind actions on the consumer.
The itinerary is:
1. Delete the binding on the server.
2. Request that the consumer (agent) perform the unbind.
@param consumer_id: A consumer ID.
@type consumer_id: str
@param repo_id: A repository ID.
@type repo_id: str
@param distributor_id: A distributor ID.
@type distributor_id: str
@param options: Unbind options passed to the agent handler.
@type options: dict
@return: A list of call_requests
@rtype list
"""
call_requests = []
bind_manager = managers.consumer_bind_manager()
binding = bind_manager.get_bind(consumer_id, repo_id, distributor_id)
# unbind
tags = [
resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE, distributor_id),
action_tag(ACTION_UNBIND)
]
args = [
consumer_id,
repo_id,
distributor_id,
True,
]
delete_request = CallRequest(bind_manager.delete, args=args, tags=tags)
delete_request.reads_resource(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id)
call_requests.append(delete_request)
# notify agent conditionally
if binding['notify_agent']:
tags = [
resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE, distributor_id),
action_tag(ACTION_AGENT_UNBIND)
]
args = [
consumer_id,
repo_id,
distributor_id,
options,
]
agent_manager = managers.consumer_agent_manager()
agent_request = CallRequest(
agent_manager.unbind,
args,
weight=0,
asynchronous=True,
archive=True,
tags=tags)
call_requests.append(agent_request)
agent_request.depends_on(delete_request.id)
return call_requests
def unbind_itinerary(consumer_id, repo_id, distributor_id, options):
"""
Get the unbind itinerary.
The tasks in the itinerary are as follows:
1. Mark the binding as (deleted) on the server.
2. Request that the consumer (agent) perform the unbind.
3. Delete the binding on the server.
@param consumer_id: A consumer ID.
@type consumer_id: str
@param repo_id: A repository ID.
@type repo_id: str
@param distributor_id: A distributor ID.
@type distributor_id: str
@param options: Unbind options passed to the agent handler.
@type options: dict
@return: A list of call_requests.
@rtype list
"""
call_requests = []
bind_manager = managers.consumer_bind_manager()
agent_manager = managers.consumer_agent_manager()
# unbind
tags = [
resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE,
distributor_id),
action_tag(ACTION_UNBIND)
]
args = [
consumer_id,
repo_id,
distributor_id,
]
unbind_request = CallRequest(bind_manager.unbind, args=args, tags=tags)
unbind_request.reads_resource(dispatch_constants.RESOURCE_CONSUMER_TYPE,
consumer_id)
call_requests.append(unbind_request)
# notify agent
tags = [
resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE,
distributor_id),
action_tag(ACTION_AGENT_UNBIND)
]
args = [
consumer_id,
repo_id,
distributor_id,
options,
]
agent_request = CallRequest(agent_manager.unbind,
args,
weight=0,
asynchronous=True,
archive=True,
tags=tags)
agent_request.add_life_cycle_callback(
dispatch_constants.CALL_SUCCESS_LIFE_CYCLE_CALLBACK, unbind_succeeded)
agent_request.add_life_cycle_callback(
dispatch_constants.CALL_FAILURE_LIFE_CYCLE_CALLBACK, unbind_failed)
call_requests.append(agent_request)
agent_request.depends_on(unbind_request.id)
# delete the binding
tags = [
resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE,
distributor_id),
action_tag(ACTION_DELETE_BINDING)
]
args = [consumer_id, repo_id, distributor_id]
delete_request = CallRequest(bind_manager.delete, args=args, tags=tags)
unbind_request.reads_resource(dispatch_constants.RESOURCE_CONSUMER_TYPE,
consumer_id)
call_requests.append(delete_request)
delete_request.depends_on(agent_request.id)
return call_requests
def forced_unbind_itinerary(consumer_id, repo_id, distributor_id, options):
"""
Get the unbind itinerary.
A forced unbind immediately deletes the binding instead
of marking it deleted and going through that lifecycle.
It is intended to be used to clean up orphaned bindings
caused by failed/unconfirmed unbind actions on the consumer.
The itinerary is:
1. Delete the binding on the server.
2. Request that the consumer (agent) perform the unbind.
@param consumer_id: A consumer ID.
@type consumer_id: str
@param repo_id: A repository ID.
@type repo_id: str
@param distributor_id: A distributor ID.
@type distributor_id: str
@param options: Unbind options passed to the agent handler.
@type options: dict
@return: A list of call_requests
@rtype list
"""
call_requests = []
bind_manager = managers.consumer_bind_manager()
agent_manager = managers.consumer_agent_manager()
# unbind
tags = [
resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE,
distributor_id),
action_tag(ACTION_UNBIND)
]
args = [
consumer_id,
repo_id,
distributor_id,
True,
]
delete_request = CallRequest(bind_manager.delete, args=args, tags=tags)
delete_request.reads_resource(dispatch_constants.RESOURCE_CONSUMER_TYPE,
consumer_id)
call_requests.append(delete_request)
# notify agent
tags = [
resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE,
distributor_id),
action_tag(ACTION_AGENT_UNBIND)
]
args = [
consumer_id,
repo_id,
distributor_id,
options,
]
agent_request = CallRequest(agent_manager.unbind,
args,
weight=0,
asynchronous=True,
archive=True,
tags=tags)
call_requests.append(agent_request)
agent_request.depends_on(delete_request.id)
return call_requests
def bind_itinerary(consumer_id, repo_id, distributor_id, notify_agent,
binding_config, agent_options):
"""
Get the bind itinerary:
1. Create the binding on the server.
2. Request that the consumer (agent) perform the bind.
@param consumer_id: A consumer ID.
@type consumer_id: str
@param repo_id: A repository ID.
@type repo_id: str
@param distributor_id: A distributor ID.
@type distributor_id: str
@param agent_options: Bind options passed to the agent handler.
@type agent_options: dict
@param notify_agent: indicates if the agent should be sent a message about the new binding
@type notify_agent: bool
@param binding_config: configuration options to use when generating the payload for this binding
@return: A list of call_requests.
@rtype list
"""
call_requests = []
bind_manager = managers.consumer_bind_manager()
agent_manager = managers.consumer_agent_manager()
# bind
tags = [
resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, consumer_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE,
distributor_id),
action_tag(ACTION_BIND)
]
args = [
consumer_id,
repo_id,
distributor_id,
notify_agent,
binding_config,
]
bind_request = CallRequest(bind_manager.bind, args, weight=0, tags=tags)
bind_request.reads_resource(dispatch_constants.RESOURCE_CONSUMER_TYPE,
consumer_id)
bind_request.reads_resource(dispatch_constants.RESOURCE_REPOSITORY_TYPE,
repo_id)
bind_request.reads_resource(
dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE,
distributor_id)
call_requests.append(bind_request)
# notify agent
if notify_agent:
tags = [
resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE,
consumer_id),
resource_tag(dispatch_constants.RESOURCE_REPOSITORY_TYPE, repo_id),
resource_tag(
dispatch_constants.RESOURCE_REPOSITORY_DISTRIBUTOR_TYPE,
distributor_id),
action_tag(ACTION_AGENT_BIND)
]
args = [consumer_id, repo_id, distributor_id, agent_options]
agent_request = CallRequest(agent_manager.bind,
args,
weight=0,
asynchronous=True,
archive=True,
tags=tags)
agent_request.add_life_cycle_callback(
dispatch_constants.CALL_SUCCESS_LIFE_CYCLE_CALLBACK,
bind_succeeded)
agent_request.add_life_cycle_callback(
dispatch_constants.CALL_FAILURE_LIFE_CYCLE_CALLBACK, bind_failed)
call_requests.append(agent_request)
agent_request.depends_on(bind_request.id)
return call_requests
