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