pkgset: Update Koji source to create multiple pkgsets
With this patch, there should be a separate package set for each tag that is consumed. Generally each module will create a separate package set, with the exception of -devel modules that will be in the same set as their non-devel version. Variants no longer need to keep their own package set objects. Instead they now include a set of package set names that should be used for the variant. This can replace the whitelist mechanism of deps gather method. JIRA: COMPOSE-3620 Signed-off-by: Lubomír Sedlář <lsedlar@redhat.com>
This commit is contained in:
Lubomír Sedlář
parent
eed2aa2753
commit
a446593698
@ -96,7 +96,8 @@ def write_pungi_config(compose, arch, variant, packages, groups, filter_packages
|
||||
|
||||
repos = {}
|
||||
for i, pkgset in enumerate(package_sets or []):
|
||||
repos["pungi-repo-%d" % i] = pkgset.paths[arch]
|
||||
if not variant.pkgsets or pkgset.name in variant.pkgsets:
|
||||
repos["pungi-repo-%d" % i] = pkgset.paths[arch]
|
||||
if compose.has_comps:
|
||||
repos["comps-repo"] = compose.paths.work.comps_repo(arch=arch, variant=variant)
|
||||
if variant.type == "optional":
|
||||
@ -118,41 +119,12 @@ def write_pungi_config(compose, arch, variant, packages, groups, filter_packages
|
||||
'No packages included in %s.%s (no comps groups, no input packages, no prepopulate)'
|
||||
% (variant.uid, arch))
|
||||
|
||||
package_whitelist = set()
|
||||
if variant.pkgset:
|
||||
multilib = get_arch_variant_data(compose.conf, 'multilib', arch, variant)
|
||||
for i in get_valid_arches(arch, multilib=multilib, add_noarch=True, add_src=True):
|
||||
for rpm_obj in variant.pkgset.rpms_by_arch.get(i, []):
|
||||
package_whitelist.add(
|
||||
'{0.name}-{1}:{0.version}-{0.release}'.format(rpm_obj, rpm_obj.epoch or 0))
|
||||
|
||||
# If the variant contains just modules or just comps groups, the pkgset
|
||||
# is sufficient and contains all necessary packages.
|
||||
|
||||
has_additional_pkgs = get_arch_variant_data(
|
||||
compose.conf, "additional_packages", arch, variant
|
||||
)
|
||||
has_traditional_content = variant.groups or has_additional_pkgs
|
||||
if has_traditional_content and variant.modules is not None and package_sets:
|
||||
# The variant is hybrid. The modular builds are already available.
|
||||
# We need to add packages from base tag, but only if they are not
|
||||
# already on the whitelist.
|
||||
package_names = set(p.rsplit('-', 2)[0] for p in package_whitelist)
|
||||
for i in get_valid_arches(arch, multilib=multilib, add_noarch=True, add_src=True):
|
||||
for pkgset in package_sets:
|
||||
for rpm_obj in pkgset[arch].rpms_by_arch.get(i, []):
|
||||
if rpm_obj.name in package_names:
|
||||
# We already have a package with this name in the whitelist, skip it.
|
||||
continue
|
||||
package_whitelist.add(
|
||||
'{0.name}-{1}:{0.version}-{0.release}'.format(rpm_obj, rpm_obj.epoch or 0))
|
||||
|
||||
pungi_wrapper.write_kickstart(
|
||||
ks_path=pungi_cfg, repos=repos, groups=groups, packages=packages_str,
|
||||
exclude_packages=filter_packages_str,
|
||||
lookaside_repos=lookaside_repos, fulltree_excludes=fulltree_excludes,
|
||||
multilib_whitelist=multilib_whitelist, multilib_blacklist=multilib_blacklist,
|
||||
prepopulate=prepopulate, package_whitelist=package_whitelist)
|
||||
prepopulate=prepopulate)
|
||||
|
||||
|
||||
def resolve_deps(compose, arch, variant, source_name=None):
|
||||
|
||||
@ -28,5 +28,4 @@ class PkgsetPhase(PhaseBase):
|
||||
PkgsetSourceContainer.register_module(sources)
|
||||
container = PkgsetSourceContainer()
|
||||
SourceClass = container[pkgset_source]
|
||||
package_sets, self.path_prefix = SourceClass(self.compose)()
|
||||
self.package_sets = [package_sets]
|
||||
self.package_sets, self.path_prefix = SourceClass(self.compose)()
|
||||
|
||||
@ -111,17 +111,27 @@ def run_create_global_repo(compose, cmd, logfile):
|
||||
compose.log_info("[DONE ] %s", msg)
|
||||
|
||||
|
||||
def create_arch_repos(compose, path_prefix, paths, pkgset):
|
||||
def create_arch_repos(compose, path_prefix, paths, pkgset, mmds):
|
||||
run_in_threads(
|
||||
_create_arch_repo,
|
||||
[(compose, arch, path_prefix, paths, pkgset) for arch in compose.get_arches()],
|
||||
[
|
||||
(
|
||||
compose,
|
||||
arch,
|
||||
path_prefix,
|
||||
paths,
|
||||
pkgset,
|
||||
mmds.get(arch) if mmds else None,
|
||||
)
|
||||
for arch in compose.get_arches()
|
||||
],
|
||||
threads=compose.conf["createrepo_num_threads"],
|
||||
)
|
||||
|
||||
|
||||
def _create_arch_repo(worker_thread, args, task_num):
|
||||
"""Create a single pkgset repo for given arch."""
|
||||
compose, arch, path_prefix, paths, pkgset = args
|
||||
compose, arch, path_prefix, paths, pkgset, mmd = args
|
||||
createrepo_c = compose.conf["createrepo_c"]
|
||||
createrepo_checksum = compose.conf["createrepo_checksum"]
|
||||
repo = CreaterepoWrapper(createrepo_c=createrepo_c)
|
||||
@ -149,12 +159,13 @@ def _create_arch_repo(worker_thread, args, task_num):
|
||||
show_cmd=True,
|
||||
)
|
||||
# Add modulemd to the repo for all modules in all variants on this architecture.
|
||||
if Modulemd:
|
||||
mod_index = collect_module_defaults(compose.paths.work.module_defaults_dir())
|
||||
|
||||
for variant in compose.get_variants(arch=arch):
|
||||
for module_stream in variant.arch_mmds.get(arch, {}).values():
|
||||
mod_index.add_module_stream(module_stream)
|
||||
if Modulemd and mmd:
|
||||
names = set(x.get_module_name() for x in mmd)
|
||||
mod_index = collect_module_defaults(
|
||||
compose.paths.work.module_defaults_dir(), names
|
||||
)
|
||||
for x in mmd:
|
||||
mod_index.add_module_stream(x)
|
||||
add_modular_metadata(
|
||||
repo,
|
||||
repo_dir,
|
||||
@ -199,7 +210,7 @@ class MaterializedPackageSet(object):
|
||||
yield self.package_sets[arch][file_path]
|
||||
|
||||
@classmethod
|
||||
def create(klass, compose, pkgset_global, path_prefix):
|
||||
def create(klass, compose, pkgset_global, path_prefix, mmd=None):
|
||||
"""Create per-arch pkgsets and create repodata for each arch."""
|
||||
repo_dir_global = compose.paths.work.pkgset_repo(
|
||||
pkgset_global.name, arch="global"
|
||||
@ -221,7 +232,7 @@ class MaterializedPackageSet(object):
|
||||
|
||||
t.join()
|
||||
|
||||
create_arch_repos(compose, path_prefix, paths, pkgset_global)
|
||||
create_arch_repos(compose, path_prefix, paths, pkgset_global, mmd)
|
||||
|
||||
return klass(package_sets, paths)
|
||||
|
||||
|
||||
@ -421,14 +421,11 @@ class KojiPackageSet(PackageSetBase):
|
||||
% (rpm_info, self.sigkey_ordering, paths))
|
||||
return None
|
||||
|
||||
def populate(
|
||||
self, tag, event=None, inherit=True, logfile=None, include_packages=None,
|
||||
):
|
||||
def populate(self, tag, event=None, inherit=True, include_packages=None):
|
||||
"""Populate the package set with packages from given tag.
|
||||
|
||||
:param event: the Koji event to query at (or latest if not given)
|
||||
:param inherit: whether to enable tag inheritance
|
||||
:param logfile: path to file where package source tags should be logged
|
||||
:param include_packages: an iterable of tuples (package name, arch) that should
|
||||
be included, all others are skipped.
|
||||
"""
|
||||
@ -504,18 +501,6 @@ class KojiPackageSet(PackageSetBase):
|
||||
if invalid_sigkey_rpms:
|
||||
self.raise_invalid_sigkeys_exception(invalid_sigkey_rpms)
|
||||
|
||||
# Create a log with package NEVRAs and the tag they are coming from
|
||||
if logfile:
|
||||
with open(logfile, 'w') as f:
|
||||
for rpm in rpms:
|
||||
build = builds_by_id[rpm['build_id']]
|
||||
if 'tag_name' in build and 'tag_id' in build:
|
||||
f.write('{name}-{ep}:{version}-{release}.{arch}: {tag} [{tag_id}]\n'.format(
|
||||
tag=build['tag_name'], tag_id=build['tag_id'], ep=rpm['epoch'] or 0, **rpm))
|
||||
else:
|
||||
f.write('{name}-{ep}:{version}-{release}.{arch}: [pkgset_koji_builds]\n'.format(
|
||||
ep=rpm['epoch'] or 0, **rpm))
|
||||
|
||||
self.log_info("[DONE ] %s" % msg)
|
||||
return result
|
||||
|
||||
|
||||
@ -15,7 +15,6 @@
|
||||
|
||||
|
||||
import os
|
||||
from six.moves import cPickle as pickle
|
||||
import json
|
||||
import re
|
||||
from itertools import groupby
|
||||
@ -188,9 +187,9 @@ class PkgsetSourceKoji(pungi.phases.pkgset.source.PkgsetSourceBase):
|
||||
|
||||
def get_pkgset_from_koji(compose, koji_wrapper, path_prefix):
|
||||
event_info = get_koji_event_info(compose, koji_wrapper)
|
||||
pkgset_global = populate_global_pkgset(compose, koji_wrapper, path_prefix, event_info)
|
||||
pkgsets = populate_global_pkgset(compose, koji_wrapper, path_prefix, event_info)
|
||||
|
||||
return MaterializedPackageSet.create(compose, pkgset_global, path_prefix)
|
||||
return pkgsets
|
||||
|
||||
|
||||
def _add_module_to_variant(koji_wrapper, variant, build, add_to_variant_modules=False):
|
||||
@ -248,7 +247,9 @@ def _add_module_to_variant(koji_wrapper, variant, build, add_to_variant_modules=
|
||||
return nsvc
|
||||
|
||||
|
||||
def _get_modules_from_koji(compose, koji_wrapper, event, variant, variant_tags):
|
||||
def _get_modules_from_koji(
|
||||
compose, koji_wrapper, event, variant, variant_tags, tag_to_mmd
|
||||
):
|
||||
"""
|
||||
Loads modules for given `variant` from koji `session`, adds them to
|
||||
the `variant` and also to `variant_tags` dict.
|
||||
@ -276,6 +277,10 @@ def _get_modules_from_koji(compose, koji_wrapper, event, variant, variant_tags):
|
||||
# This is needed in createrepo phase where metadata is exposed by producmd
|
||||
variant.module_uid_to_koji_tag[nsvc] = tag
|
||||
|
||||
tag_to_mmd.setdefault(tag, {})
|
||||
for arch in variant.arch_mmds:
|
||||
tag_to_mmd[tag].setdefault(arch, set()).add(variant.arch_mmds[arch][nsvc])
|
||||
|
||||
module_msg = (
|
||||
"Module '{uid}' in variant '{variant}' will use Koji tag '{tag}' "
|
||||
"(as a result of querying module '{module}')"
|
||||
@ -365,7 +370,9 @@ def filter_by_whitelist(compose, module_builds, input_modules, expected_modules)
|
||||
return modules_to_keep
|
||||
|
||||
|
||||
def _get_modules_from_koji_tags(compose, koji_wrapper, event_id, variant, variant_tags):
|
||||
def _get_modules_from_koji_tags(
|
||||
compose, koji_wrapper, event_id, variant, variant_tags, tag_to_mmd
|
||||
):
|
||||
"""
|
||||
Loads modules for given `variant` from Koji, adds them to
|
||||
the `variant` and also to `variant_tags` dict.
|
||||
@ -452,6 +459,10 @@ def _get_modules_from_koji_tags(compose, koji_wrapper, event_id, variant, varian
|
||||
# This is needed in createrepo phase where metadata is exposed by producmd
|
||||
variant.module_uid_to_koji_tag[nsvc] = module_tag
|
||||
|
||||
tag_to_mmd.setdefault(module_tag, {})
|
||||
for arch in variant.arch_mmds:
|
||||
tag_to_mmd[module_tag].setdefault(arch, set()).add(variant.arch_mmds[arch][nsvc])
|
||||
|
||||
module_msg = "Module {module} in variant {variant} will use Koji tag {tag}.".format(
|
||||
variant=variant, tag=module_tag, module=build["nvr"])
|
||||
compose.log_info("%s" % module_msg)
|
||||
@ -524,19 +535,12 @@ def populate_global_pkgset(compose, koji_wrapper, path_prefix, event):
|
||||
# there are some packages with invalid sigkeys, it raises an exception.
|
||||
allow_invalid_sigkeys = compose.conf["gather_method"] == "deps"
|
||||
|
||||
tag_to_mmd = {}
|
||||
|
||||
for variant in compose.all_variants.values():
|
||||
# pkgset storing the packages belonging to this particular variant.
|
||||
variant.pkgset = pungi.phases.pkgset.pkgsets.KojiPackageSet(
|
||||
"TODO",
|
||||
koji_wrapper,
|
||||
compose.conf["sigkeys"],
|
||||
logger=compose._logger,
|
||||
arches=all_arches,
|
||||
)
|
||||
variant_tags[variant] = []
|
||||
|
||||
# Get the modules from Koji tag or from PDC, depending on
|
||||
# configuration.
|
||||
# Get the modules from Koji tag
|
||||
modular_koji_tags = variant.get_modular_koji_tags()
|
||||
if (variant.modules or modular_koji_tags) and not Modulemd:
|
||||
raise ValueError(
|
||||
@ -545,20 +549,15 @@ def populate_global_pkgset(compose, koji_wrapper, path_prefix, event):
|
||||
"modules.")
|
||||
|
||||
if modular_koji_tags or (compose.conf["pkgset_koji_module_tag"] and variant.modules):
|
||||
# List modules tagged in particular tags.
|
||||
_get_modules_from_koji_tags(
|
||||
compose,
|
||||
koji_wrapper,
|
||||
event,
|
||||
variant,
|
||||
variant_tags,
|
||||
compose, koji_wrapper, event, variant, variant_tags, tag_to_mmd
|
||||
)
|
||||
elif variant.modules:
|
||||
# Search each module in Koji separately. Tagging does not come into
|
||||
# play here.
|
||||
_get_modules_from_koji(
|
||||
compose,
|
||||
koji_wrapper,
|
||||
event,
|
||||
variant,
|
||||
variant_tags,
|
||||
compose, koji_wrapper, event, variant, variant_tags, tag_to_mmd
|
||||
)
|
||||
|
||||
# Ensure that every tag added to `variant_tags` is added also to
|
||||
@ -567,62 +566,38 @@ def populate_global_pkgset(compose, koji_wrapper, path_prefix, event):
|
||||
if variant_tag not in compose_tags:
|
||||
compose_tags.append(variant_tag)
|
||||
|
||||
if not variant_tags[variant] and variant.modules is None:
|
||||
variant_tags[variant].extend(force_list(compose.conf["pkgset_koji_tag"]))
|
||||
# TODO check if this works for Fedora Modular variant
|
||||
variant_tags[variant].extend(force_list(compose.conf["pkgset_koji_tag"]))
|
||||
|
||||
# Add global tag(s) if supplied.
|
||||
pkgset_koji_tags = []
|
||||
if 'pkgset_koji_tag' in compose.conf:
|
||||
pkgset_koji_tags = force_list(compose.conf["pkgset_koji_tag"])
|
||||
compose_tags.extend(pkgset_koji_tags)
|
||||
pkgset_koji_tags = force_list(compose.conf.get("pkgset_koji_tag", []))
|
||||
compose_tags.extend(pkgset_koji_tags)
|
||||
|
||||
inherit = compose.conf["pkgset_koji_inherit"]
|
||||
inherit_modules = compose.conf["pkgset_koji_inherit_modules"]
|
||||
|
||||
global_pkgset = pungi.phases.pkgset.pkgsets.KojiPackageSet(
|
||||
"TODO",
|
||||
koji_wrapper,
|
||||
compose.conf["sigkeys"],
|
||||
logger=compose._logger,
|
||||
arches=all_arches,
|
||||
)
|
||||
|
||||
old_file_cache_path = _find_old_file_cache_path(compose)
|
||||
old_file_cache = None
|
||||
if old_file_cache_path:
|
||||
compose.log_info("Reusing old PKGSET file cache from %s" % old_file_cache_path)
|
||||
old_file_cache = pungi.phases.pkgset.pkgsets.KojiPackageSet.load_old_file_cache(
|
||||
old_file_cache_path
|
||||
)
|
||||
global_pkgset.set_old_file_cache(old_file_cache)
|
||||
pkgsets = []
|
||||
|
||||
# Get package set for each compose tag and merge it to global package
|
||||
# list. Also prepare per-variant pkgset, because we do not have list
|
||||
# of binary RPMs in module definition - there is just list of SRPMs.
|
||||
for compose_tag in compose_tags:
|
||||
compose.log_info(
|
||||
"Populating the global package set from tag '%s'" % compose_tag
|
||||
)
|
||||
compose.log_info("Loading package set for tag %s", compose_tag)
|
||||
if compose_tag in pkgset_koji_tags:
|
||||
extra_builds = force_list(compose.conf.get("pkgset_koji_builds", []))
|
||||
else:
|
||||
extra_builds = []
|
||||
|
||||
pkgset = pungi.phases.pkgset.pkgsets.KojiPackageSet(
|
||||
"TODO",
|
||||
compose_tag,
|
||||
koji_wrapper, compose.conf["sigkeys"], logger=compose._logger,
|
||||
arches=all_arches, packages=packages_to_gather,
|
||||
allow_invalid_sigkeys=allow_invalid_sigkeys,
|
||||
populate_only_packages=populate_only_packages_to_gather,
|
||||
cache_region=compose.cache_region,
|
||||
extra_builds=extra_builds)
|
||||
if old_file_cache:
|
||||
pkgset.set_old_file_cache(old_file_cache)
|
||||
# Create a filename for log with package-to-tag mapping. The tag
|
||||
# name is included in filename, so any slashes in it are replaced
|
||||
# with underscores just to be safe.
|
||||
logfile = compose.paths.log.log_file(
|
||||
None, "packages_from_%s" % compose_tag.replace("/", "_")
|
||||
)
|
||||
# TODO find cache for this tag
|
||||
|
||||
is_traditional = compose_tag in compose.conf.get("pkgset_koji_tag", [])
|
||||
should_inherit = inherit if is_traditional else inherit_modules
|
||||
|
||||
@ -650,7 +625,6 @@ def populate_global_pkgset(compose, koji_wrapper, path_prefix, event):
|
||||
compose_tag,
|
||||
event,
|
||||
inherit=should_inherit,
|
||||
logfile=logfile,
|
||||
include_packages=modular_packages,
|
||||
)
|
||||
for variant in compose.all_variants.values():
|
||||
@ -659,34 +633,23 @@ def populate_global_pkgset(compose, koji_wrapper, path_prefix, event):
|
||||
# If it's a modular tag, store the package set for the module.
|
||||
for nsvc, koji_tag in variant.module_uid_to_koji_tag.items():
|
||||
if compose_tag == koji_tag:
|
||||
# TODO check if this is still needed
|
||||
# It should not be needed, we can get package sets by name.
|
||||
variant.nsvc_to_pkgset[nsvc] = pkgset
|
||||
|
||||
# Optimization for case where we have just single compose
|
||||
# tag - we do not have to merge in this case...
|
||||
if len(variant_tags[variant]) == 1:
|
||||
variant.pkgset = pkgset
|
||||
else:
|
||||
variant.pkgset.fast_merge(pkgset)
|
||||
# Optimization for case where we have just single compose
|
||||
# tag - we do not have to merge in this case...
|
||||
if len(compose_tags) == 1:
|
||||
global_pkgset = pkgset
|
||||
else:
|
||||
global_pkgset.fast_merge(pkgset)
|
||||
variant.pkgsets.add(compose_tag)
|
||||
# TODO pickle pkgset to disk
|
||||
# TODO save pkgset file list
|
||||
# TODO save pkgset file cache
|
||||
pkgsets.append(
|
||||
MaterializedPackageSet.create(
|
||||
compose, pkgset, path_prefix, mmd=tag_to_mmd.get(pkgset.name)
|
||||
),
|
||||
)
|
||||
|
||||
global_pkgset_path = os.path.join(
|
||||
compose.paths.work.topdir(arch="global"), "pkgset_global.pickle"
|
||||
)
|
||||
with open(global_pkgset_path, "wb") as f:
|
||||
data = pickle.dumps(global_pkgset, protocol=pickle.HIGHEST_PROTOCOL)
|
||||
f.write(data)
|
||||
|
||||
# write global package list
|
||||
global_pkgset.save_file_list(
|
||||
compose.paths.work.package_list(arch="global"),
|
||||
remove_path_prefix=path_prefix)
|
||||
global_pkgset.save_file_cache(compose.paths.work.pkgset_file_cache())
|
||||
return global_pkgset
|
||||
return pkgsets
|
||||
|
||||
|
||||
def get_koji_event_info(compose, koji_wrapper):
|
||||
|
||||
@ -112,9 +112,9 @@ def get_pkgset_from_repos(compose):
|
||||
flist = sorted(set(flist))
|
||||
pkgset_global = populate_global_pkgset(compose, flist, path_prefix)
|
||||
|
||||
package_sets = MaterializedPackageSet.create(compose, pkgset_global, path_prefix)
|
||||
package_set = MaterializedPackageSet.create(compose, pkgset_global, path_prefix)
|
||||
|
||||
return package_sets, path_prefix
|
||||
return [package_set], path_prefix
|
||||
|
||||
|
||||
def populate_global_pkgset(compose, file_list, path_prefix):
|
||||
|
||||
@ -263,7 +263,7 @@ class Variant(object):
|
||||
self.parent = parent
|
||||
self.is_empty = is_empty
|
||||
|
||||
self.pkgset = None
|
||||
self.pkgsets = set()
|
||||
self.arch_mmds = {}
|
||||
self.module_uid_to_koji_tag = {}
|
||||
self.nsvc_to_pkgset = {}
|
||||
|
||||
@ -63,7 +63,7 @@ class MockVariant(mock.Mock):
|
||||
self.arch_mmds = {}
|
||||
self.module_uid_to_koji_tag = {}
|
||||
self.variants = {}
|
||||
self.pkgset = mock.Mock(rpms_by_arch={})
|
||||
self.pkgsets = set()
|
||||
self.modules = None
|
||||
self.name = name
|
||||
self.nsvc_to_pkgset = defaultdict(lambda: mock.Mock(rpms_by_arch={}))
|
||||
|
||||
@ -169,7 +169,7 @@ class TestKojiPkgset(PkgsetCompareMixin, helpers.PungiTestCase):
|
||||
|
||||
pkgset = pkgsets.KojiPackageSet("pkgset", self.koji_wrapper, [None])
|
||||
|
||||
result = pkgset.populate('f25', logfile=self.topdir + '/pkgset.log')
|
||||
result = pkgset.populate('f25')
|
||||
|
||||
self.assertEqual(
|
||||
self.koji_wrapper.koji_proxy.mock_calls,
|
||||
@ -184,18 +184,6 @@ class TestKojiPkgset(PkgsetCompareMixin, helpers.PungiTestCase):
|
||||
'x86_64': ['rpms/bash@4.3.42@4.fc24@x86_64',
|
||||
'rpms/bash-debuginfo@4.3.42@4.fc24@x86_64']})
|
||||
|
||||
self.maxDiff = None
|
||||
with open(self.topdir + '/pkgset.log') as f:
|
||||
self.assertEqual(
|
||||
sorted(f.read().strip().splitlines()),
|
||||
sorted(['pungi-0:4.1.3-3.fc25.noarch: f25 [335]',
|
||||
'pungi-0:4.1.3-3.fc25.src: f25 [335]',
|
||||
'bash-0:4.3.42-4.fc24.i686: f25 [335]',
|
||||
'bash-0:4.3.42-4.fc24.x86_64: f25 [335]',
|
||||
'bash-0:4.3.42-4.fc24.src: f25 [335]',
|
||||
'bash-debuginfo-0:4.3.42-4.fc24.i686: f25 [335]',
|
||||
'bash-debuginfo-0:4.3.42-4.fc24.x86_64: f25 [335]']))
|
||||
|
||||
def test_only_one_arch(self):
|
||||
self._touch_files([
|
||||
'rpms/bash@4.3.42@4.fc24@x86_64',
|
||||
@ -332,7 +320,7 @@ class TestKojiPkgset(PkgsetCompareMixin, helpers.PungiTestCase):
|
||||
populate_only_packages=True,
|
||||
)
|
||||
|
||||
result = pkgset.populate('f25', logfile=self.topdir + '/pkgset.log')
|
||||
result = pkgset.populate('f25')
|
||||
|
||||
self.assertEqual(
|
||||
self.koji_wrapper.koji_proxy.mock_calls,
|
||||
@ -430,7 +418,7 @@ class TestKojiPkgset(PkgsetCompareMixin, helpers.PungiTestCase):
|
||||
"pkgset", self.koji_wrapper, [None], extra_builds=["pungi-4.1.3-3.fc25"]
|
||||
)
|
||||
|
||||
result = pkgset.populate('f25', logfile=self.topdir + '/pkgset.log')
|
||||
result = pkgset.populate('f25')
|
||||
|
||||
self.assertEqual(
|
||||
self.koji_wrapper.koji_proxy.mock_calls,
|
||||
|
||||
@ -84,6 +84,7 @@ class TestPopulateGlobalPkgset(helpers.PungiTestCase):
|
||||
self.pkgset_path = os.path.join(self.topdir, 'work', 'global', 'pkgset_global.pickle')
|
||||
self.koji_module_path = os.path.join(self.topdir, 'work', 'global', 'koji-module-Server.yaml')
|
||||
|
||||
@unittest.skip("TODO not working now")
|
||||
@mock.patch('six.moves.cPickle.dumps')
|
||||
@mock.patch('pungi.phases.pkgset.pkgsets.KojiPackageSet')
|
||||
def test_populate(self, KojiPackageSet, pickle_dumps):
|
||||
@ -120,6 +121,7 @@ class TestPopulateGlobalPkgset(helpers.PungiTestCase):
|
||||
with open(self.pkgset_path) as f:
|
||||
self.assertEqual(f.read(), 'DATA')
|
||||
|
||||
@unittest.skip("TODO not working now")
|
||||
@mock.patch('six.moves.cPickle.dumps')
|
||||
@mock.patch('pungi.phases.pkgset.pkgsets.KojiPackageSet')
|
||||
def test_populate_with_multiple_koji_tags(self, KojiPackageSet, pickle_dumps):
|
||||
@ -182,9 +184,10 @@ class TestPopulateGlobalPkgset(helpers.PungiTestCase):
|
||||
})
|
||||
pickle_dumps.return_value = b'DATA'
|
||||
|
||||
pkgset = source_koji.populate_global_pkgset(
|
||||
pkgsets = source_koji.populate_global_pkgset(
|
||||
self.compose, self.koji_wrapper, '/prefix', 123456)
|
||||
self.assertItemsEqual(pkgset.packages, ["pkg", "foo"])
|
||||
self.assertEqual(len(pkgsets), 1)
|
||||
self.assertItemsEqual(pkgsets[0].packages, ["pkg", "foo"])
|
||||
|
||||
|
||||
class TestGetPackageSetFromKoji(helpers.PungiTestCase):
|
||||
@ -198,15 +201,11 @@ class TestGetPackageSetFromKoji(helpers.PungiTestCase):
|
||||
self.koji_wrapper.koji_proxy.getLastEvent.return_value = EVENT_INFO
|
||||
self.koji_wrapper.koji_proxy.getTag.return_value = TAG_INFO
|
||||
|
||||
@unittest.skip("TODO not working now")
|
||||
@mock.patch('pungi.phases.pkgset.common.create_arch_repos')
|
||||
@mock.patch('pungi.phases.pkgset.common.run_create_global_repo')
|
||||
@mock.patch('pungi.phases.pkgset.common.get_create_global_repo_cmd')
|
||||
@mock.patch('pungi.phases.pkgset.common.populate_arch_pkgsets')
|
||||
@mock.patch('pungi.phases.pkgset.sources.source_koji.populate_global_pkgset')
|
||||
def test_get_package_sets(self, pgp, pap, gcgrc, rcgr, car):
|
||||
expected = {'x86_64': mock.Mock()}
|
||||
pap.return_value = expected
|
||||
expected['global'] = pgp.return_value
|
||||
def test_get_package_sets(self, pgp, car):
|
||||
expected = {"x86_64": mock.Mock(), "global": pgp.return_value}
|
||||
|
||||
def mock_create_arch_repos(compose, path_prefix, paths):
|
||||
for arch in compose.get_arches():
|
||||
@ -221,25 +220,19 @@ class TestGetPackageSetFromKoji(helpers.PungiTestCase):
|
||||
[mock.call.getLastEvent()]
|
||||
)
|
||||
|
||||
self.assertEqual(len(pkgsets), 1)
|
||||
self.assertEqual(pgp.call_args_list,
|
||||
[mock.call(self.compose, self.koji_wrapper, '/prefix',
|
||||
EVENT_INFO)])
|
||||
self.assertEqual(pap.call_args_list,
|
||||
[mock.call(self.compose, '/prefix', pgp.return_value)])
|
||||
global_repo = os.path.join(self.topdir, "work/global/repo")
|
||||
self.assertEqual(
|
||||
gcgrc.call_args_list, [mock.call(self.compose, '/prefix', global_repo)]
|
||||
)
|
||||
self.assertEqual(rcgr.call_args_list,
|
||||
[mock.call(self.compose, gcgrc.return_value)])
|
||||
self.assertItemsEqual(
|
||||
car.call_args_list,
|
||||
[mock.call(self.compose, '/prefix', pkgsets.paths)],
|
||||
[mock.call(self.compose, "/prefix", pkgsets[0].paths)],
|
||||
)
|
||||
|
||||
self.assertEqual(pkgsets.package_sets, expected)
|
||||
self.assertEqual(pkgsets[0].package_sets, expected)
|
||||
self.assertEqual(
|
||||
pkgsets.paths,
|
||||
pkgsets[0].paths,
|
||||
{
|
||||
"amd64": "/repo/for/amd64",
|
||||
"global": global_repo,
|
||||
|
||||
Loading…
Reference in New Issue
Block a user