def _validate_consumer_repo(consumer_id, repo_id, distributor_id):
"""
Validate that the given consumer, repository, and distributor are present.
Rather than raising an exception, this method returns a dictionary of missing
values and allows the caller to decide what exception to raise.
:param consumer_id: The consumer id to validate
:type consumer_id: str
:param repo_id: The repository id to validate
:type repo_id: str
:param distributor_id: The distributor_id to validate
:type distributor_id: str
:return: A dictionary containing the missing values, or an empty dict if everything is valid
:rtype: dict
"""
missing_values = {}
try:
factory.consumer_manager().get_consumer(consumer_id)
except MissingResource:
missing_values['consumer_id'] = consumer_id
try:
model.Repository.objects.get_repo_or_missing_resource(repo_id)
except MissingResource:
missing_values['repo_id'] = repo_id
try:
factory.repo_distributor_manager().get_distributor(repo_id, distributor_id)
except MissingResource:
missing_values['distributor_id'] = distributor_id
return missing_values
def get(self, request, consumer_id):
"""
List schedules <action>.
:param request: WSGI request object
:type request: django.core.handlers.wsgi.WSGIRequest
:param consumer_id: The consumer ID.
:type consumer_id: str
:raises MissingResource: if consumer does not exist
:return: Response containing consumer's schedules <action>
:rtype: django.http.HttpResponse
"""
try:
factory.consumer_manager().get_consumer(consumer_id)
except MissingResource:
raise MissingResource(consumer_id=consumer_id)
schedules = self.manager.get(consumer_id, self.ACTION)
schedule_objs = []
for schedule in schedules:
obj = scheduled_unit_management_obj(schedule.for_display())
add_link_schedule(obj, self.ACTION, consumer_id)
schedule_objs.append(obj)
return generate_json_response_with_pulp_encoder(schedule_objs)
def GET(self, consumer_id, repo_id=None):
"""
Fetch all bind objects referencing the specified consumer_id. Optionally,
specify a repo_id to fetch all bind objects for the consumer_id to the repo_id
:param consumer_id: The specified consumer.
:type consumer_id: str
:param repo_id: The repository to retrieve bindings for (optional)
:type repo_id: str
:return: A list of dictionaries that represent pulp.server.db.model.consumer.Bind objects
:rtype: list
"""
# Check to make sure the resources exist
missing_resources = {}
if repo_id is not None:
repo = managers.repo_query_manager().find_by_id(repo_id)
if repo is None:
missing_resources['repo_id'] = repo_id
# If get_consumer raises MissingResource we might miss reporting a bad repo_id
try:
managers.consumer_manager().get_consumer(consumer_id)
except MissingResource:
missing_resources['consumer_id'] = consumer_id
if len(missing_resources) > 0:
raise MissingResource(**missing_resources)
manager = managers.consumer_bind_manager()
bindings = manager.find_by_consumer(consumer_id, repo_id)
bindings = [serialization.binding.serialize(b) for b in bindings]
return self.ok(bindings)
def _validate_consumer_repo(consumer_id, repo_id, distributor_id):
"""
Validate that the given consumer, repository, and distributor are present.
Rather than raising an exception, this method returns a dictionary of missing
values and allows the caller to decide what exception to raise.
:param consumer_id: The consumer id to validate
:type consumer_id: str
:param repo_id: The repository id to validate
:type repo_id: str
:param distributor_id: The distributor_id to validate
:type distributor_id: str
:return: A dictionary containing the missing values, or an empty dict if everything is valid
:rtype: dict
"""
missing_values = {}
try:
factory.consumer_manager().get_consumer(consumer_id)
except MissingResource:
missing_values['consumer_id'] = consumer_id
try:
model.Repository.objects.get_repo_or_missing_resource(repo_id)
except MissingResource:
missing_values['repo_id'] = repo_id
try:
factory.repo_distributor_manager().get_distributor(repo_id, distributor_id)
except MissingResource:
missing_values['distributor_id'] = distributor_id
return missing_values
def get(self, request, consumer_id):
"""
List schedules <action>.
:param request: WSGI request object
:type request: django.core.handlers.wsgi.WSGIRequest
:param consumer_id: The consumer ID.
:type consumer_id: str
:raises MissingResource: if consumer does not exist
:return: Response containing consumer's schedules <action>
:rtype: django.http.HttpResponse
"""
try:
factory.consumer_manager().get_consumer(consumer_id)
except MissingResource:
raise MissingResource(consumer_id=consumer_id)
schedules = self.manager.get(consumer_id, self.ACTION)
schedule_objs = []
for schedule in schedules:
obj = scheduled_unit_management_obj(schedule.for_display())
add_link_schedule(obj, self.ACTION, consumer_id)
schedule_objs.append(obj)
return generate_json_response_with_pulp_encoder(schedule_objs)
def POST(self):
body = self.params()
id = body.get('id')
display_name = body.get('display_name')
description = body.get('description')
notes = body.get('notes')
manager = managers.consumer_manager()
args = [id, display_name, description, notes]
weight = pulp_config.config.getint('tasks', 'create_weight')
tags = [
resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, id),
action_tag('create')
]
call_request = CallRequest(manager.register,
args,
weight=weight,
tags=tags)
call_request.creates_resource(
dispatch_constants.RESOURCE_CONSUMER_TYPE, id)
call_report = CallReport.from_call_request(call_request)
call_report.serialize_result = False
consumer = execution.execute_sync(call_request, call_report)
consumer.update(
{'_href': serialization.link.child_link_obj(consumer['id'])})
return self.created(consumer['_href'], consumer)
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 POST(self, consumer_id):
"""
Create a bind association between the specified
consumer by id included in the URL path and a repo-distributor
specified in the POST body: {repo_id:<str>, distributor_id:<str>}.
Designed to be idempotent so only MissingResource is expected to
be raised by manager.
@param consumer_id: The consumer to bind.
@type consumer_id: str
@return: The list of call_reports
@rtype: list
"""
# validate consumer
consumer_manager = managers.consumer_manager()
consumer_manager.get_consumer(consumer_id)
# get other options and validate them
body = self.params()
repo_id = body.get('repo_id')
distributor_id = body.get('distributor_id')
binding_config = body.get('binding_config', None)
options = body.get('options', {})
notify_agent = body.get('notify_agent', True)
managers.repo_query_manager().get_repository(repo_id)
managers.repo_distributor_manager().get_distributor(
repo_id, distributor_id)
# bind
call_requests = bind_itinerary(consumer_id, repo_id, distributor_id,
notify_agent, binding_config, options)
execution.execute_multiple(call_requests)
def test_syntactic_sugar_methods(self):
"""
Tests the syntactic sugar methods for retrieving specific managers.
"""
# Setup
factory.initialize()
# Test
self.assertTrue(isinstance(factory.authentication_manager(), AuthenticationManager))
self.assertTrue(isinstance(factory.cert_generation_manager(), CertGenerationManager))
self.assertTrue(isinstance(factory.certificate_manager(), CertificateManager))
self.assertTrue(isinstance(factory.password_manager(), PasswordManager))
self.assertTrue(isinstance(factory.permission_manager(), PermissionManager))
self.assertTrue(isinstance(factory.permission_query_manager(), PermissionQueryManager))
self.assertTrue(isinstance(factory.role_manager(), RoleManager))
self.assertTrue(isinstance(factory.role_query_manager(), RoleQueryManager))
self.assertTrue(isinstance(factory.user_manager(), UserManager))
self.assertTrue(isinstance(factory.user_query_manager(), UserQueryManager))
self.assertTrue(isinstance(factory.repo_manager(), RepoManager))
self.assertTrue(isinstance(factory.repo_unit_association_manager(), RepoUnitAssociationManager))
self.assertTrue(isinstance(factory.repo_publish_manager(), RepoPublishManager))
self.assertTrue(isinstance(factory.repo_query_manager(), RepoQueryManager))
self.assertTrue(isinstance(factory.repo_sync_manager(), RepoSyncManager))
self.assertTrue(isinstance(factory.content_manager(), ContentManager))
self.assertTrue(isinstance(factory.content_query_manager(), ContentQueryManager))
self.assertTrue(isinstance(factory.content_upload_manager(), ContentUploadManager))
self.assertTrue(isinstance(factory.consumer_manager(), ConsumerManager))
self.assertTrue(isinstance(factory.topic_publish_manager(), TopicPublishManager))
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, 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 bind(self, consumer_id, repo_id, distributor_id, options):
"""
Request the agent to perform the specified bind. This method will be called
after the server-side representation of the binding has been created.
:param consumer_id: The 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: The options are handler specific.
:type options: dict
"""
# agent request
consumer_manager = managers.consumer_manager()
binding_manager = managers.consumer_bind_manager()
consumer = consumer_manager.get_consumer(consumer_id)
binding = binding_manager.get_bind(consumer_id, repo_id, distributor_id)
agent_bindings = self.__bindings([binding])
agent = PulpAgent(consumer)
agent.consumer.bind(agent_bindings, options)
# request tracking
action_id = factory.context().call_request_id
consumer_manager = managers.consumer_bind_manager()
consumer_manager.action_pending(
consumer_id,
repo_id,
distributor_id,
Bind.Action.BIND,
action_id)
def update(consumer_id, content_type, profile):
"""
Update a unit profile.
Created if not already exists.
:param consumer_id: uniquely identifies the consumer.
:type consumer_id: str
:param content_type: The profile (content) type ID.
:type content_type: str
:param profile: The unit profile
:type profile: object
"""
try:
profiler, config = plugin_api.get_profiler_by_type(content_type)
except plugin_exceptions.PluginNotFound:
# Not all profile types have a type specific profiler, so let's use the baseclass
# Profiler
profiler, config = (Profiler(), {})
consumer = factory.consumer_manager().get_consumer(consumer_id)
# Allow the profiler a chance to update the profile before we save it
profile = profiler.update_profile(consumer, content_type, profile,
config)
try:
p = ProfileManager.get_profile(consumer_id, content_type)
p['profile'] = profile
# We store the profile's hash anytime the profile gets altered
p['profile_hash'] = UnitProfile.calculate_hash(profile)
except MissingResource:
p = UnitProfile(consumer_id, content_type, profile)
collection = UnitProfile.get_collection()
collection.save(p, safe=True)
return p
def test_get_with_bindings(self):
"""
Test consumer with bindings.
"""
# Setup
manager = factory.repo_manager()
repo = manager.create_repo(self.REPO_ID)
manager = factory.repo_distributor_manager()
manager.add_distributor(self.REPO_ID, self.DISTRIBUTOR_TYPE_ID, {}, True, distributor_id=self.DISTRIBUTOR_ID)
manager = factory.consumer_manager()
manager.register(self.CONSUMER_ID)
manager = factory.consumer_bind_manager()
bind = manager.bind(self.CONSUMER_ID, self.REPO_ID, self.DISTRIBUTOR_ID)
# Test
params = {"bindings": True}
path = "/v2/consumers/%s/" % self.CONSUMER_ID
status, body = self.get(path, params=params)
# Verify
self.assertEqual(200, status)
self.assertEqual(self.CONSUMER_ID, body["id"])
self.assertTrue("_href" in body)
self.assertTrue(body["_href"].endswith(path))
self.assertTrue("bindings" in body)
bindings = body["bindings"]
self.assertEquals(len(bindings), 1)
self.assertEquals(bindings[0], self.REPO_ID)
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):
config = {"key1": "value1", "key2": None}
manager = factory.repo_distributor_manager()
manager.add_distributor(self.REPO_ID, "mock-distributor", config, True, distributor_id=self.DISTRIBUTOR_ID)
manager = factory.consumer_manager()
for consumer_id in self.ALL_CONSUMERS:
manager.register(consumer_id)
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 populate(self, ssl=False):
PluginTestBase.populate(self)
# register downstream
manager = managers.consumer_manager()
manager.register(self.PULP_ID)
manager = managers.repo_importer_manager()
# add importer
cfg = dict(manifest_url='http://apple.com', protocol='file')
manager.set_importer(self.REPO_ID, CITRUS_IMPORTER, cfg)
# add distributor
if ssl:
dist_conf = self.dist_conf_with_ssl()
else:
dist_conf = self.dist_conf()
manager = managers.repo_distributor_manager()
manager.add_distributor(
self.REPO_ID,
CITRUS_DISTRUBUTOR,
dist_conf,
False,
CITRUS_DISTRUBUTOR)
# bind
manager = managers.consumer_bind_manager()
manager.bind(self.PULP_ID, self.REPO_ID, CITRUS_DISTRUBUTOR)
def bind(self, consumer_id, repo_id, distributor_id, options):
"""
Request the agent to perform the specified bind. This method will be called
after the server-side representation of the binding has been created.
:param consumer_id: The 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: The options are handler specific.
:type options: dict
"""
# agent request
consumer_manager = managers.consumer_manager()
binding_manager = managers.consumer_bind_manager()
consumer = consumer_manager.get_consumer(consumer_id)
binding = binding_manager.get_bind(consumer_id, repo_id,
distributor_id)
agent_bindings = self.__bindings([binding])
agent = PulpAgent(consumer)
agent.consumer.bind(agent_bindings, options)
# request tracking
action_id = factory.context().call_request_id
consumer_manager = managers.consumer_bind_manager()
consumer_manager.action_pending(consumer_id, repo_id, distributor_id,
Bind.Action.BIND, action_id)
def POST(self):
body = self.params()
consumer_id = body.get('id')
display_name = body.get('display_name')
description = body.get('description')
notes = body.get('notes')
rsa_pub = body.get('rsa_pub')
manager = managers.consumer_manager()
created, certificate = manager.register(
consumer_id,
display_name=display_name,
description=description,
notes=notes,
rsa_pub=rsa_pub)
link = serialization.link.child_link_obj(consumer_id)
created.update({'_href': link})
document = {
'consumer': created,
'certificate': certificate
}
return self.created(link['_href'], document)
def POST(self):
body = self.params()
id = body.get('id')
display_name = body.get('display_name')
description = body.get('description')
notes = body.get('notes')
manager = managers.consumer_manager()
args = [id, display_name, description, notes]
weight = pulp_config.config.getint('tasks', 'create_weight')
tags = [resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, id),
action_tag('create')]
call_request = CallRequest(manager.register,
args,
weight=weight,
tags=tags)
call_request.creates_resource(dispatch_constants.RESOURCE_CONSUMER_TYPE, id)
call_report = CallReport.from_call_request(call_request)
call_report.serialize_result = False
consumer = execution.execute_sync(call_request, call_report)
consumer.update({'_href': serialization.link.child_link_obj(consumer['id'])})
return self.created(consumer['_href'], consumer)
def populate(self, strategy=constants.DEFAULT_STRATEGY, ssl=False):
PluginTestBase.populate(self)
# register child
manager = managers.consumer_manager()
manager.register(self.PULP_ID, notes={constants.STRATEGY_NOTE_KEY: strategy})
manager = managers.repo_importer_manager()
# add importer
importer_conf = {
constants.MANIFEST_URL_KEYWORD: 'http://redhat.com',
constants.STRATEGY_KEYWORD: constants.DEFAULT_STRATEGY,
constants.PROTOCOL_KEYWORD: 'file',
}
manager.set_importer(self.REPO_ID, constants.HTTP_IMPORTER, importer_conf)
# add distributors
if ssl:
dist_conf = self.dist_conf_with_ssl()
else:
dist_conf = self.dist_conf()
manager = managers.repo_distributor_manager()
manager.add_distributor(
self.REPO_ID,
constants.HTTP_DISTRIBUTOR,
dist_conf,
False,
constants.HTTP_DISTRIBUTOR)
manager.add_distributor(self.REPO_ID, FAKE_DISTRIBUTOR, {}, False, FAKE_DISTRIBUTOR)
# bind
conf = {constants.STRATEGY_KEYWORD: strategy}
manager = managers.consumer_bind_manager()
manager.bind(self.PULP_ID, self.REPO_ID, constants.HTTP_DISTRIBUTOR, False, conf)
def update(self, consumer_id, content_type, profile):
"""
Update a unit profile.
Created if not already exists.
@param consumer_id: uniquely identifies the consumer.
@type consumer_id: str
@param content_type: The profile (content) type ID.
@type content_type: str
@param profile: The unit profile
@type profile: object
"""
try:
profiler, config = plugin_api.get_profiler_by_type(content_type)
except plugin_exceptions.PluginNotFound:
# Not all profile types have a type specific profiler, so let's use the baseclass
# Profiler
profiler, config = (Profiler(), {})
consumer = factory.consumer_manager().get_consumer(consumer_id)
# Allow the profiler a chance to update the profile before we save it
profile = profiler.update_profile(consumer, content_type, profile, config)
try:
p = self.get_profile(consumer_id, content_type)
p['profile'] = profile
# We store the profile's hash anytime the profile gets altered
p['profile_hash'] = UnitProfile.calculate_hash(profile)
except MissingResource:
p = UnitProfile(consumer_id, content_type, profile)
collection = UnitProfile.get_collection()
collection.save(p, safe=True)
return p
def unbind(self, consumer_id, repo_id, distributor_id, options):
"""
Request the agent to perform the specified unbind.
@param consumer_id: The 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: The options are handler specific.
@type options: dict
"""
# agent request
manager = managers.consumer_manager()
consumer = manager.get_consumer(consumer_id)
binding = dict(repo_id=repo_id, distributor_id=distributor_id)
bindings = self.__unbindings([binding])
agent = PulpAgent(consumer)
agent.consumer.unbind(bindings, options)
# request tracking
action_id = factory.context().call_request_id
manager = managers.consumer_bind_manager()
manager.action_pending(
consumer_id,
repo_id,
distributor_id,
Bind.Action.UNBIND,
action_id)
def test_syntactic_sugar_methods(self):
"""
Tests the syntactic sugar methods for retrieving specific managers.
"""
# Setup
factory.initialize()
# Test
self.assertTrue(isinstance(factory.authentication_manager(), AuthenticationManager))
self.assertTrue(isinstance(factory.cert_generation_manager(), CertGenerationManager))
self.assertTrue(isinstance(factory.certificate_manager(), CertificateManager))
self.assertTrue(isinstance(factory.password_manager(), PasswordManager))
self.assertTrue(isinstance(factory.permission_manager(), PermissionManager))
self.assertTrue(isinstance(factory.permission_query_manager(), PermissionQueryManager))
self.assertTrue(isinstance(factory.role_manager(), RoleManager))
self.assertTrue(isinstance(factory.role_query_manager(), RoleQueryManager))
self.assertTrue(isinstance(factory.user_manager(), UserManager))
self.assertTrue(isinstance(factory.user_query_manager(), UserQueryManager))
self.assertTrue(isinstance(factory.repo_manager(), RepoManager))
self.assertTrue(isinstance(factory.repo_unit_association_manager(),
RepoUnitAssociationManager))
self.assertTrue(isinstance(factory.repo_publish_manager(), RepoPublishManager))
self.assertTrue(isinstance(factory.repo_query_manager(), RepoQueryManager))
self.assertTrue(isinstance(factory.repo_sync_manager(), RepoSyncManager))
self.assertTrue(isinstance(factory.content_manager(), ContentManager))
self.assertTrue(isinstance(factory.content_query_manager(), ContentQueryManager))
self.assertTrue(isinstance(factory.content_upload_manager(), ContentUploadManager))
self.assertTrue(isinstance(factory.consumer_manager(), ConsumerManager))
self.assertTrue(isinstance(factory.topic_publish_manager(), TopicPublishManager))
def uninstall_content(self, consumer_id, units, options):
"""
Uninstall content units on a consumer.
@param consumer_id: The consumer ID.
@type consumer_id: str
@param units: A list of content units to be uninstalled.
@type units: list of:
{ type_id:<str>, type_id:<dict> }
@param options: Uninstall options; based on unit type.
@type options: dict
"""
manager = managers.consumer_manager()
consumer = manager.get_consumer(consumer_id)
conduit = ProfilerConduit()
collated = Units(units)
for typeid, units in collated.items():
pc = self.__profiled_consumer(consumer_id)
profiler, cfg = self.__profiler(typeid)
units = self.__invoke_plugin(
profiler.uninstall_units,
pc,
units,
options,
cfg,
conduit)
collated[typeid] = units
units = collated.join()
agent = PulpAgent(consumer)
agent.content.uninstall(units, options)
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 GET(self, consumer_id):
"""
Get all profiles associated with a consumer.
@param consumer_id: The consumer ID.
@type consumer_id: str
@return: A list of profiles:
profile is: {consumer_id:<str>, content_type:<str>, profile:<dict>}
@return: list
"""
# Check that the consumer exists and raise a MissingResource exception, in case it doesn't.
managers.consumer_manager().get_consumer(consumer_id)
manager = managers.consumer_profile_manager()
profiles = manager.get_profiles(consumer_id)
profiles = [serialization.consumer.profile(p) for p in profiles]
return self.ok(profiles)
def bind(self, consumer_id, repo_id, distributor_id):
"""
Bind consumer to a specific distributor associated with
a repository. This call is idempotent.
@param consumer_id: uniquely identifies the consumer.
@type consumer_id: str
@param repo_id: uniquely identifies the repository.
@type repo_id: str
@param distributor_id: uniquely identifies a distributor.
@type distributor_id: str
@return: The Bind object
@rtype: SON
@raise MissingResource: when given consumer does not exist.
"""
# ensure the consumer is valid
manager = factory.consumer_manager()
manager.get_consumer(consumer_id)
# ensure the repository & distributor are valid
manager = factory.repo_distributor_manager()
manager.get_distributor(repo_id, distributor_id)
# perform the bind
collection = Bind.get_collection()
try:
bind = Bind(consumer_id, repo_id, distributor_id)
collection.save(bind, safe=True)
except DuplicateKeyError:
self.__reset_bind(consumer_id, repo_id, distributor_id)
# fetch the inserted/updated bind
bind = self.get_bind(consumer_id, repo_id, distributor_id)
# update history
details = {'repo_id':repo_id, 'distributor_id':distributor_id}
manager = factory.consumer_history_manager()
manager.record_event(consumer_id, 'repo_bound', details)
return bind
def POST(self, consumer_id):
"""
Create a bind association between the specified
consumer by id included in the URL path and a repo-distributor
specified in the POST body: {repo_id:<str>, distributor_id:<str>}.
Designed to be idempotent so only MissingResource is expected to
be raised by manager.
@param consumer_id: The consumer to bind.
@type consumer_id: str
@return: The list of call_reports
@rtype: list
"""
# validate consumer
consumer_manager = managers.consumer_manager()
consumer_manager.get_consumer(consumer_id)
# get other options and validate them
body = self.params()
repo_id = body.get('repo_id')
distributor_id = body.get('distributor_id')
binding_config = body.get('binding_config', None)
options = body.get('options', {})
notify_agent = body.get('notify_agent', True)
managers.repo_query_manager().get_repository(repo_id)
managers.repo_distributor_manager().get_distributor(repo_id, distributor_id)
# bind
call_requests = bind_itinerary(consumer_id, repo_id, distributor_id, notify_agent, binding_config, options)
execution.execute_multiple(call_requests)
def test_get_with_bindings(self):
"""
Test consumer with bindings.
"""
# Setup
manager = factory.repo_manager()
repo = manager.create_repo(self.REPO_ID)
manager = factory.repo_distributor_manager()
manager.add_distributor(
self.REPO_ID,
self.DISTRIBUTOR_TYPE_ID,
{},
True,
distributor_id=self.DISTRIBUTOR_ID)
manager = factory.consumer_manager()
manager.register(self.CONSUMER_ID)
manager = factory.consumer_bind_manager()
bind = manager.bind(self.CONSUMER_ID, self.REPO_ID, self.DISTRIBUTOR_ID)
# Test
params = {'bindings':True}
path = '/v2/consumers/%s/' % self.CONSUMER_ID
status, body = self.get(path, params=params)
# Verify
self.assertEqual(200, status)
self.assertEqual(self.CONSUMER_ID, body['id'])
self.assertTrue('_href' in body)
self.assertTrue(body['_href'].endswith(path))
self.assertTrue('bindings' in body)
bindings = body['bindings']
self.assertEquals(len(bindings), 1)
self.assertEquals(bindings[0]['repo_id'], self.REPO_ID)
self.assertEquals(bindings[0]['distributor_id'], self.DISTRIBUTOR_ID)
self.assertEquals(bindings[0]['consumer_actions'], [])
def bind(self, consumer_id, repo_id, distributor_id):
"""
Bind consumer to a specific distributor associated with
a repository. This call is idempotent.
@param consumer_id: uniquely identifies the consumer.
@type consumer_id: str
@param repo_id: uniquely identifies the repository.
@type repo_id: str
@param distributor_id: uniquely identifies a distributor.
@type distributor_id: str
@return: The Bind object
@rtype: SON
@raise MissingResource: when given consumer does not exist.
"""
manager = factory.consumer_manager()
manager.get_consumer(consumer_id)
manager = factory.repo_distributor_manager()
distributor = manager.get_distributor(repo_id, distributor_id)
bind = Bind(consumer_id, repo_id, distributor_id)
collection = Bind.get_collection()
try:
collection.save(bind, safe=True)
bind = self.get_bind(consumer_id, repo_id, distributor_id)
except DuplicateKeyError:
# idempotent
pass
manager = factory.consumer_agent_manager()
manager.bind(consumer_id, repo_id)
consumer_event_details = {"repo_id": repo_id, "distributor_id": distributor_id}
factory.consumer_history_manager().record_event(consumer_id, "repo_bound", consumer_event_details)
return bind
def populate(self):
manager = factory.consumer_manager()
for id in self.CONSUMER_IDS:
manager.register(id)
manager = factory.consumer_profile_manager()
for id in self.CONSUMER_IDS:
manager.create(id, 'rpm', self.PROFILE)
def populate(self):
manager = factory.consumer_manager()
for id in self.CONSUMER_IDS:
manager.register(id)
manager = factory.consumer_profile_manager()
for id in self.CONSUMER_IDS:
manager.create(id, 'rpm', self.PROFILE)
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 PUT(self, id):
body = self.params()
delta = body.get('delta')
manager = managers.consumer_manager()
consumer = manager.update(id, delta)
href = serialization.link.current_link_obj()
consumer.update(href)
return self.ok(consumer)
def populate_consumers(self, env):
for i in range(0, env.consumers):
id = 'consumer_%d' % i
manager = managers.consumer_manager()
manager.register(id)
manager = managers.consumer_bind_manager()
manager.bind(id, self.REPO_ID, FakeDistributor.ID, True, None)
self.populate_profile(id, env)
def populate(self):
manager = factory.repo_manager()
repo = manager.create_repo(self.REPO_ID)
manager = factory.repo_distributor_manager()
manager.add_distributor(self.REPO_ID, self.DISTRIBUTOR_TYPE_ID, {}, True, distributor_id=self.DISTRIBUTOR_ID)
mock_plugins.MOCK_DISTRIBUTOR.create_consumer_payload.return_value = self.PAYLOAD
manager = factory.consumer_manager()
manager.register(self.CONSUMER_ID)
def GET(self, id):
params = web.input()
manager = managers.consumer_manager()
consumer = manager.get_consumer(id)
consumer = expand_consumers(params, [consumer])[0]
href = serialization.link.current_link_obj()
consumer.update(href)
return self.ok(consumer)
def setUp(self):
super(ScheduledUnitInstallTests, self).setUp()
plugin_api._create_manager()
mock_plugins.install()
mock_agent.install()
self.consumer_id = 'test-consumer'
self.consumer_manager = factory.consumer_manager()
self.consumer_manager.register(self.consumer_id)
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, id):
manager = managers.consumer_manager()
tags = [
resource_tag(dispatch_constants.RESOURCE_CONSUMER_TYPE, id),
action_tag('delete'),
]
call_request = CallRequest(manager.unregister, [id], tags=tags)
call_request.deletes_resource(
dispatch_constants.RESOURCE_CONSUMER_TYPE, id)
return self.ok(execution.execute(call_request))
def unbind(self, id, repo_id):
"""
Apply a unbind to the agent.
@param repo_id: A repository ID.
@type repo_id: str
"""
manager = managers.consumer_manager()
consumer = manager.get_consumer(id)
agent = PulpAgent(consumer)
agent.consumer.unbind(repo_id)
def populate(self):
manager = factory.repo_manager()
manager.create_repo(self.REPO_ID)
manager = factory.repo_distributor_manager()
manager.add_distributor(self.REPO_ID,
self.DISTRIBUTOR_TYPE_ID, {},
True,
distributor_id=self.DISTRIBUTOR_ID)
mock_plugins.MOCK_DISTRIBUTOR.create_consumer_payload.return_value = self.PAYLOAD
manager = factory.consumer_manager()
manager.register(self.CONSUMER_ID)
def populate(self):
config = {'key1': 'value1', 'key2': None}
dist_controller.add_distributor(
self.REPO_ID,
'mock-distributor',
config,
True,
distributor_id=self.DISTRIBUTOR_ID)
manager = factory.consumer_manager()
for consumer_id in self.ALL_CONSUMERS:
manager.register(consumer_id)
def _validate_consumer(consumer_id):
"""
Determines if a given consumer_id is valid by checking its existence
in the database.
:param consumer_id: a unique ID for a consumer
:type consumer_id: basestring
"""
consumer_manager = managers_factory.consumer_manager()
consumer_manager.get_consumer(consumer_id)
def test_consumer_unregister_cleanup(self):
# Setup
self.test_create()
# Test
manager = factory.consumer_manager()
manager.unregister(self.CONSUMER_ID)
# Verify
collection = UnitProfile.get_collection()
cursor = collection.find({'consumer_id': self.CONSUMER_ID})
profiles = list(cursor)
self.assertEquals(len(profiles), 0)
def cancel_request(self, consumer_id, task_id):
"""
Cancel an agent request associated with the specified task ID.
:param consumer_id: The consumer ID.
:type consumer_id: str
:param: task_id: The task ID associated with the request.
:type: str
"""
manager = managers.consumer_manager()
consumer = manager.get_consumer(consumer_id)
agent = PulpAgent(consumer)
agent.cancel(task_id)
def populate(self):
config = {'key1': 'value1', 'key2': None}
manager = factory.repo_manager()
repo = manager.create_repo(self.REPO_ID)
manager = factory.repo_distributor_manager()
manager.add_distributor(self.REPO_ID,
'mock-distributor',
config,
True,
distributor_id=self.DISTRIBUTOR_ID)
manager = factory.consumer_manager()
manager.register(self.CONSUMER_ID)
def _inject_strategy(consumer_id, options):
"""
Inject the node-level synchronization strategy.
:param consumer_id: The consumer ID.
:type consumer_id: str
:param options: The update options.
:type options: dict
"""
manager = managers.consumer_manager()
consumer = manager.get_consumer(consumer_id)
strategy = consumer['notes'].get(constants.STRATEGY_NOTE_KEY)
options[constants.STRATEGY_KEYWORD] = strategy
def get(self, request, consumer_id):
"""
Get all profiles associated with a consumer.
:param request: WSGI request object
:type request: django.core.handlers.wsgi.WSGIRequest
:param consumer_id: A consumer ID.
:type consumer_id: str
:return: Response representing list of profiles
:rtype: django.http.HttpResponse
"""
# Check that the consumer exists and raise a MissingResource exception, in case it doesn't.
factory.consumer_manager().get_consumer(consumer_id)
manager = factory.consumer_profile_manager()
profiles = manager.get_profiles(consumer_id)
for consumer_profile in profiles:
add_link_profile(consumer_profile)
return generate_json_response_with_pulp_encoder(profiles)
def get_key(consumer_id):
"""
Get the consumer's public RSA key.
:return: The consumer's public RSA key.
:rtype: RSA.RSA
"""
rsa_pub = 'rsa_pub'
manager = managers.consumer_manager()
consumer = manager.get_consumer(consumer_id, fields=[rsa_pub])
pem = consumer[rsa_pub]
bfr = BIO.MemoryBuffer(str(pem))
return RSA.load_pub_key_bio(bfr)
def unregistered(self, consumer_id):
"""
Notification that a consumer (agent) has
been unregistered. This ensure that all registration
artifacts have been cleaned up.
:param consumer_id: The consumer ID.
:type consumer_id: str
"""
manager = managers.consumer_manager()
consumer = manager.get_consumer(consumer_id)
agent = PulpAgent(consumer)
agent.consumer.unregistered()
def _validate_consumer(consumer_id):
"""
Determines if a given consumer_id is valid by checking its existence
in the database.
:param consumer_id: a unique ID for a consumer
:type consumer_id: basestring
:raises: pulp.server.exceptions.MissingResource
"""
consumer_manager = managers_factory.consumer_manager()
consumer_manager.get_consumer(consumer_id)
