454 lines
16 KiB
Python
454 lines
16 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; version 2 of the License.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU Library General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, see <https://gnu.org/licenses/>.
|
|
|
|
|
|
__all__ = ("create_variant_repo",)
|
|
|
|
|
|
import copy
|
|
import errno
|
|
import glob
|
|
import os
|
|
import shutil
|
|
import threading
|
|
import xml.dom.minidom
|
|
|
|
from kobo.threads import ThreadPool, WorkerThread
|
|
from kobo.shortcuts import run, relative_path
|
|
|
|
from ..wrappers.scm import get_dir_from_scm
|
|
from ..wrappers.createrepo import CreaterepoWrapper
|
|
from .base import PhaseBase
|
|
from ..util import find_old_compose, get_arch_variant_data, temp_dir
|
|
from ..module_util import Modulemd, collect_module_defaults
|
|
|
|
import productmd.rpms
|
|
import productmd.modules
|
|
|
|
|
|
createrepo_lock = threading.Lock()
|
|
createrepo_dirs = set()
|
|
|
|
|
|
class CreaterepoPhase(PhaseBase):
|
|
name = "createrepo"
|
|
|
|
def __init__(self, compose, pkgset_phase=None):
|
|
PhaseBase.__init__(self, compose)
|
|
self.pool = ThreadPool(logger=self.compose._logger)
|
|
self.modules_metadata = ModulesMetadata(compose)
|
|
self.pkgset_phase = pkgset_phase
|
|
|
|
def validate(self):
|
|
errors = []
|
|
|
|
if not self.compose.old_composes and self.compose.conf.get("createrepo_deltas"):
|
|
errors.append("Can not generate deltas without old compose")
|
|
|
|
if errors:
|
|
raise ValueError("\n".join(errors))
|
|
|
|
def run(self):
|
|
get_productids_from_scm(self.compose)
|
|
reference_pkgset = None
|
|
if self.pkgset_phase and self.pkgset_phase.package_sets:
|
|
reference_pkgset = self.pkgset_phase.package_sets[-1]
|
|
for i in range(self.compose.conf["createrepo_num_threads"]):
|
|
self.pool.add(
|
|
CreaterepoThread(self.pool, reference_pkgset, self.modules_metadata)
|
|
)
|
|
|
|
for variant in self.compose.get_variants():
|
|
if variant.is_empty:
|
|
continue
|
|
self.pool.queue_put((self.compose, None, variant, "srpm"))
|
|
for arch in variant.arches:
|
|
self.pool.queue_put((self.compose, arch, variant, "rpm"))
|
|
self.pool.queue_put((self.compose, arch, variant, "debuginfo"))
|
|
|
|
self.pool.start()
|
|
|
|
def stop(self):
|
|
super(CreaterepoPhase, self).stop()
|
|
self.modules_metadata.write_modules_metadata()
|
|
|
|
|
|
def create_variant_repo(
|
|
compose, arch, variant, pkg_type, pkgset, modules_metadata=None
|
|
):
|
|
types = {
|
|
"rpm": (
|
|
"binary",
|
|
lambda **kwargs: compose.paths.compose.repository(
|
|
arch=arch, variant=variant, **kwargs
|
|
),
|
|
),
|
|
"srpm": (
|
|
"source",
|
|
lambda **kwargs: compose.paths.compose.repository(
|
|
arch="src", variant=variant, **kwargs
|
|
),
|
|
),
|
|
"debuginfo": (
|
|
"debug",
|
|
lambda **kwargs: compose.paths.compose.debug_repository(
|
|
arch=arch, variant=variant, **kwargs
|
|
),
|
|
),
|
|
}
|
|
|
|
if variant.is_empty or (arch is None and pkg_type != "srpm"):
|
|
compose.log_info(
|
|
"[SKIP ] Creating repo (arch: %s, variant: %s): %s" % (arch, variant)
|
|
)
|
|
return
|
|
|
|
createrepo_c = compose.conf["createrepo_c"]
|
|
createrepo_checksum = compose.conf["createrepo_checksum"]
|
|
repo = CreaterepoWrapper(createrepo_c=createrepo_c)
|
|
repo_dir_arch = None
|
|
if pkgset:
|
|
repo_dir_arch = pkgset.paths["global" if pkg_type == "srpm" else arch]
|
|
|
|
try:
|
|
repo_dir = types[pkg_type][1]()
|
|
except KeyError:
|
|
raise ValueError("Unknown package type: %s" % pkg_type)
|
|
|
|
msg = "Creating repo (arch: %s, variant: %s): %s" % (arch, variant, repo_dir)
|
|
|
|
# HACK: using global lock
|
|
# This is important when addons put packages into parent variant directory.
|
|
# There can't be multiple createrepo processes operating on the same
|
|
# directory.
|
|
with createrepo_lock:
|
|
if repo_dir in createrepo_dirs:
|
|
compose.log_warning("[SKIP ] Already in progress: %s" % msg)
|
|
return
|
|
createrepo_dirs.add(repo_dir)
|
|
|
|
compose.log_info("[BEGIN] %s" % msg)
|
|
|
|
# We only want delta RPMs for binary repos.
|
|
with_deltas = pkg_type == "rpm" and _has_deltas(compose, variant, arch)
|
|
|
|
rpms = set()
|
|
rpm_nevras = set()
|
|
|
|
# read rpms from metadata rather than guessing it by scanning filesystem
|
|
manifest_file = compose.paths.compose.metadata("rpms.json")
|
|
manifest = productmd.rpms.Rpms()
|
|
manifest.load(manifest_file)
|
|
|
|
for rpms_arch, data in manifest.rpms.get(variant.uid, {}).items():
|
|
if arch is not None and arch != rpms_arch:
|
|
continue
|
|
for srpm_data in data.values():
|
|
for rpm_nevra, rpm_data in srpm_data.items():
|
|
if types[pkg_type][0] != rpm_data["category"]:
|
|
continue
|
|
path = os.path.join(compose.topdir, "compose", rpm_data["path"])
|
|
rel_path = relative_path(path, repo_dir.rstrip("/") + "/")
|
|
rpms.add(rel_path)
|
|
rpm_nevras.add(str(rpm_nevra))
|
|
|
|
file_list = compose.paths.work.repo_package_list(arch, variant, pkg_type)
|
|
with open(file_list, "w") as f:
|
|
for rel_path in sorted(rpms):
|
|
f.write("%s\n" % rel_path)
|
|
|
|
# Only find last compose when we actually want delta RPMs.
|
|
old_package_dirs = _get_old_package_dirs(compose, repo_dir) if with_deltas else None
|
|
if old_package_dirs:
|
|
# If we are creating deltas, we can not reuse existing metadata, as
|
|
# that would stop deltas from being created.
|
|
# This seems to only affect createrepo_c though.
|
|
repo_dir_arch = None
|
|
|
|
comps_path = None
|
|
if compose.has_comps and pkg_type == "rpm":
|
|
comps_path = compose.paths.work.comps(arch=arch, variant=variant)
|
|
cmd = repo.get_createrepo_cmd(
|
|
repo_dir,
|
|
update=True,
|
|
database=compose.should_create_yum_database,
|
|
skip_stat=True,
|
|
pkglist=file_list,
|
|
outputdir=repo_dir,
|
|
workers=compose.conf["createrepo_num_workers"],
|
|
groupfile=comps_path,
|
|
update_md_path=repo_dir_arch,
|
|
checksum=createrepo_checksum,
|
|
deltas=with_deltas,
|
|
oldpackagedirs=old_package_dirs,
|
|
use_xz=compose.conf["createrepo_use_xz"],
|
|
extra_args=compose.conf["createrepo_extra_args"],
|
|
)
|
|
log_file = compose.paths.log.log_file(
|
|
arch, "createrepo-%s.%s" % (variant, pkg_type)
|
|
)
|
|
run(cmd, logfile=log_file, show_cmd=True)
|
|
|
|
# call modifyrepo to inject productid
|
|
product_id = compose.conf.get("product_id")
|
|
if product_id and pkg_type == "rpm":
|
|
# add product certificate to base (rpm) repo; skip source and debug
|
|
product_id_path = compose.paths.work.product_id(arch, variant)
|
|
if os.path.isfile(product_id_path):
|
|
cmd = repo.get_modifyrepo_cmd(
|
|
os.path.join(repo_dir, "repodata"), product_id_path, compress_type="gz"
|
|
)
|
|
log_file = compose.paths.log.log_file(arch, "modifyrepo-%s" % variant)
|
|
run(cmd, logfile=log_file, show_cmd=True)
|
|
# productinfo is not supported by modifyrepo in any way
|
|
# this is a HACK to make CDN happy (dmach: at least I think,
|
|
# need to confirm with dgregor)
|
|
shutil.copy2(
|
|
product_id_path, os.path.join(repo_dir, "repodata", "productid")
|
|
)
|
|
|
|
# call modifyrepo to inject modulemd if needed
|
|
if pkg_type == "rpm" and arch in variant.arch_mmds and Modulemd is not None:
|
|
mod_index = Modulemd.ModuleIndex()
|
|
metadata = []
|
|
|
|
for module_id, mmd in variant.arch_mmds.get(arch, {}).items():
|
|
if modules_metadata:
|
|
module_rpms = mmd.get_rpm_artifacts()
|
|
metadata.append((module_id, module_rpms))
|
|
mod_index.add_module_stream(mmd)
|
|
|
|
module_names = set(mod_index.get_module_names())
|
|
defaults_dir = compose.paths.work.module_defaults_dir()
|
|
overrides_dir = compose.conf.get("module_defaults_override_dir")
|
|
collect_module_defaults(
|
|
defaults_dir, module_names, mod_index, overrides_dir=overrides_dir
|
|
)
|
|
|
|
log_file = compose.paths.log.log_file(arch, "modifyrepo-modules-%s" % variant)
|
|
add_modular_metadata(repo, repo_dir, mod_index, log_file)
|
|
|
|
for module_id, module_rpms in metadata:
|
|
modulemd_path = os.path.join(
|
|
types[pkg_type][1](relative=True),
|
|
find_file_in_repodata(repo_dir, "modules"),
|
|
)
|
|
modules_metadata.prepare_module_metadata(
|
|
variant,
|
|
arch,
|
|
module_id,
|
|
modulemd_path,
|
|
types[pkg_type][0],
|
|
list(module_rpms),
|
|
)
|
|
|
|
compose.log_info("[DONE ] %s" % msg)
|
|
|
|
|
|
def add_modular_metadata(repo, repo_path, mod_index, log_file):
|
|
"""Add modular metadata into a repository."""
|
|
# Dumping empty index fails, we need to check for that.
|
|
if not mod_index.get_module_names():
|
|
return
|
|
|
|
with temp_dir() as tmp_dir:
|
|
modules_path = os.path.join(tmp_dir, "modules.yaml")
|
|
with open(modules_path, "w") as f:
|
|
f.write(mod_index.dump_to_string())
|
|
|
|
cmd = repo.get_modifyrepo_cmd(
|
|
os.path.join(repo_path, "repodata"),
|
|
modules_path,
|
|
mdtype="modules",
|
|
compress_type="gz",
|
|
)
|
|
run(cmd, logfile=log_file, show_cmd=True)
|
|
|
|
|
|
def find_file_in_repodata(repo_path, type_):
|
|
dom = xml.dom.minidom.parse(os.path.join(repo_path, "repodata", "repomd.xml"))
|
|
for entry in dom.getElementsByTagName("data"):
|
|
if entry.getAttribute("type") == type_:
|
|
return entry.getElementsByTagName("location")[0].getAttribute("href")
|
|
entry.unlink()
|
|
raise RuntimeError("No such file in repodata: %s" % type_)
|
|
|
|
|
|
class CreaterepoThread(WorkerThread):
|
|
def __init__(self, pool, reference_pkgset, modules_metadata):
|
|
super(CreaterepoThread, self).__init__(pool)
|
|
self.reference_pkgset = reference_pkgset
|
|
self.modules_metadata = modules_metadata
|
|
|
|
def process(self, item, num):
|
|
compose, arch, variant, pkg_type = item
|
|
create_variant_repo(
|
|
compose,
|
|
arch,
|
|
variant,
|
|
pkg_type=pkg_type,
|
|
pkgset=self.reference_pkgset,
|
|
modules_metadata=self.modules_metadata,
|
|
)
|
|
|
|
|
|
def get_productids_from_scm(compose):
|
|
# product_id is a scm_dict: {scm, repo, branch, dir}
|
|
# expected file name format: $variant_uid-$arch-*.pem
|
|
product_id = compose.conf.get("product_id")
|
|
if not product_id:
|
|
compose.log_info("No product certificates specified")
|
|
return
|
|
|
|
product_id_allow_missing = compose.conf["product_id_allow_missing"]
|
|
|
|
msg = "Getting product certificates from SCM..."
|
|
compose.log_info("[BEGIN] %s" % msg)
|
|
|
|
tmp_dir = compose.mkdtemp(prefix="pungi_")
|
|
try:
|
|
get_dir_from_scm(product_id, tmp_dir)
|
|
except OSError as e:
|
|
if e.errno == errno.ENOENT and product_id_allow_missing:
|
|
compose.log_warning("No product IDs in %s" % product_id)
|
|
return
|
|
raise
|
|
|
|
for arch in compose.get_arches():
|
|
for variant in compose.get_variants(arch=arch):
|
|
# some layered products may use base product name before variant
|
|
pem_files = glob.glob("%s/*%s-%s-*.pem" % (tmp_dir, variant.uid, arch))
|
|
# use for development:
|
|
# pem_files = glob.glob("%s/*.pem" % tmp_dir)[-1:]
|
|
if not pem_files:
|
|
warning = "No product certificate found (arch: %s, variant: %s)" % (
|
|
arch,
|
|
variant.uid,
|
|
)
|
|
if product_id_allow_missing:
|
|
compose.log_warning(warning)
|
|
continue
|
|
else:
|
|
shutil.rmtree(tmp_dir)
|
|
raise RuntimeError(warning)
|
|
if len(pem_files) > 1:
|
|
shutil.rmtree(tmp_dir)
|
|
raise RuntimeError(
|
|
"Multiple product certificates found (arch: %s, variant: %s): %s"
|
|
% (
|
|
arch,
|
|
variant.uid,
|
|
", ".join(sorted([os.path.basename(i) for i in pem_files])),
|
|
)
|
|
)
|
|
product_id_path = compose.paths.work.product_id(arch, variant)
|
|
shutil.copy2(pem_files[0], product_id_path)
|
|
|
|
shutil.rmtree(tmp_dir)
|
|
compose.log_info("[DONE ] %s" % msg)
|
|
|
|
|
|
def _get_old_package_dirs(compose, repo_dir):
|
|
"""Given a compose and a path to a repo in it, try to find corresponging
|
|
repo in an older compose and return a list of paths to directories with
|
|
packages in it.
|
|
"""
|
|
if not compose.conf["createrepo_deltas"]:
|
|
return None
|
|
old_compose_path = find_old_compose(
|
|
compose.old_composes,
|
|
compose.ci_base.release.short,
|
|
compose.ci_base.release.version,
|
|
compose.ci_base.release.type_suffix,
|
|
compose.ci_base.base_product.short
|
|
if compose.ci_base.release.is_layered
|
|
else None,
|
|
compose.ci_base.base_product.version
|
|
if compose.ci_base.release.is_layered
|
|
else None,
|
|
allowed_statuses=["FINISHED", "FINISHED_INCOMPLETE"],
|
|
)
|
|
if not old_compose_path:
|
|
compose.log_info("No suitable old compose found in: %s" % compose.old_composes)
|
|
return None
|
|
rel_dir = relative_path(repo_dir, compose.topdir.rstrip("/") + "/")
|
|
old_package_dirs = os.path.join(old_compose_path, rel_dir, "Packages")
|
|
if compose.conf["hashed_directories"]:
|
|
old_package_dirs = _find_package_dirs(old_package_dirs)
|
|
return old_package_dirs
|
|
|
|
|
|
def _find_package_dirs(base):
|
|
"""Assuming the packages are in directories hashed by first letter, find
|
|
all the buckets in given base.
|
|
"""
|
|
buckets = set()
|
|
try:
|
|
for subdir in os.listdir(base):
|
|
bucket = os.path.join(base, subdir)
|
|
if os.path.isdir(bucket):
|
|
buckets.add(bucket)
|
|
except OSError:
|
|
# The directory does not exist, so no drpms for you!
|
|
pass
|
|
return sorted(buckets)
|
|
|
|
|
|
def _has_deltas(compose, variant, arch):
|
|
"""Check if delta RPMs are enabled for given variant and architecture."""
|
|
key = "createrepo_deltas"
|
|
if isinstance(compose.conf.get(key), bool):
|
|
return compose.conf[key]
|
|
return any(get_arch_variant_data(compose.conf, key, arch, variant))
|
|
|
|
|
|
class ModulesMetadata(object):
|
|
def __init__(self, compose):
|
|
# Prepare empty module metadata
|
|
self.compose = compose
|
|
self.modules_metadata_file = self.compose.paths.compose.metadata("modules.json")
|
|
self.productmd_modules_metadata = productmd.modules.Modules()
|
|
self.productmd_modules_metadata.compose.id = copy.copy(self.compose.compose_id)
|
|
self.productmd_modules_metadata.compose.type = copy.copy(
|
|
self.compose.compose_type
|
|
)
|
|
self.productmd_modules_metadata.compose.date = copy.copy(
|
|
self.compose.compose_date
|
|
)
|
|
self.productmd_modules_metadata.compose.respin = copy.copy(
|
|
self.compose.compose_respin
|
|
)
|
|
|
|
def write_modules_metadata(self):
|
|
"""
|
|
flush modules metadata into file
|
|
"""
|
|
self.compose.log_info(
|
|
"Writing modules metadata: %s" % self.modules_metadata_file
|
|
)
|
|
self.productmd_modules_metadata.dump(self.modules_metadata_file)
|
|
|
|
def prepare_module_metadata(
|
|
self, variant, arch, nsvc, modulemd_path, category, module_rpms
|
|
):
|
|
"""
|
|
Find koji tag which corresponds to the module and add record into
|
|
module metadata structure.
|
|
"""
|
|
koji_tag = variant.module_uid_to_koji_tag[nsvc]
|
|
self.productmd_modules_metadata.add(
|
|
variant.uid, arch, nsvc, koji_tag, modulemd_path, category, module_rpms
|
|
)
|