def test_get_missing_rpms_and_units(self):
# 2 Existing RPMs, one is missing
# Expecting return of the one missing rpm
# Fake out the verify_exists
def side_effect(arg, checksum=None, checksum_type="sha256", size=None, verify_options={}):
if arg == "rel_path_b":
return False
return True
util.verify_exists = mock.Mock()
util.verify_exists.side_effect = side_effect
rpm_a = self.get_simple_rpm("test_value_a")
rpm_b = self.get_simple_rpm("test_value_b")
rpm_lookup_key_a = importer_rpm.form_lookup_key(rpm_a)
rpm_lookup_key_b = importer_rpm.form_lookup_key(rpm_b)
available_rpms = {}
available_rpms[rpm_lookup_key_a] = rpm_a
available_rpms[rpm_lookup_key_b] = rpm_b
unit_a = Unit(TYPE_ID_RPM, importer_rpm.form_rpm_unit_key(rpm_a), "test_metadata", "rel_path_a")
unit_b = Unit(TYPE_ID_RPM, importer_rpm.form_rpm_unit_key(rpm_b), "test_metadata", "rel_path_b")
existing_units = {}
existing_units[rpm_lookup_key_a] = unit_a
existing_units[rpm_lookup_key_b] = unit_b
missing_rpms, missing_units = importer_rpm.get_missing_rpms_and_units(available_rpms,
existing_units)
self.assertEquals(len(missing_rpms), 1)
self.assertEquals(len(missing_units), 1)
self.assertTrue(rpm_lookup_key_b in missing_rpms)
self.assertTrue(rpm_lookup_key_b in missing_units)
self.assertEquals(missing_rpms[rpm_lookup_key_b], rpm_b)
def test_get_available_rpms(self):
rpm = {}
for k in UNIT_KEY_RPM:
rpm[k] = "test_value"
available_rpms = importer_rpm.get_available_rpms([rpm])
lookup_key = importer_rpm.form_lookup_key(rpm)
self.assertEqual(available_rpms[lookup_key], rpm)
def test_get_new_rpms_and_units(self):
# 1 Existing RPM
# 2 RPMs in available
# Expected 1 New RPM
rpm_a = self.get_simple_rpm("test_value_a")
rpm_b = self.get_simple_rpm("test_value_b")
rpm_lookup_key_a = importer_rpm.form_lookup_key(rpm_a)
rpm_lookup_key_b = importer_rpm.form_lookup_key(rpm_b)
available_rpms = {}
available_rpms[rpm_lookup_key_a] = rpm_a
available_rpms[rpm_lookup_key_b] = rpm_b
unit_a = Unit(TYPE_ID_RPM, importer_rpm.form_rpm_unit_key(rpm_a), "test_metadata", "rel_path")
existing_units = {}
existing_units[rpm_lookup_key_a] = unit_a
sync_conduit = importer_mocks.get_sync_conduit(pkg_dir=self.pkg_dir)
new_rpms, new_units = importer_rpm.get_new_rpms_and_units(available_rpms,
existing_units, sync_conduit)
self.assertEquals(len(new_rpms), 1)
self.assertEquals(len(new_units), 1)
self.assertTrue(rpm_lookup_key_b in new_rpms)
self.assertTrue(rpm_lookup_key_b in new_units)
self.assertEquals(new_rpms[rpm_lookup_key_b], rpm_b)
#
# Repeat test but now nothing is new
#
unit_b = Unit(TYPE_ID_RPM, importer_rpm.form_rpm_unit_key(rpm_b), "test_metadata", "rel_path_b")
existing_units = {}
existing_units[rpm_lookup_key_a] = unit_a
existing_units[rpm_lookup_key_b] = unit_b
new_rpms, new_units = importer_rpm.get_new_rpms_and_units(available_rpms,
existing_units, sync_conduit)
self.assertEquals(len(new_rpms), 0)
self.assertEquals(len(new_units), 0)
#
# Repeat test but now both rpms in available are new
#
existing_units = {}
new_rpms, new_units = importer_rpm.get_new_rpms_and_units(available_rpms,
existing_units, sync_conduit)
self.assertEquals(len(new_rpms), 2)
self.assertEquals(len(new_units), 2)
self.assertTrue(rpm_lookup_key_a in new_rpms)
self.assertTrue(rpm_lookup_key_b in new_rpms)
def test_get_orphaned_units(self):
# Create A & B, Orphan B
unit_key_a = {}
for k in UNIT_KEY_RPM:
unit_key_a[k] = "test_value"
unit_key_b = {}
for k in UNIT_KEY_RPM:
unit_key_b[k] = "test_value_b"
unit_a = Unit(TYPE_ID_RPM, unit_key_a, "test_metadata", "test_rel_path")
unit_b = Unit(TYPE_ID_RPM, unit_key_b, "test_metadata", "test_rel_path")
existing_units = {
importer_rpm.form_lookup_key(unit_key_a):unit_a,
importer_rpm.form_lookup_key(unit_key_b):unit_b
}
available_rpms = {}
available_rpms[importer_rpm.form_lookup_key(unit_key_a)] = unit_key_a
orphaned_units = importer_rpm.get_orphaned_units(available_rpms, existing_units)
expected_orphan_key = importer_rpm.form_lookup_key(unit_key_b)
self.assertEquals(len(orphaned_units), 1)
self.assertTrue(expected_orphan_key in orphaned_units)
def test_get_existing_units(self):
unit_key = {}
for k in UNIT_KEY_RPM:
unit_key[k] = "test_value"
existing_units = [Unit(TYPE_ID_RPM, unit_key, "test_metadata", os.path.join(self.pkg_dir, "test_rel_path"))]
sync_conduit = importer_mocks.get_sync_conduit(existing_units=existing_units, pkg_dir=self.pkg_dir)
actual_existing_units = importer_rpm.get_existing_units(sync_conduit)
self.assertEquals(len(actual_existing_units), 1)
self.assertEquals(len(existing_units), len(actual_existing_units))
lookup_key = importer_rpm.form_lookup_key(unit_key)
self.assertEqual(existing_units[0], actual_existing_units[lookup_key])
def _import_errata_unit_rpms(self, source_repo, erratum_unit, import_conduit, config, existing_rpm_units=None, blacklist_units=None):
"""
lookup rpms units associated with an erratum; resolve deps and import rpm units
@param source_repo: metadata describing the repository containing the
units to import
@type source_repo: L{pulp.plugins.data.Repository}
@param erratum_unit: erratum unit to lookup child units for to import
into
@type erratum_unit: L{pulp.plugins.data.Unit}
@param import_conduit: provides access to relevant Pulp functionality
@type import_conduit: L{pulp.plugins.conduits.unit_import.ImportUnitConduit}
@param config: plugin configuration
@type config: L{pulp.plugins.plugins.config.PluginCallConfiguration}
@param existing_rpm_units: optional list of pre-filtered units to import
@type existing_rpm_units: list of L{pulp.plugins.data.Unit}
"""
pkglist = erratum_unit.metadata['pkglist']
existing_rpm_units = existing_rpm_units or {}
for pkg in pkglist:
for pinfo in pkg['packages']:
if not pinfo.has_key('sum'):
_LOG.debug("Missing checksum info on package <%s> for linking a rpm to an erratum." % (pinfo))
continue
pinfo['checksumtype'], pinfo['checksum'] = pinfo['sum']
rpm_key = form_lookup_key(pinfo)
if rpm_key in existing_rpm_units.keys():
if rpm_key in blacklist_units:
_LOG.debug("package %s blacklisted; skip import" % pinfo)
continue
rpm_unit = existing_rpm_units[rpm_key]
import_conduit.associate_unit(rpm_unit)
# process any deps
self._import_unit_dependencies(source_repo, [rpm_unit], import_conduit, config, existing_rpm_units=existing_rpm_units)
_LOG.debug("Found matching rpm unit %s" % rpm_unit)
else:
_LOG.debug("rpm unit %s not found; skipping" % pinfo)
def link_errata_rpm_units(sync_conduit, new_errata_units):
"""
Links errata to corresponding rpms
@param sync_conduit
@type sync_conduit pulp.server.content.conduits.repo_sync.RepoSyncConduit
@param new_errata_units: errata units to link
@type new_errata_units: {}
@return a link_report dictionry.
@rtype {}
"""
link_report = {}
# link errata and rpm units
criteria = UnitAssociationCriteria(type_ids=[importer_rpm.RPM_TYPE_ID, importer_rpm.SRPM_TYPE_ID])
existing_rpms = importer_rpm.get_existing_units(sync_conduit, criteria=criteria)
link_report['linked_units'] = []
link_report['missing_rpms'] = []
for u in new_errata_units.values():
pkglist = u.metadata['pkglist']
for pkg in pkglist:
for pinfo in pkg['packages']:
if not pinfo.has_key('sum'):
_LOG.debug("Missing checksum info on package <%s> for linking a rpm to an erratum." % (pinfo))
continue
pinfo['checksumtype'], pinfo['checksum'] = pinfo['sum']
rpm_key = importer_rpm.form_lookup_key(pinfo)
if rpm_key in existing_rpms.keys():
rpm_unit = existing_rpms[rpm_key]
_LOG.info("Found matching rpm unit %s" % rpm_unit)
sync_conduit.link_unit(u, rpm_unit, bidirectional=True)
link_report['linked_units'].append(rpm_unit)
else:
link_report['missing_rpms'].append(pinfo)
_LOG.info("rpm unit %s not found; skipping" % pinfo)
return link_report
