def set_distributor_scratchpad(self, repo_group_id, distributor_id, contents):
"""
Sets the value of the scratchpad for the given group's distributor,
replacing the existing value if one is present.
@param contents: value to save in the scratchpad; must be serializable
@type contents: object
"""
distributor = self.get_distributor(repo_group_id, distributor_id)
distributor['scratchpad'] = contents
RepoGroupDistributor.get_collection().save(distributor, safe=True)
def set_distributor_scratchpad(self, repo_group_id, distributor_id,
contents):
"""
Sets the value of the scratchpad for the given group's distributor,
replacing the existing value if one is present.
@param contents: value to save in the scratchpad; must be serializable
@type contents: object
"""
distributor = self.get_distributor(repo_group_id, distributor_id)
distributor['scratchpad'] = contents
RepoGroupDistributor.get_collection().save(distributor, safe=True)
def test_add_distributor_replace_existing(self):
# Setup
self.distributor_manager.add_distributor(self.group_id,
'mock-group-distributor', {},
distributor_id='d1')
# Test
self.distributor_manager.add_distributor(self.group_id,
'mock-group-distributor-2',
{},
distributor_id='d1')
# Verify
all_distributors = list(RepoGroupDistributor.get_collection().find())
self.assertEqual(1, len(all_distributors))
self.assertEqual(all_distributors[0]['distributor_type_id'],
'mock-group-distributor-2')
# Plugin Calls
self.assertEqual(
1,
mock_plugins.MOCK_GROUP_DISTRIBUTOR.distributor_added.call_count)
self.assertEqual(
1,
mock_plugins.MOCK_GROUP_DISTRIBUTOR_2.distributor_added.call_count)
self.assertEqual(
1,
mock_plugins.MOCK_GROUP_DISTRIBUTOR.distributor_removed.call_count)
def _do_publish(self, group, distributor_id, distributor_instance, conduit, call_config):
distributor_coll = RepoGroupDistributor.get_collection()
publish_result_coll = RepoGroupPublishResult.get_collection()
group_id = group.id
# Perform the publish
publish_start_timestamp = _now_timestamp()
try:
report = distributor_instance.publish_group(group, conduit, call_config)
except Exception, e:
publish_end_timestamp = _now_timestamp()
# Reload the distributor in case the scratchpad is changed by the plugin
distributor = distributor_coll.find_one({'id' : distributor_id, 'repo_group_id' : group_id})
distributor['last_publish'] = publish_end_timestamp
distributor_coll.save(distributor)
# Add a publish history entry for the run
result = RepoGroupPublishResult.error_result(group_id, distributor_id,
distributor['distributor_type_id'], publish_start_timestamp,
publish_end_timestamp, e, sys.exc_info()[2])
publish_result_coll.save(result, safe=True)
_LOG.exception('Exception caught from plugin during publish call for group [%s]' % group_id)
raise PulpExecutionException(e), None, sys.exc_info()[2]
def _do_publish(group, distributor_id, distributor_instance, conduit,
call_config):
distributor_coll = RepoGroupDistributor.get_collection()
publish_result_coll = RepoGroupPublishResult.get_collection()
group_id = group.id
# Perform the publish
publish_start_timestamp = _now_timestamp()
try:
report = distributor_instance.publish_group(
group, conduit, call_config)
except Exception, e:
publish_end_timestamp = _now_timestamp()
# Reload the distributor in case the scratchpad is changed by the plugin
distributor = distributor_coll.find_one({
'id': distributor_id,
'repo_group_id': group_id
})
distributor['last_publish'] = publish_end_timestamp
distributor_coll.save(distributor)
# Add a publish history entry for the run
result = RepoGroupPublishResult.error_result(
group_id, distributor_id, distributor['distributor_type_id'],
publish_start_timestamp, publish_end_timestamp, e,
sys.exc_info()[2])
publish_result_coll.save(result)
raise
def _do_publish(group, distributor_id, distributor_instance, conduit, call_config):
distributor_coll = RepoGroupDistributor.get_collection()
publish_result_coll = RepoGroupPublishResult.get_collection()
group_id = group.id
# Perform the publish
publish_start_timestamp = _now_timestamp()
try:
report = distributor_instance.publish_group(group, conduit, call_config)
except Exception, e:
publish_end_timestamp = _now_timestamp()
# Reload the distributor in case the scratchpad is changed by the plugin
distributor = distributor_coll.find_one({"id": distributor_id, "repo_group_id": group_id})
distributor["last_publish"] = publish_end_timestamp
distributor_coll.save(distributor)
# Add a publish history entry for the run
result = RepoGroupPublishResult.error_result(
group_id,
distributor_id,
distributor["distributor_type_id"],
publish_start_timestamp,
publish_end_timestamp,
e,
sys.exc_info()[2],
)
publish_result_coll.save(result, safe=True)
raise
def get_distributor(repo_group_id, distributor_id):
"""
Returns an individual distributor on the given repo group, raising
an exception if one does not exist at the given ID.
@param repo_group_id: identifies the repo group
@type repo_group_id: str
@param distributor_id: identifies the distributor
@type distributor_id: str
@return: SON representation of the distributor
@rtype: dict
@raise MissingResource: if either there is no distributor for the
given group ID/distributor ID pair or the group itself does not exist
"""
# Check the group's existence for the exception contract first
manager_factory.repo_group_query_manager().get_group(repo_group_id)
# Check for the distributor if we know the group exists
spec = {
'repo_group_id': repo_group_id,
'id': distributor_id,
}
distributor = RepoGroupDistributor.get_collection().find_one(spec)
if distributor is None:
raise MissingResource(repo_group=repo_group_id,
distributor=distributor_id)
return distributor
def find_with_distributor_type(self, distributor_type_id):
"""
Returns a list of repository groups, including a list of distributor
instances, for all groups that have a configured distributor of the
given type. The distributor list will be stored in the group under
the key "distributors"
@return: list of group objects from the database with an extra key
added holding the distributor instances
"""
group_coll = RepoGroup.get_collection()
group_distributor_coll = RepoGroupDistributor.get_collection()
groups_by_id = {}
spec = {'distributor_type_id' : distributor_type_id}
group_distributors = list(group_distributor_coll.find(spec))
for gd in group_distributors:
group = groups_by_id.get(gd['repo_group_id'], None)
if group is None:
group = group_coll.find_one({'id' : gd['repo_group_id']})
groups_by_id[gd['repo_group_id']] = group
dists = group.setdefault('distributors', [])
dists.append(gd)
return groups_by_id.values()
def find_with_distributor_type(self, distributor_type_id):
"""
Returns a list of repository groups, including a list of distributor
instances, for all groups that have a configured distributor of the
given type. The distributor list will be stored in the group under
the key "distributors"
@return: list of group objects from the database with an extra key
added holding the distributor instances
"""
group_coll = RepoGroup.get_collection()
group_distributor_coll = RepoGroupDistributor.get_collection()
groups_by_id = {}
spec = {'distributor_type_id': distributor_type_id}
group_distributors = list(group_distributor_coll.find(spec))
for gd in group_distributors:
group = groups_by_id.get(gd['repo_group_id'], None)
if group is None:
group = group_coll.find_one({'id': gd['repo_group_id']})
groups_by_id[gd['repo_group_id']] = group
dists = group.setdefault('distributors', [])
dists.append(gd)
return groups_by_id.values()
def get_distributor(self, repo_group_id, distributor_id):
"""
Returns an individual distributor on the given repo group, raising
an exception if one does not exist at the given ID.
@param repo_group_id: identifies the repo group
@type repo_group_id: str
@param distributor_id: identifies the distributor
@type distributor_id: str
@return: SON representation of the distributor
@rtype: dict
@raise MissingResource: if either there is no distributor for the
given group ID/distributor ID pair or the group itself does not exist
"""
# Check the group's existence for the exception contract first
manager_factory.repo_group_query_manager().get_group(repo_group_id)
# Check for the distributor if we know the group exists
spec = {
'repo_group_id' : repo_group_id,
'id' : distributor_id,
}
distributor = RepoGroupDistributor.get_collection().find_one(spec)
if distributor is None:
raise MissingResource(repo_group=repo_group_id, distributor=distributor_id)
return distributor
def test_last_publish(self):
# Test - Unpublished
unpublished = self.conduit.last_publish()
self.assertTrue(unpublished is None)
# Setup - Publish
last_publish = datetime.datetime.now()
repo_group_dist = self.distributor_manager.get_distributor(self.group_id, self.distributor_id)
repo_group_dist['last_publish'] = dateutils.format_iso8601_datetime(last_publish)
RepoGroupDistributor.get_collection().save(repo_group_dist, safe=True)
# Test
found = self.conduit.last_publish()
self.assertTrue(isinstance(found, datetime.datetime))
last_publish = dateutils.parse_iso8601_datetime(repo_group_dist['last_publish']) # simulate the DB encoding
self.assertEqual(last_publish, found)
def test_last_publish(self):
# Test - Unpublished
unpublished = self.conduit.last_publish()
self.assertTrue(unpublished is None)
last_publish = datetime.datetime.now()
repo_group_dist = self.distributor_manager.get_distributor(self.group_id,
self.distributor_id)
repo_group_dist['last_publish'] = dateutils.format_iso8601_datetime(last_publish)
RepoGroupDistributor.get_collection().save(repo_group_dist, safe=True)
# Test
found = self.conduit.last_publish()
self.assertTrue(isinstance(found, datetime.datetime))
# simulate the DB encoding
last_publish = dateutils.parse_iso8601_datetime(repo_group_dist['last_publish'])
self.assertEqual(last_publish, found)
def test_delete_with_distributor(self):
# Setup
group_id = 'doomed'
self.manager.create_repo_group(group_id)
distributor_id = 'doomed-dist'
dist_manager = managers_factory.repo_group_distributor_manager()
dist_manager.add_distributor(group_id, 'mock-group-distributor', {}, distributor_id=distributor_id)
distributor = RepoGroupDistributor.get_collection().find_one({'id' : distributor_id})
self.assertTrue(distributor is not None)
# Test
self.manager.delete_repo_group(group_id)
# Verify
distributor = RepoGroupDistributor.get_collection().find_one({'id' : distributor_id})
self.assertTrue(distributor is None)
def test_delete_with_distributor(self):
# Setup
group_id = 'doomed'
self.manager.create_repo_group(group_id)
distributor_id = 'doomed-dist'
dist_manager = managers_factory.repo_group_distributor_manager()
dist_manager.add_distributor(group_id, 'mock-group-distributor', {}, distributor_id=distributor_id)
distributor = RepoGroupDistributor.get_collection().find_one({'id' : distributor_id})
self.assertTrue(distributor is not None)
# Test
self.manager.delete_repo_group(group_id)
# Verify
distributor = RepoGroupDistributor.get_collection().find_one({'id' : distributor_id})
self.assertTrue(distributor is None)
def test_remove_distributor(self):
# Setup
self.distributor_manager.add_distributor(self.group_id, 'mock-group-distributor', {}, distributor_id='d1')
# Test
self.distributor_manager.remove_distributor(self.group_id, 'd1')
# Verify
distributor = RepoGroupDistributor.get_collection().find_one({'id' : 'd1'})
self.assertTrue(distributor is None)
def test_add_distributor_multiple_distributors(self):
# Setup
self.distributor_manager.add_distributor(self.group_id, 'mock-group-distributor', {})
# Test
self.distributor_manager.add_distributor(self.group_id, 'mock-group-distributor', {})
# Verify
all_distributors = list(RepoGroupDistributor.get_collection().find())
self.assertEqual(2, len(all_distributors))
def test_add_distributor_multiple_distributors(self):
# Setup
self.distributor_manager.add_distributor(self.group_id,
'mock-group-distributor', {})
# Test
self.distributor_manager.add_distributor(self.group_id,
'mock-group-distributor', {})
# Verify
all_distributors = list(RepoGroupDistributor.get_collection().find())
self.assertEqual(2, len(all_distributors))
def test_remove_distributor(self):
# Setup
self.distributor_manager.add_distributor(self.group_id,
'mock-group-distributor', {},
distributor_id='d1')
# Test
self.distributor_manager.remove_distributor(self.group_id, 'd1')
# Verify
distributor = RepoGroupDistributor.get_collection().find_one(
{'id': 'd1'})
self.assertTrue(distributor is None)
def test_add_distributor(self):
# Setup
config = {'a': 'a', 'b': None}
# Test
added = self.distributor_manager.add_distributor(
self.group_id, 'mock-group-distributor', config)
# Verify
expected_config = {'a': 'a'}
# Returned Value
self.assertTrue(added is not None)
self.assertEqual(added['config'], expected_config)
self.assertEqual(added['distributor_type_id'],
'mock-group-distributor')
# Database
distributor = RepoGroupDistributor.get_collection().find_one(
{'id': added['id']})
self.assertTrue(distributor is not None)
self.assertEqual(distributor['config'], expected_config)
self.assertEqual(distributor['distributor_type_id'],
'mock-group-distributor')
# Plugin - Validate Config
self.assertEqual(
1, mock_plugins.MOCK_GROUP_DISTRIBUTOR.validate_config.call_count)
call_group = mock_plugins.MOCK_GROUP_DISTRIBUTOR.validate_config.call_args[
0][0]
call_config = mock_plugins.MOCK_GROUP_DISTRIBUTOR.validate_config.call_args[
0][1]
self.assertTrue(isinstance(call_group, RepositoryGroup))
self.assertEqual(call_group.id, self.group_id)
self.assertTrue(isinstance(call_config, PluginCallConfiguration))
self.assertTrue(call_config.repo_plugin_config, expected_config)
# Plugin - Distributor Added
self.assertEqual(
1,
mock_plugins.MOCK_GROUP_DISTRIBUTOR.distributor_added.call_count)
call_group = mock_plugins.MOCK_GROUP_DISTRIBUTOR.validate_config.call_args[
0][0]
call_config = mock_plugins.MOCK_GROUP_DISTRIBUTOR.validate_config.call_args[
0][1]
self.assertTrue(isinstance(call_group, RepositoryGroup))
self.assertTrue(isinstance(call_config, PluginCallConfiguration))
def remove_distributor(repo_group_id, distributor_id, force=False):
"""
Removes a distributor from a group.
@param repo_group_id: identifies the group
@type repo_group_id: str
@param distributor_id: identifies the distributor on the group
@type distributor_id: str
@param force: if true, the distributor will be removed from the database
regardless of whether or not the plugin's clean up method raises
an exception
@raise MissingResource: if there is no group or distributor with the
given ID
@raise PulpExecutionException: if the distributor raises an error on cleanup
"""
distributor_coll = RepoGroupDistributor.get_collection()
# Validation - calls will raise MissingResource
group = manager_factory.repo_group_query_manager().get_group(
repo_group_id)
distributor = RepoGroupDistributorManager.get_distributor(
repo_group_id, distributor_id)
# Call the distributor's cleanup method
distributor_type_id = distributor['distributor_type_id']
distributor_instance, plugin_config = plugin_api.get_group_distributor_by_id(
distributor_type_id)
call_config = PluginCallConfiguration(plugin_config,
distributor['config'])
transfer_group = common_utils.to_transfer_repo_group(group)
transfer_group.working_dir = common_utils.distributor_working_dir(
distributor_type_id, repo_group_id)
try:
distributor_instance.distributor_removed(transfer_group,
call_config)
except Exception:
_logger.exception(
'Exception cleaning up distributor [%s] on group [%s]' %
(distributor_id, repo_group_id))
if not force:
raise PulpExecutionException(), None, sys.exc_info()[2]
# Clean up the database
distributor_coll.remove(distributor, safe=True)
def test_delete(self):
# Setup
group_id = 'group'
distributor_id = 'created'
self.manager.create_repo_group(group_id)
self.distributor_manager.add_distributor(group_id, 'mock-group-distributor', {}, distributor_id=distributor_id)
# Test
status, body = self.delete('/v2/repo_groups/%s/distributors/%s/' % (group_id, distributor_id))
# Verify
self.assertEqual(200, status)
self.assertEqual(body, None)
found = RepoGroupDistributor.get_collection().find_one({'id' : distributor_id})
self.assertEqual(found, None)
def test_delete(self):
# Setup
group_id = "group"
distributor_id = "created"
self.manager.create_repo_group(group_id)
self.distributor_manager.add_distributor(group_id, "mock-group-distributor", {}, distributor_id=distributor_id)
# Test
status, body = self.delete("/v2/repo_groups/%s/distributors/%s/" % (group_id, distributor_id))
# Verify
self.assertEqual(200, status)
self.assertEqual(body, None)
found = RepoGroupDistributor.get_collection().find_one({"id": distributor_id})
self.assertEqual(found, None)
def test_delete(self):
# Setup
group_id = 'group'
distributor_id = 'created'
self.manager.create_repo_group(group_id)
self.distributor_manager.add_distributor(group_id, 'mock-group-distributor', {}, distributor_id=distributor_id)
# Test
status, body = self.delete('/v2/repo_groups/%s/distributors/%s/' % (group_id, distributor_id))
# Verify
self.assertEqual(200, status)
self.assertEqual(body, None)
found = RepoGroupDistributor.get_collection().find_one({'id' : distributor_id})
self.assertEqual(found, None)
def test_put(self):
# Setup
group_id = 'group-1'
distributor_id = 'dist-1'
self.manager.create_repo_group(group_id)
self.distributor_manager.add_distributor(group_id, 'mock-group-distributor', {'a' : 'A'}, distributor_id=distributor_id)
# Test
updated_config = {'b' : 'B'}
status, body = self.put('/v2/repo_groups/%s/distributors/%s/' % (group_id, distributor_id), {'distributor_config' : updated_config})
# Verify
self.assertEqual(200, status)
self.assertEqual(body['id'], distributor_id)
found = RepoGroupDistributor.get_collection().find_one({'id' : distributor_id})
self.assertEqual(found['config'], {'a' : 'A', 'b' : 'B'})
def test_add_distributor_replace_existing(self):
# Setup
self.distributor_manager.add_distributor(self.group_id, 'mock-group-distributor', {}, distributor_id='d1')
# Test
self.distributor_manager.add_distributor(self.group_id, 'mock-group-distributor-2', {}, distributor_id='d1')
# Verify
all_distributors = list(RepoGroupDistributor.get_collection().find())
self.assertEqual(1, len(all_distributors))
self.assertEqual(all_distributors[0]['distributor_type_id'], 'mock-group-distributor-2')
# Plugin Calls
self.assertEqual(1, mock_plugins.MOCK_GROUP_DISTRIBUTOR.distributor_added.call_count)
self.assertEqual(1, mock_plugins.MOCK_GROUP_DISTRIBUTOR_2.distributor_added.call_count)
self.assertEqual(1, mock_plugins.MOCK_GROUP_DISTRIBUTOR.distributor_removed.call_count)
def test_put(self):
# Setup
group_id = 'group-1'
distributor_id = 'dist-1'
self.manager.create_repo_group(group_id)
self.distributor_manager.add_distributor(group_id, 'mock-group-distributor', {'a' : 'A'}, distributor_id=distributor_id)
# Test
updated_config = {'b' : 'B'}
status, body = self.put('/v2/repo_groups/%s/distributors/%s/' % (group_id, distributor_id), {'distributor_config' : updated_config})
# Verify
self.assertEqual(200, status)
self.assertEqual(body['id'], distributor_id)
found = RepoGroupDistributor.get_collection().find_one({'id' : distributor_id})
self.assertEqual(found['config'], {'a' : 'A', 'b' : 'B'})
def test_post(self):
# Setup
group_id = 'group-1'
self.manager.create_repo_group(group_id)
# Test
data = {
'distributor_type_id' : 'mock-group-distributor',
'distributor_config' : {'a' : 'A'},
'distributor_id' : 'dist-1',
}
status, body = self.post('/v2/repo_groups/%s/distributors/' % group_id, data)
# Verify
self.assertEqual(201, status)
self.assertEqual(body['id'], data['distributor_id'])
found = RepoGroupDistributor.get_collection().find_one({'id' : data['distributor_id']})
self.assertTrue(found is not None)
def remove_distributor(repo_group_id, distributor_id, force=False):
"""
Removes a distributor from a group.
@param repo_group_id: identifies the group
@type repo_group_id: str
@param distributor_id: identifies the distributor on the group
@type distributor_id: str
@param force: if true, the distributor will be removed from the database
regardless of whether or not the plugin's clean up method raises
an exception
@raise MissingResource: if there is no group or distributor with the
given ID
@raise PulpExecutionException: if the distributor raises an error on cleanup
"""
distributor_coll = RepoGroupDistributor.get_collection()
# Validation - calls will raise MissingResource
group = manager_factory.repo_group_query_manager().get_group(repo_group_id)
distributor = RepoGroupDistributorManager.get_distributor(repo_group_id, distributor_id)
# Call the distributor's cleanup method
distributor_type_id = distributor['distributor_type_id']
distributor_instance, plugin_config = plugin_api.get_group_distributor_by_id(
distributor_type_id)
call_config = PluginCallConfiguration(plugin_config, distributor['config'])
transfer_group = common_utils.to_transfer_repo_group(group)
try:
distributor_instance.distributor_removed(transfer_group, call_config)
except Exception:
_logger.exception('Exception cleaning up distributor [%s] on group [%s]' % (
distributor_id, repo_group_id))
if not force:
raise PulpExecutionException(), None, sys.exc_info()[2]
# Clean up the database
distributor_coll.remove(distributor, safe=True)
def test_post(self):
# Setup
group_id = 'group-1'
self.manager.create_repo_group(group_id)
# Test
data = {
'distributor_type_id' : 'mock-group-distributor',
'distributor_config' : {'a' : 'A'},
'distributor_id' : 'dist-1',
}
status, body = self.post('/v2/repo_groups/%s/distributors/' % group_id, data)
# Verify
self.assertEqual(201, status)
self.assertEqual(body['id'], data['distributor_id'])
found = RepoGroupDistributor.get_collection().find_one({'id' : data['distributor_id']})
self.assertTrue(found is not None)
def test_post(self):
# Setup
group_id = "group-1"
self.manager.create_repo_group(group_id)
# Test
data = {
"distributor_type_id": "mock-group-distributor",
"distributor_config": {"a": "A"},
"distributor_id": "dist-1",
}
status, body = self.post("/v2/repo_groups/%s/distributors/" % group_id, data)
# Verify
self.assertEqual(201, status)
self.assertEqual(body["id"], data["distributor_id"])
found = RepoGroupDistributor.get_collection().find_one({"id": data["distributor_id"]})
self.assertTrue(found is not None)
def find_distributors(self, repo_group_id):
"""
Returns all distributors on the given repo group, returning an empty
list if none exist.
@param repo_group_id: identifies the repo group
@type repo_group_id: str
@return: list of SON representations of the group's distributors
@rtype: list
@raise MissingResource: if the group does not exist
"""
group = RepoGroup.get_collection().find_one({'id' : repo_group_id})
if group is None:
raise MissingResource(repo_group=repo_group_id)
spec = {'repo_group_id' : repo_group_id}
distributors = list(RepoGroupDistributor.get_collection().find(spec))
return distributors
def find_distributors(repo_group_id):
"""
Returns all distributors on the given repo group, returning an empty
list if none exist.
@param repo_group_id: identifies the repo group
@type repo_group_id: str
@return: list of SON representations of the group's distributors
@rtype: list
@raise MissingResource: if the group does not exist
"""
group = RepoGroup.get_collection().find_one({'id': repo_group_id})
if group is None:
raise MissingResource(repo_group=repo_group_id)
spec = {'repo_group_id': repo_group_id}
distributors = list(RepoGroupDistributor.get_collection().find(spec))
return distributors
def test_put(self):
# Setup
group_id = "group-1"
distributor_id = "dist-1"
self.manager.create_repo_group(group_id)
self.distributor_manager.add_distributor(
group_id, "mock-group-distributor", {"a": "A"}, distributor_id=distributor_id
)
# Test
updated_config = {"b": "B"}
status, body = self.put(
"/v2/repo_groups/%s/distributors/%s/" % (group_id, distributor_id), {"distributor_config": updated_config}
)
# Verify
self.assertEqual(200, status)
self.assertEqual(body["id"], distributor_id)
found = RepoGroupDistributor.get_collection().find_one({"id": distributor_id})
self.assertEqual(found["config"], {"a": "A", "b": "B"})
def test_add_distributor(self):
# Setup
config = {'a': 'a', 'b': None}
# Test
added = self.distributor_manager.add_distributor(self.group_id, 'mock-group-distributor',
config)
# Verify
expected_config = {'a': 'a'}
# Returned Value
self.assertTrue(added is not None)
self.assertEqual(added['config'], expected_config)
self.assertEqual(added['distributor_type_id'], 'mock-group-distributor')
# Database
distributor = RepoGroupDistributor.get_collection().find_one({'id': added['id']})
self.assertTrue(distributor is not None)
self.assertEqual(distributor['config'], expected_config)
self.assertEqual(distributor['distributor_type_id'], 'mock-group-distributor')
# Plugin - Validate Config
self.assertEqual(1, mock_plugins.MOCK_GROUP_DISTRIBUTOR.validate_config.call_count)
call_group = mock_plugins.MOCK_GROUP_DISTRIBUTOR.validate_config.call_args[0][0]
call_config = mock_plugins.MOCK_GROUP_DISTRIBUTOR.validate_config.call_args[0][1]
self.assertTrue(isinstance(call_group, RepositoryGroup))
self.assertEqual(call_group.id, self.group_id)
self.assertTrue(isinstance(call_config, PluginCallConfiguration))
self.assertTrue(call_config.repo_plugin_config, expected_config)
# Plugin - Distributor Added
self.assertEqual(1, mock_plugins.MOCK_GROUP_DISTRIBUTOR.distributor_added.call_count)
call_group = mock_plugins.MOCK_GROUP_DISTRIBUTOR.validate_config.call_args[0][0]
call_config = mock_plugins.MOCK_GROUP_DISTRIBUTOR.validate_config.call_args[0][1]
self.assertTrue(isinstance(call_group, RepositoryGroup))
self.assertTrue(isinstance(call_config, PluginCallConfiguration))
def clean(self):
super(RepoGroupPublishManagerTests, self).clean()
RepoGroup.get_collection().remove()
RepoGroupDistributor.get_collection().remove()
RepoGroupPublishResult.get_collection().remove()
def tearDown(self):
super(RepoGroupTests, self).tearDown()
self.manager = None
model.Repository.objects.delete()
RepoGroup.get_collection().remove()
RepoGroupDistributor.get_collection().remove()
def tearDown(self):
super(RepoGroupTests, self).tearDown()
self.manager = None
model.Repository.drop_collection()
RepoGroup.get_collection().remove(safe=True)
RepoGroupDistributor.get_collection().remove(safe=True)
def clean(self):
super(PublishActionTests, self).clean()
RepoGroup.get_collection().remove()
RepoGroupDistributor.get_collection().remove()
def tearDown(self):
super(RepoGroupTests, self).tearDown()
self.manager = None
model.Repository.objects.delete()
RepoGroup.get_collection().remove()
RepoGroupDistributor.get_collection().remove()
distributor_id,
force=False)
except MissingResource:
pass # if it didn't exist, no problem
# Invoke the appopriate plugin lifecycle method
try:
distributor_instance.distributor_added(transfer_group, call_config)
except Exception, e:
_logger.exception(
'Error initializing distributor [%s] for group [%s]' %
(distributor_type_id, repo_group_id))
raise PulpExecutionException(), None, sys.exc_info()[2]
# Finally, update the database
distributor = RepoGroupDistributor(distributor_id, distributor_type_id,
repo_group_id, clean_config)
distributor_coll.save(distributor)
return distributor
@staticmethod
def remove_distributor(repo_group_id, distributor_id, force=False):
"""
Removes a distributor from a group.
@param repo_group_id: identifies the group
@type repo_group_id: str
@param distributor_id: identifies the distributor on the group
@type distributor_id: str
def clean(self):
super(RepoGroupPublishConduitTests, self).clean()
RepoGroup.get_collection().remove()
RepoGroupDistributor.get_collection().remove()
transfer_group.working_dir = common_utils.group_distributor_working_dir(distributor_type_id, repo_group_id)
transfer_related_groups = related_groups(distributor_type_id, omit_group_id=repo_group_id)
# Request the plugin validate the configuration
try:
is_valid, message = distributor_instance.validate_config(transfer_group, call_config, transfer_related_groups)
if not is_valid:
raise PulpDataException(message)
except Exception, e:
_LOG.exception('Exception received from distributor [%s] while validating config' % distributor_type_id)
raise PulpDataException(e.args), None, sys.exc_info()[2]
# If we got this far, the merged_config is valid
distributor['config'] = merged_config
RepoGroupDistributor.get_collection().save(distributor, safe=True)
return distributor
def get_distributor_scratchpad(self, repo_group_id, distributor_id):
"""
Returns the contents of the distributor's scratchpad, raising an
error if the group or distributor does not exist.
This is different than the behavior of the repo scratchpad calls. Those
should be updated when we have time. jdob, June 13, 2012.
@return: value set for the distributor's scratchpad
@rtype: object
"""
# Request the plugin validate the configuration
try:
is_valid, message = distributor_instance.validate_config(transfer_group, call_config,
config_conduit)
if not is_valid:
raise PulpDataException(message)
except Exception, e:
msg = _('Exception received from distributor [%(d)s] while validating config')
msg = msg % {'d': distributor_type_id}
_logger.exception(msg)
raise PulpDataException(e.args), None, sys.exc_info()[2]
# If we got this far, the merged_config is valid
distributor['config'] = merged_config
RepoGroupDistributor.get_collection().save(distributor)
return distributor
def get_distributor_scratchpad(self, repo_group_id, distributor_id):
"""
Returns the contents of the distributor's scratchpad, raising an
error if the group or distributor does not exist.
This is different than the behavior of the repo scratchpad calls. Those
should be updated when we have time. jdob, June 13, 2012.
@return: value set for the distributor's scratchpad
@rtype: object
"""
def add_distributor(self, repo_group_id, distributor_type_id, group_plugin_config,
distributor_id=None):
"""
Adds an association from the given repository group to a distributor.
The assocation will be tracked through the distributor_id; each
distributor on a given group must have a unique ID. If this is not
specified, one will be generated. If a distributor already exists on the
group with a given ID, the existing one will be removed and replaced
with the newly configured one.
@param repo_group_id: identifies the repo group
@type repo_group_id: str
@param distributor_type_id: type of distributor being added; must reference
one of the installed group distributors
@type distributor_type_id: str
@param group_plugin_config: config to use for the distributor for this group alone
@type group_plugin_config: dict
@param distributor_id: if specified, the newly added distributor will be
referenced by this value and the group id; if omitted one will
be generated
@type distributor_id: str
@return: database representation of the added distributor
@rtype: dict
@raise MissingResource: if the group doesn't exist
@raise InvalidValue: if a distributor ID is provided and is not valid
@raise PulpDataException: if the plugin indicates the config is invalid
@raise PulpExecutionException: if the plugin raises an exception while
initializing the newly added distributor
"""
distributor_coll = RepoGroupDistributor.get_collection()
query_manager = manager_factory.repo_group_query_manager()
# Validation
group = query_manager.get_group(repo_group_id) # will raise MissingResource
if not plugin_api.is_valid_group_distributor(distributor_type_id):
raise InvalidValue(['distributor_type_id'])
# Determine the ID for the distributor on this repo
if distributor_id is None:
distributor_id = str(uuid.uuid4())
else:
# Validate if one was passed in
if not is_distributor_id_valid(distributor_id):
raise InvalidValue(['distributor_id'])
distributor_instance, plugin_config = plugin_api.get_group_distributor_by_id(distributor_type_id)
# Convention is that a value of None means unset. Remove any keys that
# are explicitly set to None so the plugin will default them.
clean_config = None
if group_plugin_config is not None:
clean_config = dict([(k, v) for k, v in group_plugin_config.items() if v is not None])
# Let the plugin validate the configuration
call_config = PluginCallConfiguration(plugin_config, clean_config)
transfer_group = common_utils.to_transfer_repo_group(group)
transfer_group.working_dir = common_utils.distributor_working_dir(distributor_type_id, repo_group_id)
# Load the related groups which is needed for the validation
transfer_related_groups = related_groups(distributor_type_id)
# Request the plugin validate the configuration
try:
is_valid, message = distributor_instance.validate_config(transfer_group, call_config, transfer_related_groups)
if not is_valid:
raise PulpDataException(message)
except Exception, e:
_LOG.exception('Exception received from distributor [%s] while validating config' % distributor_type_id)
raise PulpDataException(e.args), None, sys.exc_info()[2]
def add_distributor(repo_group_id,
distributor_type_id,
group_plugin_config,
distributor_id=None):
"""
Adds an association from the given repository group to a distributor.
The assocation will be tracked through the distributor_id; each
distributor on a given group must have a unique ID. If this is not
specified, one will be generated. If a distributor already exists on the
group with a given ID, the existing one will be removed and replaced
with the newly configured one.
@param repo_group_id: identifies the repo group
@type repo_group_id: str
@param distributor_type_id: type of distributor being added; must reference
one of the installed group distributors
@type distributor_type_id: str
@param group_plugin_config: config to use for the distributor for this group alone
@type group_plugin_config: dict
@param distributor_id: if specified, the newly added distributor will be
referenced by this value and the group id; if omitted one will
be generated
@type distributor_id: str
@return: database representation of the added distributor
@rtype: dict
@raise MissingResource: if the group doesn't exist
@raise InvalidValue: if a distributor ID is provided and is not valid
@raise PulpDataException: if the plugin indicates the config is invalid
@raise PulpExecutionException: if the plugin raises an exception while
initializing the newly added distributor
"""
distributor_coll = RepoGroupDistributor.get_collection()
query_manager = manager_factory.repo_group_query_manager()
# Validation
group = query_manager.get_group(
repo_group_id) # will raise MissingResource
if not plugin_api.is_valid_group_distributor(distributor_type_id):
raise InvalidValue(['distributor_type_id'])
# Determine the ID for the distributor on this repo
if distributor_id is None:
distributor_id = str(uuid.uuid4())
else:
# Validate if one was passed in
if not is_distributor_id_valid(distributor_id):
raise InvalidValue(['distributor_id'])
distributor_instance, plugin_config = plugin_api.get_group_distributor_by_id(
distributor_type_id)
# Convention is that a value of None means unset. Remove any keys that
# are explicitly set to None so the plugin will default them.
clean_config = None
if group_plugin_config is not None:
clean_config = dict([(k, v)
for k, v in group_plugin_config.items()
if v is not None])
# Let the plugin validate the configuration
call_config = PluginCallConfiguration(plugin_config, clean_config)
transfer_group = common_utils.to_transfer_repo_group(group)
config_conduit = RepoConfigConduit(distributor_type_id)
# Request the plugin validate the configuration
try:
is_valid, message = distributor_instance.validate_config(
transfer_group, call_config, config_conduit)
if not is_valid:
raise PulpDataException(message)
except Exception, e:
msg = _(
'Exception received from distributor [%(d)s] while validating config'
)
msg = msg % {'d': distributor_type_id}
_logger.exception(msg)
raise PulpDataException(e.args), None, sys.exc_info()[2]
def tearDown(self):
super(RepoGroupTests, self).tearDown()
self.manager = None
Repo.get_collection().remove(safe=True)
RepoGroup.get_collection().remove(safe=True)
RepoGroupDistributor.get_collection().remove(safe=True)
