def iter_parse(self, path: str, factory: PackageFactory,
transformer: PackageTransformer) -> Iterable[PackageMaker]:
for header in rpm.readHeaderListFromFile(path):
with factory.begin() as pkg:
fields = {
key: str(header[key], self.encoding)
if header[key] is not None else None
for key in [
'name', 'version', 'release', 'packager', 'group',
'summary'
]
}
pkg.set_name(fields['name'])
pkg.set_version(fields['version']) # XXX: handle release
if fields['version'] is None:
raise RuntimeError('version not defined')
pkg.set_rawversion(
nevra_construct(None, header['epoch'], fields['version'],
fields['release']))
if fields['packager']:
pkg.add_maintainers(extract_maintainers(fields['packager'])
) # XXX: may have multiple maintainers
pkg.add_categories(fields['group'])
pkg.set_summary(fields['summary'])
yield pkg
def iter_parse(self, path, factory):
for header in rpm.readHeaderListFromFile(path):
fields = {
key: str(header[key], self.encoding)
if header[key] is not None else None
for key in
['name', 'version', 'release', 'packager', 'group', 'summary']
}
pkg = factory.begin()
pkg.set_name(fields['name'])
pkg.set_version(fields['version']) # XXX: handle release
pkg.set_origversion(
nevra_construct(None, header['epoch'], fields['version'],
fields['release']))
if fields['packager']:
pkg.add_maintainers(extract_maintainers(
fields['packager'])) # XXX: may have multiple maintainers
pkg.add_categories(fields['group'])
pkg.set_summary(fields['summary'])
yield pkg
def iter_parse(self, path, factory):
root = xml.etree.ElementTree.parse(path)
for info in root.findall('./info'):
pkg = factory.begin()
nevra = nevra_parse(info.attrib['fn'])
pkg.set_name(nevra[0])
pkg.set_version(nevra[2])
pkg.set_origversion(
nevra_construct(None, nevra[1], nevra[2], nevra[3]))
# What we do here is we try to extract prerelease part
# and mark version as ignored with non-trivial ROSAREV,
# as it it likely a snapshot and trus cannot be trusted
if not nevra[3].isdecimal():
pkg.set_flags(PackageFlags.ignore)
match = re.search('\\b(a|alpha|b|beta|pre|rc)[0-9]+',
nevra[3].lower())
if match:
pkg.package.version += match.group(
0) # XXX: encapsulation violation
pkg.add_homepages(info.attrib['url'])
pkg.add_licenses(info.attrib['license'])
yield pkg
def iter_parse(self, path: str, factory: PackageFactory,
transformer: PackageTransformer) -> Iterable[PackageMaker]:
root = xml.etree.ElementTree.parse(path)
for info in root.findall('./info'):
with factory.begin() as pkg:
name, epoch, version, release, arch = nevra_parse(
info.attrib['fn'])
assert (arch == 'src')
pkg.add_name(name, NameType.SRCRPM_NAME)
pkg.set_version(version)
pkg.set_rawversion(
nevra_construct(None, epoch, version, release))
pkg.set_arch(arch)
# What we do here is we try to extract prerelease part
# and mark version as ignored with non-trivial ROSAREV,
# as it it likely a snapshot and trus cannot be trusted
if not version.isdecimal():
pkg.set_flags(PackageFlags.IGNORE)
match = re.search('\\b(a|alpha|b|beta|pre|rc)[0-9]+',
version.lower())
if match:
pkg.set_version(version + match.group(0))
pkg.add_homepages(info.attrib['url'])
pkg.add_licenses(info.attrib['license'])
yield pkg
def iter_parse(self, path: str,
factory: PackageFactory) -> Iterable[PackageMaker]:
with open(path) as listfile:
for line in listfile:
with factory.begin() as pkg:
filename = line.strip().split()[-1]
name, epoch, version, release, arch = nevra_parse(filename)
assert (arch == 'src')
pkg.add_name(name, NameType.SRCRPM_NAME)
fixed_version, flags = parse_rpm_version(
self._vertags, version, release)
pkg.set_version(fixed_version)
pkg.set_rawversion(
nevra_construct(None, epoch, version, release))
pkg.set_flags(flags)
pkg.set_arch(arch)
pkg.set_extra_field('nevr', filename.rsplit('.', 2)[0])
yield pkg
def iter_parse(self, path, factory, transformer):
normalize_version = VersionStripper().strip_right_greedy('+')
skipped_archs = {}
for entry in _iter_package_entries(path):
pkg = factory.begin()
arch = entry.find(
'{http://linux.duke.edu/metadata/common}arch').text
if self.allowed_archs and arch not in self.allowed_archs:
skipped_archs[arch] = skipped_archs.get(arch, 0) + 1
continue
pkg.set_name(
entry.find('{http://linux.duke.edu/metadata/common}name').text)
epoch = entry.find('{http://linux.duke.edu/metadata/common}version'
).attrib['epoch']
version = entry.find(
'{http://linux.duke.edu/metadata/common}version').attrib['ver']
release = entry.find(
'{http://linux.duke.edu/metadata/common}version').attrib['rel']
match = re.match('0\\.[0-9]+\\.((?:alpha|beta|rc)[0-9]+)\\.',
release)
if match:
# known pre-release schema: https://fedoraproject.org/wiki/Packaging:Versioning#Prerelease_versions
version += '-' + match.group(1)
elif release < '1':
# unknown pre-release schema: https://fedoraproject.org/wiki/Packaging:Versioning#Some_definitions
# most likely a snapshot
pkg.set_flags(PackageFlags.ignore)
pkg.set_version(version, normalize_version)
pkg.set_rawversion(nevra_construct(None, epoch, version, release))
pkg.set_summary(
entry.find(
'{http://linux.duke.edu/metadata/common}summary').text)
pkg.add_homepages(
entry.find('{http://linux.duke.edu/metadata/common}url').text)
pkg.add_categories(
entry.find('{http://linux.duke.edu/metadata/common}format/'
'{http://linux.duke.edu/metadata/rpm}group').text)
pkg.add_licenses(
entry.find('{http://linux.duke.edu/metadata/common}format/'
'{http://linux.duke.edu/metadata/rpm}license').text)
packager = entry.find(
'{http://linux.duke.edu/metadata/common}packager').text
if packager:
pkg.add_maintainers(extract_maintainers(packager))
yield pkg
for arch, numpackages in sorted(skipped_archs.items()):
factory.log(
'skipped {} packages(s) with disallowed architecture {}'.
format(numpackages, arch))
def iter_parse(self, path: str, factory: PackageFactory, transformer: PackageTransformer) -> Iterable[PackageMaker]:
normalize_version = VersionStripper().strip_right_greedy('+')
skipped_archs: Dict[str, int] = {}
for entry in iter_xml_elements_at_level(path, 1, ['{http://linux.duke.edu/metadata/common}package']):
with factory.begin() as pkg:
arch = safe_findtext(entry, '{http://linux.duke.edu/metadata/common}arch')
if self.allowed_archs and arch not in self.allowed_archs:
skipped_archs[arch] = skipped_archs.get(arch, 0) + 1
continue
name = safe_findtext(entry, '{http://linux.duke.edu/metadata/common}name')
if '%{' in name:
pkg.log('incorrect package name (unexpanded substitution)', severity=Logger.ERROR)
continue
pkg.add_name(name, NameType.GENERIC_PKGNAME)
version_elt = entry.find('{http://linux.duke.edu/metadata/common}version')
if version_elt is None:
raise RuntimeError('Cannot find <version> element')
epoch = version_elt.attrib['epoch']
version = version_elt.attrib['ver']
release = version_elt.attrib['rel']
match = re.match('0\\.[0-9]+\\.((?:alpha|beta|rc)[0-9]+)\\.', release)
if match:
# known pre-release schema: https://fedoraproject.org/wiki/Packaging:Versioning#Prerelease_versions
version += '-' + match.group(1)
elif release < '1':
# unknown pre-release schema: https://fedoraproject.org/wiki/Packaging:Versioning#Some_definitions
# most likely a snapshot
pkg.set_flags(PackageFlags.IGNORE)
pkg.set_version(version, normalize_version)
pkg.set_rawversion(nevra_construct(None, epoch, version, release))
pkg.set_summary(entry.findtext('{http://linux.duke.edu/metadata/common}summary'))
pkg.add_homepages(entry.findtext('{http://linux.duke.edu/metadata/common}url'))
pkg.add_categories(entry.findtext('{http://linux.duke.edu/metadata/common}format/'
'{http://linux.duke.edu/metadata/rpm}group'))
pkg.add_licenses(entry.findtext('{http://linux.duke.edu/metadata/common}format/'
'{http://linux.duke.edu/metadata/rpm}license'))
pkg.set_arch(entry.findtext('{http://linux.duke.edu/metadata/common}arch'))
packager = entry.findtext('{http://linux.duke.edu/metadata/common}packager')
if packager:
pkg.add_maintainers(extract_maintainers(packager))
yield pkg
for arch, numpackages in sorted(skipped_archs.items()):
factory.log('skipped {} packages(s) with disallowed architecture {}'.format(numpackages, arch))
def iter_parse(self, path: str,
factory: PackageFactory) -> Iterable[PackageMaker]:
for header in rpm.readHeaderListFromFile(path):
with factory.begin() as pkg:
assert (header.isSource()) # binary packages not supported yet
def sanitize_key(key: Any) -> Any:
return rpm.tagnames[key].lower(
) if key in rpm.tagnames else key
def sanitize_value(value: Any) -> Any:
return value.decode(self._encoding,
errors='ignore') if isinstance(
value, bytes) else value
pkgdata = {
sanitize_key(key): sanitize_value(value)
for key, value in dict(header).items()
}
# For Sisyphus (but not PCLinuxOS), there is pkgdata[1000011], which contains
# a different name (for instance, for GLEW there is libGLEW-devel)
# May use is for some other purposes
pkg.add_name(pkgdata['name'], NameType.SRCRPM_NAME)
if pkgdata['version'] is None:
raise RuntimeError('version not defined')
version, flags = parse_rpm_version(self._vertags,
pkgdata['version'],
pkgdata['release'])
pkg.set_version(version)
pkg.set_rawversion(
nevra_construct(None, header['epoch'], pkgdata['version'],
pkgdata['release']))
pkg.set_flags(flags)
if 'packager' in pkgdata:
pkg.add_maintainers(
extract_maintainers(pkgdata['packager'])
) # XXX: may have multiple maintainers
pkg.add_categories(pkgdata['group'])
try:
# e.g. PCLinuxOS summaries may contain surrogate garbage
pkgdata['summary'].encode('utf-8')
pkg.set_summary(pkgdata['summary'])
except:
pkg.log('incorrect UTF in summary', Logger.ERROR)
pkg.set_arch(pkgdata['arch'])
yield pkg
def iter_parse(self, path: str, factory: PackageFactory,
transformer: PackageTransformer) -> Iterable[PackageMaker]:
normalize_version = VersionStripper().strip_right_greedy('+')
skipped_archs: Dict[str, int] = Counter()
wanted_columns = [
'name', 'version', 'arch', 'epoch', 'release', 'summary', 'url',
'rpm_group', 'rpm_license', 'arch', 'rpm_packager', 'rpm_sourcerpm'
]
for pkgdata in iter_sqlite(path, 'packages', wanted_columns):
is_src = pkgdata['arch'] == 'src'
if (is_src and not self._src) or (not is_src and not self._binary):
skipped_archs[pkgdata['arch']] += 1
continue
with factory.begin() as pkg:
if is_src:
pkg.add_name(pkgdata['name'], NameType.SRCRPM_NAME)
else:
pkg.add_name(pkgdata['name'], NameType.BINRPM_NAME)
pkg.add_name(
nevra_parse(pkgdata['rpm_sourcerpm'])[0],
NameType.BINRPM_SRCNAME)
version = pkgdata['version']
match = re.match('0\\.[0-9]+\\.((?:alpha|beta|rc)[0-9]+)\\.',
pkgdata['release'])
if match:
# known pre-release schema: https://fedoraproject.org/wiki/Packaging:Versioning#Prerelease_versions
version += '-' + match.group(1)
elif pkgdata['release'] < '1':
# unknown pre-release schema: https://fedoraproject.org/wiki/Packaging:Versioning#Some_definitions
# most likely a snapshot
pkg.set_flags(PackageFlags.IGNORE)
pkg.set_version(version, normalize_version)
pkg.set_rawversion(
nevra_construct(None, pkgdata['epoch'], pkgdata['version'],
pkgdata['release']))
pkg.set_arch(pkgdata['arch'])
pkg.set_summary(pkgdata['summary'])
pkg.add_homepages(pkgdata['url'])
pkg.add_categories(pkgdata['rpm_group'])
pkg.add_licenses(pkgdata['rpm_license'])
pkg.set_arch(pkgdata['arch'])
pkg.add_maintainers(
extract_maintainers(pkgdata['rpm_packager']))
yield pkg
def iter_parse(self, path: str, factory: PackageFactory) -> Iterable[PackageMaker]:
for item in lxml.html.parse(path).getroot().xpath('.//div[@id="rpms_list"]/ul/li/a'):
nevra = nevra_parse(item.text)
pkg = factory.begin()
pkg.add_name(nevra[0], NameType.UNSUPPORTED)
pkg.set_version(nevra[2])
pkg.set_rawversion(nevra_construct(None, nevra[1], nevra[2], nevra[3]))
yield pkg
def test_epoch_mode_provide(self):
self.assertEqual(
nevra_construct('foo',
None,
'1.2.3',
'fc34.git20181111',
'src',
epoch_mode=EpochMode.PROVIDE),
'foo-0:1.2.3-fc34.git20181111.src')
self.assertEqual(
nevra_construct('foo',
0,
'1.2.3',
'fc34.git20181111',
'src',
epoch_mode=EpochMode.PROVIDE),
'foo-0:1.2.3-fc34.git20181111.src')
self.assertEqual(
nevra_construct('foo',
'',
'1.2.3',
'fc34.git20181111',
'src',
epoch_mode=EpochMode.PROVIDE),
'foo-0:1.2.3-fc34.git20181111.src')
self.assertEqual(
nevra_construct('foo',
'0',
'1.2.3',
'fc34.git20181111',
'src',
epoch_mode=EpochMode.PROVIDE),
'foo-0:1.2.3-fc34.git20181111.src')
self.assertEqual(
nevra_construct('foo',
'1',
'1.2.3',
'fc34.git20181111',
'src',
epoch_mode=EpochMode.PROVIDE),
'foo-1:1.2.3-fc34.git20181111.src')
def test_epoch_mode_trim(self):
self.assertEqual(
nevra_construct('foo',
None,
'1.2.3',
'fc34.git20181111',
'src',
epoch_mode=EpochMode.TRIM),
'foo-1.2.3-fc34.git20181111.src')
self.assertEqual(
nevra_construct('foo',
0,
'1.2.3',
'fc34.git20181111',
'src',
epoch_mode=EpochMode.TRIM),
'foo-1.2.3-fc34.git20181111.src')
self.assertEqual(
nevra_construct('foo',
'',
'1.2.3',
'fc34.git20181111',
'src',
epoch_mode=EpochMode.TRIM),
'foo-1.2.3-fc34.git20181111.src')
self.assertEqual(
nevra_construct('foo',
'0',
'1.2.3',
'fc34.git20181111',
'src',
epoch_mode=EpochMode.TRIM),
'foo-1.2.3-fc34.git20181111.src')
self.assertEqual(
nevra_construct('foo',
'1',
'1.2.3',
'fc34.git20181111',
'src',
epoch_mode=EpochMode.TRIM),
'foo-1:1.2.3-fc34.git20181111.src')
def iter_parse(self, path, factory):
for item in lxml.html.parse(path).getroot().xpath(
'.//div[@id="rpms_list"]/ul/li/a'):
nevra = nevra_parse(item.text)
pkg = factory.begin()
pkg.set_name(nevra[0])
pkg.set_version(nevra[2])
pkg.set_origversion(
nevra_construct(None, nevra[1], nevra[2], nevra[3]))
yield pkg
def iter_parse(self, path, factory):
with open(path) as listfile:
for line in listfile:
pkg = factory.begin()
filename = line.strip().split()[-1]
nevra = nevra_parse(filename)
pkg.set_name(nevra[0])
pkg.set_version(nevra[2])
pkg.set_origversion(nevra_construct(None, nevra[1], nevra[2], nevra[3]))
pkg.set_extra_field('nevr', filename.rsplit('.', 2)[0])
yield pkg
def iter_parse(
self, path: str, factory: PackageFactory,
transformer: PackageTransformer
) -> Generator[PackageMaker, None, None]:
for item in lxml.html.parse(path).getroot().xpath(
'.//div[@id="rpms_list"]/ul/li/a'):
nevra = nevra_parse(item.text)
pkg = factory.begin()
pkg.set_name(nevra[0])
pkg.set_version(nevra[2])
pkg.set_rawversion(
nevra_construct(None, nevra[1], nevra[2], nevra[3]))
yield pkg
def iter_parse(self, path: str, factory: PackageFactory, transformer: PackageTransformer) -> Generator[PackageMaker, None, None]:
with open(path) as listfile:
for line in listfile:
pkg = factory.begin()
filename = line.strip().split()[-1]
nevra = nevra_parse(filename)
pkg.set_name(nevra[0])
pkg.set_version(nevra[2])
pkg.set_rawversion(nevra_construct(None, nevra[1], nevra[2], nevra[3]))
pkg.set_extra_field('nevr', filename.rsplit('.', 2)[0])
yield pkg
def test_partial(self) -> None:
self.assertEqual(nevra_construct(None, '1', '1.2.3', 'fc34.git20181111', 'src'), '1:1.2.3-fc34.git20181111.src')
self.assertEqual(nevra_construct('foo', None, '1.2.3', 'fc34.git20181111', 'src'), 'foo-1.2.3-fc34.git20181111.src')
with self.assertRaises(RuntimeError):
nevra_construct('foo', '1', None, 'fc34.git20181111', 'src') # type: ignore
self.assertEqual(nevra_construct('foo', '1', '1.2.3', None, 'src'), 'foo-1:1.2.3.src')
self.assertEqual(nevra_construct('foo', '1', '1.2.3', 'fc34.git20181111', None), 'foo-1:1.2.3-fc34.git20181111')
def test_partial(self):
assert nevra_construct(None, '1', '1.2.3', 'fc34.git20181111', 'src') == '1:1.2.3-fc34.git20181111.src'
assert nevra_construct('foo', None, '1.2.3', 'fc34.git20181111', 'src') == 'foo-1.2.3-fc34.git20181111.src'
with pytest.raises(RuntimeError):
nevra_construct('foo', '1', None, 'fc34.git20181111', 'src') # type: ignore
assert nevra_construct('foo', '1', '1.2.3', None, 'src') == 'foo-1:1.2.3.src'
assert nevra_construct('foo', '1', '1.2.3', 'fc34.git20181111', None) == 'foo-1:1.2.3-fc34.git20181111'
def iter_parse(self, path: str, factory: PackageFactory, transformer: PackageTransformer) -> Iterable[PackageMaker]:
with open(path) as listfile:
for line in listfile:
pkg = factory.begin()
filename = line.strip().split()[-1]
name, epoch, version, release, arch = nevra_parse(filename)
pkg.set_name(name)
pkg.set_version(version)
pkg.set_rawversion(nevra_construct(None, epoch, version, release))
pkg.set_arch(arch)
pkg.set_extra_field('nevr', filename.rsplit('.', 2)[0])
yield pkg
def iter_parse(self, path: str, factory: PackageFactory,
transformer: PackageTransformer) -> Iterable[PackageMaker]:
for header in rpm.readHeaderListFromFile(path):
with factory.begin() as pkg:
assert (header.isSource()) # binary packages not supported yet
pkgdata = {
rpm.tagnames[key].lower() if key in rpm.tagnames else key:
value.decode(self.encoding, errors='ignore') if isinstance(
value, bytes) else value
for key, value in dict(header).items()
}
# For Sisyphus (but not PCLinuxOS), there is pkgdata[1000011], which contains
# a different name (for instance, for GLEW there is libGLEW-devel)
# May use is for some other purposes
pkg.add_name(pkgdata['name'], NameType.SRCRPM_NAME)
pkg.set_version(pkgdata['version']) # XXX: handle release
if pkgdata['version'] is None:
raise RuntimeError('version not defined')
pkg.set_rawversion(
nevra_construct(None, header['epoch'], pkgdata['version'],
pkgdata['release']))
if 'packager' in pkgdata:
pkg.add_maintainers(
extract_maintainers(pkgdata['packager'])
) # XXX: may have multiple maintainers
pkg.add_categories(pkgdata['group'])
pkg.set_summary(pkgdata['summary'])
pkg.set_arch(pkgdata['arch'])
yield pkg
def iter_parse(self, path: str,
factory: PackageFactory) -> Iterable[PackageMaker]:
for packagedata in iter_json_list(path, ('packages', None)):
with factory.begin() as pkg:
pkg.add_name(packagedata['name'], NameType.SRCRPM_NAME)
pkg.add_binnames(binary['name']
for binary in packagedata['binaries'])
version, flags = parse_rpm_version(self._vertags,
packagedata['version'],
packagedata['release'])
pkg.set_version(version)
pkg.set_rawversion(
nevra_construct(None, packagedata['epoch'],
packagedata['version'],
packagedata['release']))
pkg.set_flags(flags)
pkg.add_categories(packagedata['category'])
pkg.set_summary(packagedata['summary'])
pkg.add_licenses(packagedata['license'])
pkg.add_maintainers(packagedata['packager'])
pkg.add_links(LinkType.UPSTREAM_HOMEPAGE, packagedata['url'])
pkg.add_links(LinkType.PACKAGE_HOMEPAGE,
packagedata['homepage'])
pkg.add_links(LinkType.PACKAGE_RECIPE, packagedata['recipe'])
pkg.add_links(LinkType.PACKAGE_RECIPE_RAW,
packagedata['recipe_raw'])
pkg.add_links(LinkType.PACKAGE_ISSUE_TRACKER,
packagedata['bugzilla'])
# TODO: parse CPE data when available
if 'CPE' in packagedata:
pass
yield pkg
def test_basic(self):
self.assertEqual(
nevra_construct('foo', '1', '1.2.3', 'fc34.git20181111', 'src'),
'foo-1:1.2.3-fc34.git20181111.src')
def test_epoch_mode_preserve(self):
assert nevra_construct('foo', None, '1.2.3', 'fc34.git20181111', 'src', epoch_mode=EpochMode.PRESERVE) == 'foo-1.2.3-fc34.git20181111.src'
assert nevra_construct('foo', 0, '1.2.3', 'fc34.git20181111', 'src', epoch_mode=EpochMode.PRESERVE) == 'foo-0:1.2.3-fc34.git20181111.src'
assert nevra_construct('foo', '', '1.2.3', 'fc34.git20181111', 'src', epoch_mode=EpochMode.PRESERVE) == 'foo-1.2.3-fc34.git20181111.src'
assert nevra_construct('foo', '0', '1.2.3', 'fc34.git20181111', 'src', epoch_mode=EpochMode.PRESERVE) == 'foo-0:1.2.3-fc34.git20181111.src'
assert nevra_construct('foo', '1', '1.2.3', 'fc34.git20181111', 'src', epoch_mode=EpochMode.PRESERVE) == 'foo-1:1.2.3-fc34.git20181111.src'
def test_basic(self):
assert nevra_construct('foo', '1', '1.2.3', 'fc34.git20181111', 'src') == 'foo-1:1.2.3-fc34.git20181111.src'
def iter_parse(self, path: str, factory: PackageFactory,
transformer: PackageTransformer) -> Iterable[PackageMaker]:
normalize_version = VersionStripper().strip_right_greedy('+')
skipped_archs: Dict[str, int] = Counter()
if self._arch_from_filename:
factory.log('mitigation for incorrect <arch></arch> enabled',
severity=Logger.WARNING)
for entry in iter_xml_elements_at_level(
path, 1, ['{http://linux.duke.edu/metadata/common}package']):
if self._arch_from_filename:
# XXX: openmandriva 3 hack, to be removed when it EoLs
location_elt = entry.find(
'{http://linux.duke.edu/metadata/common}location')
if location_elt is None:
raise RuntimeError('Cannot find <location> element')
arch = nevra_parse(safe_getattr(location_elt, 'href'))[4]
else:
arch = safe_findtext(
entry, '{http://linux.duke.edu/metadata/common}arch')
is_src = arch == 'src'
if (is_src and not self._src) or (not is_src and not self._binary):
skipped_archs[arch] += 1
continue
with factory.begin() as pkg:
name = safe_findtext(
entry, '{http://linux.duke.edu/metadata/common}name')
if '%{' in name:
pkg.log('incorrect package name (unexpanded substitution)',
severity=Logger.ERROR)
continue
if is_src:
pkg.add_name(name, NameType.SRCRPM_NAME)
else:
pkg.add_name(name, NameType.BINRPM_NAME)
sourcerpm = safe_findtext(
entry, '{http://linux.duke.edu/metadata/common}format/'
'{http://linux.duke.edu/metadata/rpm}sourcerpm')
pkg.add_name(
nevra_parse(sourcerpm)[0], NameType.BINRPM_SRCNAME)
version_elt = entry.find(
'{http://linux.duke.edu/metadata/common}version')
if version_elt is None:
raise RuntimeError('Cannot find <version> element')
epoch = version_elt.attrib['epoch']
version = version_elt.attrib['ver']
release = version_elt.attrib['rel']
fixed_version = version
match = re.match('0\\.[0-9]+\\.((?:alpha|beta|rc)[0-9]+)\\.',
release)
if match:
# known pre-release schema: https://fedoraproject.org/wiki/Packaging:Versioning#Prerelease_versions
fixed_version += '-' + match.group(1)
elif release < '1':
# unknown pre-release schema: https://fedoraproject.org/wiki/Packaging:Versioning#Some_definitions
# most likely a snapshot
pkg.set_flags(PackageFlags.IGNORE)
pkg.set_version(fixed_version, normalize_version)
pkg.set_rawversion(
nevra_construct(None, epoch, version, release))
pkg.set_summary(
entry.findtext(
'{http://linux.duke.edu/metadata/common}summary'))
pkg.add_homepages(
entry.findtext(
'{http://linux.duke.edu/metadata/common}url'))
pkg.add_categories(
entry.findtext(
'{http://linux.duke.edu/metadata/common}format/'
'{http://linux.duke.edu/metadata/rpm}group'))
pkg.add_licenses(
entry.findtext(
'{http://linux.duke.edu/metadata/common}format/'
'{http://linux.duke.edu/metadata/rpm}license'))
pkg.set_arch(
entry.findtext(
'{http://linux.duke.edu/metadata/common}arch'))
packager = entry.findtext(
'{http://linux.duke.edu/metadata/common}packager')
if packager:
pkg.add_maintainers(extract_maintainers(packager))
yield pkg
for arch, numpackages in sorted(skipped_archs.items()):
factory.log(
'skipped {} packages(s) with disallowed architecture {}'.
format(numpackages, arch))
