836 lines
30 KiB
Python
836 lines
30 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/>.
|
|
|
|
|
|
import os
|
|
import random
|
|
import shutil
|
|
import stat
|
|
import json
|
|
|
|
import productmd.treeinfo
|
|
from productmd.images import Image
|
|
from kobo.threads import ThreadPool, WorkerThread
|
|
from kobo.shortcuts import run, relative_path
|
|
from six.moves import shlex_quote
|
|
|
|
from pungi.wrappers import iso
|
|
from pungi.wrappers.createrepo import CreaterepoWrapper
|
|
from pungi.wrappers import kojiwrapper
|
|
from pungi.phases.base import PhaseBase, PhaseLoggerMixin
|
|
from pungi.util import (
|
|
makedirs,
|
|
get_volid,
|
|
get_arch_variant_data,
|
|
failable,
|
|
get_file_size,
|
|
get_mtime,
|
|
read_json_file,
|
|
)
|
|
from pungi.media_split import MediaSplitter, convert_media_size
|
|
from pungi.compose_metadata.discinfo import read_discinfo, write_discinfo
|
|
from pungi.runroot import Runroot
|
|
|
|
from .. import createiso
|
|
|
|
|
|
class CreateisoPhase(PhaseLoggerMixin, PhaseBase):
|
|
name = "createiso"
|
|
|
|
def __init__(self, compose, buildinstall_phase):
|
|
super(CreateisoPhase, self).__init__(compose)
|
|
self.pool = ThreadPool(logger=self.logger)
|
|
self.bi = buildinstall_phase
|
|
|
|
def _find_rpms(self, path):
|
|
"""Check if there are some RPMs in the path."""
|
|
for _, _, files in os.walk(path):
|
|
for fn in files:
|
|
if fn.endswith(".rpm"):
|
|
return True
|
|
return False
|
|
|
|
def _is_bootable(self, variant, arch):
|
|
if arch == "src":
|
|
return False
|
|
if variant.type != "variant":
|
|
return False
|
|
skip = get_arch_variant_data(
|
|
self.compose.conf, "buildinstall_skip", arch, variant
|
|
)
|
|
if skip == [True]:
|
|
# Buildinstall is skipped for this tree. Can't create a bootable ISO.
|
|
return False
|
|
return bool(self.compose.conf.get("buildinstall_method", ""))
|
|
|
|
def _metadata_path(self, variant, arch, disc_num, disc_count):
|
|
return self.compose.paths.log.log_file(
|
|
arch,
|
|
"createiso-%s-%d-%d" % (variant.uid, disc_num, disc_count),
|
|
ext="json",
|
|
)
|
|
|
|
def save_reuse_metadata(self, cmd, variant, arch, opts):
|
|
"""Save metadata for future composes to verify if the compose can be reused."""
|
|
metadata = {
|
|
"cmd": cmd,
|
|
"opts": opts._asdict(),
|
|
}
|
|
|
|
metadata_path = self._metadata_path(
|
|
variant, arch, cmd["disc_num"], cmd["disc_count"]
|
|
)
|
|
with open(metadata_path, "w") as f:
|
|
json.dump(metadata, f, indent=2)
|
|
return metadata
|
|
|
|
def _load_old_metadata(self, cmd, variant, arch):
|
|
metadata_path = self._metadata_path(
|
|
variant, arch, cmd["disc_num"], cmd["disc_count"]
|
|
)
|
|
old_path = self.compose.paths.old_compose_path(metadata_path)
|
|
self.logger.info(
|
|
"Loading old metadata for %s.%s from: %s", variant, arch, old_path
|
|
)
|
|
try:
|
|
return read_json_file(old_path)
|
|
except Exception:
|
|
return None
|
|
|
|
def perform_reuse(self, cmd, variant, arch, opts, iso_path):
|
|
"""
|
|
Copy all related files from old compose to the new one. As a last step
|
|
add the new image to metadata.
|
|
"""
|
|
linker = OldFileLinker(self.logger)
|
|
old_file_name = os.path.basename(iso_path)
|
|
current_file_name = os.path.basename(cmd["iso_path"])
|
|
try:
|
|
# Hardlink ISO and manifest
|
|
for suffix in ("", ".manifest"):
|
|
linker.link(iso_path + suffix, cmd["iso_path"] + suffix)
|
|
# Copy log files
|
|
# The log file name includes filename of the image, so we need to
|
|
# find old file with the old name, and rename it to the new name.
|
|
log_file = self.compose.paths.log.log_file(
|
|
arch, "createiso-%s" % current_file_name
|
|
)
|
|
old_log_file = self.compose.paths.old_compose_path(
|
|
self.compose.paths.log.log_file(arch, "createiso-%s" % old_file_name)
|
|
)
|
|
linker.link(old_log_file, log_file)
|
|
# Copy jigdo files
|
|
if opts.jigdo_dir:
|
|
old_jigdo_dir = self.compose.paths.old_compose_path(opts.jigdo_dir)
|
|
for suffix in (".template", ".jigdo"):
|
|
linker.link(
|
|
os.path.join(old_jigdo_dir, old_file_name) + suffix,
|
|
os.path.join(opts.jigdo_dir, current_file_name) + suffix,
|
|
)
|
|
except Exception:
|
|
# A problem happened while linking some file, let's clean up
|
|
# everything.
|
|
linker.abort()
|
|
raise
|
|
# Add image to manifest
|
|
add_iso_to_metadata(
|
|
self.compose,
|
|
variant,
|
|
arch,
|
|
cmd["iso_path"],
|
|
bootable=cmd["bootable"],
|
|
disc_num=cmd["disc_num"],
|
|
disc_count=cmd["disc_count"],
|
|
)
|
|
|
|
def try_reuse(self, cmd, variant, arch, opts):
|
|
"""Try to reuse image from previous compose.
|
|
|
|
:returns bool: True if reuse was successful, False otherwise
|
|
"""
|
|
if not self.compose.conf["createiso_allow_reuse"]:
|
|
return
|
|
|
|
log_msg = "Cannot reuse ISO for %s.%s" % (variant, arch)
|
|
current_metadata = self.save_reuse_metadata(cmd, variant, arch, opts)
|
|
|
|
if opts.buildinstall_method and not self.bi.reused(variant, arch):
|
|
# If buildinstall phase was not reused for some reason, we can not
|
|
# reuse any bootable image. If a package change caused rebuild of
|
|
# boot.iso, we would catch it here too, but there could be a
|
|
# configuration change in lorax template which would remain
|
|
# undetected.
|
|
self.logger.info("%s - boot configuration changed", log_msg)
|
|
return False
|
|
|
|
# Check old compose configuration: extra_files and product_ids can be
|
|
# reflected on ISO.
|
|
old_config = self.compose.load_old_compose_config()
|
|
if not old_config:
|
|
self.logger.info("%s - no config for old compose", log_msg)
|
|
return False
|
|
# Convert current configuration to JSON and back to encode it similarly
|
|
# to the old one
|
|
config = json.loads(json.dumps(self.compose.conf))
|
|
for opt in self.compose.conf:
|
|
# Skip a selection of options: these affect what packages can be
|
|
# included, which we explicitly check later on.
|
|
config_whitelist = set(
|
|
[
|
|
"gather_lookaside_repos",
|
|
"pkgset_koji_builds",
|
|
"pkgset_koji_scratch_tasks",
|
|
"pkgset_koji_module_builds",
|
|
]
|
|
)
|
|
# Skip irrelevant options
|
|
config_whitelist.update(["osbs", "osbuild"])
|
|
if opt in config_whitelist:
|
|
continue
|
|
|
|
if old_config.get(opt) != config.get(opt):
|
|
self.logger.info("%s - option %s differs", log_msg, opt)
|
|
return False
|
|
|
|
old_metadata = self._load_old_metadata(cmd, variant, arch)
|
|
if not old_metadata:
|
|
self.logger.info("%s - no old metadata found", log_msg)
|
|
return False
|
|
|
|
# Test if volume ID matches - volid can be generated dynamically based on
|
|
# other values, and could change even if nothing else is different.
|
|
if current_metadata["opts"]["volid"] != old_metadata["opts"]["volid"]:
|
|
self.logger.info("%s - volume ID differs", log_msg)
|
|
return False
|
|
|
|
# Compare packages on the ISO.
|
|
if compare_packages(
|
|
old_metadata["opts"]["graft_points"],
|
|
current_metadata["opts"]["graft_points"],
|
|
):
|
|
self.logger.info("%s - packages differ", log_msg)
|
|
return False
|
|
|
|
try:
|
|
self.perform_reuse(
|
|
cmd,
|
|
variant,
|
|
arch,
|
|
opts,
|
|
old_metadata["cmd"]["iso_path"],
|
|
)
|
|
return True
|
|
except Exception as exc:
|
|
self.compose.log_error(
|
|
"Error while reusing ISO for %s.%s: %s", variant, arch, exc
|
|
)
|
|
self.compose.traceback("createiso-reuse-%s-%s" % (variant, arch))
|
|
return False
|
|
|
|
def run(self):
|
|
symlink_isos_to = self.compose.conf.get("symlink_isos_to")
|
|
disc_type = self.compose.conf["disc_types"].get("dvd", "dvd")
|
|
deliverables = []
|
|
|
|
commands = []
|
|
for variant in self.compose.get_variants(
|
|
types=["variant", "layered-product", "optional"]
|
|
):
|
|
if variant.is_empty:
|
|
continue
|
|
for arch in variant.arches + ["src"]:
|
|
skip_iso = get_arch_variant_data(
|
|
self.compose.conf, "createiso_skip", arch, variant
|
|
)
|
|
if skip_iso == [True]:
|
|
self.logger.info(
|
|
"Skipping createiso for %s.%s due to config option"
|
|
% (variant, arch)
|
|
)
|
|
continue
|
|
|
|
volid = get_volid(self.compose, arch, variant, disc_type=disc_type)
|
|
os_tree = self.compose.paths.compose.os_tree(arch, variant)
|
|
|
|
iso_dir = self.compose.paths.compose.iso_dir(
|
|
arch, variant, symlink_to=symlink_isos_to
|
|
)
|
|
if not iso_dir:
|
|
continue
|
|
|
|
if not self._find_rpms(os_tree):
|
|
self.logger.warning(
|
|
"No RPMs found for %s.%s, skipping ISO" % (variant.uid, arch)
|
|
)
|
|
continue
|
|
|
|
bootable = self._is_bootable(variant, arch)
|
|
|
|
if bootable and not self.bi.succeeded(variant, arch):
|
|
self.logger.warning(
|
|
"ISO should be bootable, but buildinstall failed. "
|
|
"Skipping for %s.%s" % (variant, arch)
|
|
)
|
|
continue
|
|
|
|
split_iso_data = split_iso(
|
|
self.compose, arch, variant, no_split=bootable, logger=self.logger
|
|
)
|
|
disc_count = len(split_iso_data)
|
|
|
|
for disc_num, iso_data in enumerate(split_iso_data):
|
|
disc_num += 1
|
|
|
|
filename = self.compose.get_image_name(
|
|
arch, variant, disc_type=disc_type, disc_num=disc_num
|
|
)
|
|
iso_path = self.compose.paths.compose.iso_path(
|
|
arch, variant, filename, symlink_to=symlink_isos_to
|
|
)
|
|
if os.path.isfile(iso_path):
|
|
self.logger.warning(
|
|
"Skipping mkisofs, image already exists: %s", iso_path
|
|
)
|
|
continue
|
|
deliverables.append(iso_path)
|
|
|
|
graft_points = prepare_iso(
|
|
self.compose,
|
|
arch,
|
|
variant,
|
|
disc_num=disc_num,
|
|
disc_count=disc_count,
|
|
split_iso_data=iso_data,
|
|
)
|
|
|
|
cmd = {
|
|
"iso_path": iso_path,
|
|
"bootable": bootable,
|
|
"cmd": [],
|
|
"label": "", # currently not used
|
|
"disc_num": disc_num,
|
|
"disc_count": disc_count,
|
|
}
|
|
|
|
if os.path.islink(iso_dir):
|
|
cmd["mount"] = os.path.abspath(
|
|
os.path.join(os.path.dirname(iso_dir), os.readlink(iso_dir))
|
|
)
|
|
|
|
opts = createiso.CreateIsoOpts(
|
|
output_dir=iso_dir,
|
|
iso_name=filename,
|
|
volid=volid,
|
|
graft_points=graft_points,
|
|
arch=arch,
|
|
supported=self.compose.supported,
|
|
hfs_compat=self.compose.conf["iso_hfs_ppc64le_compatible"],
|
|
use_xorrisofs=self.compose.conf.get("createiso_use_xorrisofs"),
|
|
iso_level=get_iso_level_config(self.compose, variant, arch),
|
|
)
|
|
|
|
if bootable:
|
|
opts = opts._replace(
|
|
buildinstall_method=self.compose.conf[
|
|
"buildinstall_method"
|
|
],
|
|
boot_iso=os.path.join(os_tree, "images", "boot.iso"),
|
|
)
|
|
|
|
if self.compose.conf["create_jigdo"]:
|
|
jigdo_dir = self.compose.paths.compose.jigdo_dir(arch, variant)
|
|
opts = opts._replace(jigdo_dir=jigdo_dir, os_tree=os_tree)
|
|
|
|
# Try to reuse
|
|
if self.try_reuse(cmd, variant, arch, opts):
|
|
# Reuse was successful, go to next ISO
|
|
continue
|
|
|
|
script_dir = self.compose.paths.work.tmp_dir(arch, variant)
|
|
opts = opts._replace(script_dir=script_dir)
|
|
script_file = os.path.join(script_dir, "createiso-%s.sh" % filename)
|
|
with open(script_file, "w") as f:
|
|
createiso.write_script(opts, f)
|
|
cmd["cmd"] = ["bash", script_file]
|
|
commands.append((cmd, variant, arch))
|
|
|
|
if self.compose.notifier:
|
|
self.compose.notifier.send("createiso-targets", deliverables=deliverables)
|
|
|
|
for (cmd, variant, arch) in commands:
|
|
self.pool.add(CreateIsoThread(self.pool))
|
|
self.pool.queue_put((self.compose, cmd, variant, arch))
|
|
|
|
self.pool.start()
|
|
|
|
|
|
def read_packages(graft_points):
|
|
"""Read packages that were listed in given graft points file.
|
|
|
|
Only files under Packages directory are considered. Particularly this
|
|
excludes .discinfo, .treeinfo and media.repo as well as repodata and
|
|
any extra files.
|
|
|
|
Extra files are easier to check by configuration (same name doesn't
|
|
imply same content). Repodata depend entirely on included packages (and
|
|
possibly product id certificate), but are affected by current time
|
|
which can change checksum despite data being the same.
|
|
"""
|
|
with open(graft_points) as f:
|
|
return set(
|
|
line.split("=", 1)[0]
|
|
for line in f
|
|
if line.startswith("Packages/") or "/Packages/" in line
|
|
)
|
|
|
|
|
|
def compare_packages(old_graft_points, new_graft_points):
|
|
"""Read packages from the two files and compare them.
|
|
|
|
:returns bool: True if there are differences, False otherwise
|
|
"""
|
|
old_files = read_packages(old_graft_points)
|
|
new_files = read_packages(new_graft_points)
|
|
return old_files != new_files
|
|
|
|
|
|
class CreateIsoThread(WorkerThread):
|
|
def fail(self, compose, cmd, variant, arch):
|
|
self.pool.log_error("CreateISO failed, removing ISO: %s" % cmd["iso_path"])
|
|
try:
|
|
# remove incomplete ISO
|
|
os.unlink(cmd["iso_path"])
|
|
# TODO: remove jigdo & template
|
|
except OSError:
|
|
pass
|
|
if compose.notifier:
|
|
compose.notifier.send(
|
|
"createiso-imagefail",
|
|
file=cmd["iso_path"],
|
|
arch=arch,
|
|
variant=str(variant),
|
|
)
|
|
|
|
def process(self, item, num):
|
|
compose, cmd, variant, arch = item
|
|
can_fail = compose.can_fail(variant, arch, "iso")
|
|
with failable(
|
|
compose, can_fail, variant, arch, "iso", logger=self.pool._logger
|
|
):
|
|
self.worker(compose, cmd, variant, arch, num)
|
|
|
|
def worker(self, compose, cmd, variant, arch, num):
|
|
mounts = [compose.topdir]
|
|
if "mount" in cmd:
|
|
mounts.append(cmd["mount"])
|
|
|
|
bootable = cmd["bootable"]
|
|
log_file = compose.paths.log.log_file(
|
|
arch, "createiso-%s" % os.path.basename(cmd["iso_path"])
|
|
)
|
|
|
|
msg = "Creating ISO (arch: %s, variant: %s): %s" % (
|
|
arch,
|
|
variant,
|
|
os.path.basename(cmd["iso_path"]),
|
|
)
|
|
self.pool.log_info("[BEGIN] %s" % msg)
|
|
|
|
try:
|
|
run_createiso_command(
|
|
num, compose, bootable, arch, cmd["cmd"], mounts, log_file
|
|
)
|
|
except Exception:
|
|
self.fail(compose, cmd, variant, arch)
|
|
raise
|
|
|
|
add_iso_to_metadata(
|
|
compose,
|
|
variant,
|
|
arch,
|
|
cmd["iso_path"],
|
|
cmd["bootable"],
|
|
cmd["disc_num"],
|
|
cmd["disc_count"],
|
|
)
|
|
|
|
# Delete staging directory if present.
|
|
staging_dir = compose.paths.work.iso_staging_dir(
|
|
arch, variant, filename=os.path.basename(cmd["iso_path"]), create_dir=False
|
|
)
|
|
if os.path.exists(staging_dir):
|
|
try:
|
|
shutil.rmtree(staging_dir)
|
|
except Exception as e:
|
|
self.pool.log_warning(
|
|
"Failed to clean up staging dir: %s %s" % (staging_dir, str(e))
|
|
)
|
|
|
|
self.pool.log_info("[DONE ] %s" % msg)
|
|
if compose.notifier:
|
|
compose.notifier.send(
|
|
"createiso-imagedone",
|
|
file=cmd["iso_path"],
|
|
arch=arch,
|
|
variant=str(variant),
|
|
)
|
|
|
|
|
|
def add_iso_to_metadata(
|
|
compose,
|
|
variant,
|
|
arch,
|
|
iso_path,
|
|
bootable,
|
|
disc_num=1,
|
|
disc_count=1,
|
|
additional_variants=None,
|
|
):
|
|
img = Image(compose.im)
|
|
img.path = iso_path.replace(compose.paths.compose.topdir(), "").lstrip("/")
|
|
img.mtime = get_mtime(iso_path)
|
|
img.size = get_file_size(iso_path)
|
|
img.arch = arch
|
|
# XXX: HARDCODED
|
|
img.type = "dvd"
|
|
img.format = "iso"
|
|
img.disc_number = disc_num
|
|
img.disc_count = disc_count
|
|
img.bootable = bootable
|
|
img.subvariant = variant.uid
|
|
img.implant_md5 = iso.get_implanted_md5(iso_path, logger=compose._logger)
|
|
if additional_variants:
|
|
img.unified = True
|
|
img.additional_variants = additional_variants
|
|
setattr(img, "can_fail", compose.can_fail(variant, arch, "iso"))
|
|
setattr(img, "deliverable", "iso")
|
|
try:
|
|
img.volume_id = iso.get_volume_id(iso_path)
|
|
except RuntimeError:
|
|
pass
|
|
if arch == "src":
|
|
for variant_arch in variant.arches:
|
|
compose.im.add(variant.uid, variant_arch, img)
|
|
else:
|
|
compose.im.add(variant.uid, arch, img)
|
|
return img
|
|
|
|
|
|
def run_createiso_command(num, compose, bootable, arch, cmd, mounts, log_file):
|
|
packages = [
|
|
"coreutils",
|
|
"xorriso" if compose.conf.get("createiso_use_xorrisofs") else "genisoimage",
|
|
"isomd5sum",
|
|
]
|
|
if compose.conf["create_jigdo"]:
|
|
packages.append("jigdo")
|
|
if bootable:
|
|
extra_packages = {
|
|
"lorax": ["lorax", "which"],
|
|
"buildinstall": ["anaconda"],
|
|
}
|
|
packages.extend(extra_packages[compose.conf["buildinstall_method"]])
|
|
|
|
runroot = Runroot(compose, phase="createiso")
|
|
|
|
build_arch = arch
|
|
if runroot.runroot_method == "koji" and not bootable:
|
|
runroot_tag = compose.conf["runroot_tag"]
|
|
koji_wrapper = kojiwrapper.KojiWrapper(compose)
|
|
koji_proxy = koji_wrapper.koji_proxy
|
|
tag_info = koji_proxy.getTag(runroot_tag)
|
|
if not tag_info:
|
|
raise RuntimeError('Tag "%s" does not exist.' % runroot_tag)
|
|
tag_arches = tag_info["arches"].split(" ")
|
|
|
|
if "x86_64" in tag_arches:
|
|
# assign non-bootable images to x86_64 if possible
|
|
build_arch = "x86_64"
|
|
elif build_arch == "src":
|
|
# pick random arch from available runroot tag arches
|
|
build_arch = random.choice(tag_arches)
|
|
|
|
runroot.run(
|
|
cmd,
|
|
log_file=log_file,
|
|
arch=build_arch,
|
|
packages=packages,
|
|
mounts=mounts,
|
|
weight=compose.conf["runroot_weights"].get("createiso"),
|
|
)
|
|
|
|
|
|
def split_iso(compose, arch, variant, no_split=False, logger=None):
|
|
"""
|
|
Split contents of the os/ directory for given tree into chunks fitting on ISO.
|
|
|
|
All files from the directory are taken except for possible boot.iso image.
|
|
Files added in extra_files phase are put on all disks.
|
|
|
|
If `no_split` is set, we will pretend that the media is practically
|
|
infinite so that everything goes on single disc. A warning is printed if
|
|
the size is bigger than configured.
|
|
"""
|
|
if not logger:
|
|
logger = compose._logger
|
|
media_size = compose.conf["iso_size"]
|
|
media_reserve = compose.conf["split_iso_reserve"]
|
|
split_size = convert_media_size(media_size) - convert_media_size(media_reserve)
|
|
real_size = None if no_split else split_size
|
|
|
|
ms = MediaSplitter(real_size, compose, logger=logger)
|
|
|
|
os_tree = compose.paths.compose.os_tree(arch, variant)
|
|
extra_files_dir = compose.paths.work.extra_files_dir(arch, variant)
|
|
|
|
# scan extra files to mark them "sticky" -> they'll be on all media after split
|
|
extra_files = set(["media.repo"])
|
|
for root, dirs, files in os.walk(extra_files_dir):
|
|
for fn in files:
|
|
path = os.path.join(root, fn)
|
|
rel_path = relative_path(path, extra_files_dir.rstrip("/") + "/")
|
|
extra_files.add(rel_path)
|
|
|
|
packages = []
|
|
all_files = []
|
|
all_files_ignore = []
|
|
|
|
ti = productmd.treeinfo.TreeInfo()
|
|
ti.load(os.path.join(os_tree, ".treeinfo"))
|
|
boot_iso_rpath = ti.images.images.get(arch, {}).get("boot.iso", None)
|
|
if boot_iso_rpath:
|
|
all_files_ignore.append(boot_iso_rpath)
|
|
if all_files_ignore:
|
|
logger.debug("split_iso all_files_ignore = %s" % ", ".join(all_files_ignore))
|
|
|
|
for root, dirs, files in os.walk(os_tree):
|
|
for dn in dirs[:]:
|
|
repo_dir = os.path.join(root, dn)
|
|
if repo_dir == os.path.join(
|
|
compose.paths.compose.repository(arch, variant), "repodata"
|
|
):
|
|
dirs.remove(dn)
|
|
|
|
for fn in files:
|
|
path = os.path.join(root, fn)
|
|
rel_path = relative_path(path, os_tree.rstrip("/") + "/")
|
|
sticky = rel_path in extra_files
|
|
if rel_path in all_files_ignore:
|
|
logger.info("split_iso: Skipping %s" % rel_path)
|
|
continue
|
|
if root.startswith(compose.paths.compose.packages(arch, variant)):
|
|
packages.append((path, os.path.getsize(path), sticky))
|
|
else:
|
|
all_files.append((path, os.path.getsize(path), sticky))
|
|
|
|
for path, size, sticky in all_files + packages:
|
|
ms.add_file(path, size, sticky)
|
|
|
|
logger.debug("Splitting media for %s.%s:" % (variant.uid, arch))
|
|
result = ms.split()
|
|
if no_split and result[0]["size"] > split_size:
|
|
logger.warning(
|
|
"ISO for %s.%s does not fit on single media! It is %s bytes too big. "
|
|
"(Total size: %s B)"
|
|
% (variant.uid, arch, result[0]["size"] - split_size, result[0]["size"])
|
|
)
|
|
return result
|
|
|
|
|
|
def prepare_iso(
|
|
compose, arch, variant, disc_num=1, disc_count=None, split_iso_data=None
|
|
):
|
|
tree_dir = compose.paths.compose.os_tree(arch, variant)
|
|
filename = compose.get_image_name(arch, variant, disc_num=disc_num)
|
|
iso_dir = compose.paths.work.iso_dir(arch, filename)
|
|
|
|
# modify treeinfo
|
|
ti_path = os.path.join(tree_dir, ".treeinfo")
|
|
ti = load_and_tweak_treeinfo(ti_path, disc_num, disc_count)
|
|
|
|
copy_boot_images(tree_dir, iso_dir)
|
|
|
|
if disc_count > 1:
|
|
# remove repodata/repomd.xml from checksums, create a new one later
|
|
if "repodata/repomd.xml" in ti.checksums.checksums:
|
|
del ti.checksums.checksums["repodata/repomd.xml"]
|
|
|
|
# rebuild repodata
|
|
createrepo_c = compose.conf["createrepo_c"]
|
|
createrepo_checksum = compose.conf["createrepo_checksum"]
|
|
repo = CreaterepoWrapper(createrepo_c=createrepo_c)
|
|
|
|
file_list = "%s-file-list" % iso_dir
|
|
packages_dir = compose.paths.compose.packages(arch, variant)
|
|
file_list_content = []
|
|
for i in split_iso_data["files"]:
|
|
if not i.endswith(".rpm"):
|
|
continue
|
|
if not i.startswith(packages_dir):
|
|
continue
|
|
rel_path = relative_path(i, tree_dir.rstrip("/") + "/")
|
|
file_list_content.append(rel_path)
|
|
|
|
if file_list_content:
|
|
# write modified repodata only if there are packages available
|
|
run("cp -a %s/repodata %s/" % (shlex_quote(tree_dir), shlex_quote(iso_dir)))
|
|
with open(file_list, "w") as f:
|
|
f.write("\n".join(file_list_content))
|
|
cmd = repo.get_createrepo_cmd(
|
|
tree_dir,
|
|
update=True,
|
|
database=True,
|
|
skip_stat=True,
|
|
pkglist=file_list,
|
|
outputdir=iso_dir,
|
|
workers=compose.conf["createrepo_num_workers"],
|
|
checksum=createrepo_checksum,
|
|
)
|
|
run(cmd)
|
|
# add repodata/repomd.xml back to checksums
|
|
ti.checksums.add(
|
|
"repodata/repomd.xml", createrepo_checksum, root_dir=iso_dir
|
|
)
|
|
|
|
new_ti_path = os.path.join(iso_dir, ".treeinfo")
|
|
ti.dump(new_ti_path)
|
|
|
|
# modify discinfo
|
|
di_path = os.path.join(tree_dir, ".discinfo")
|
|
data = read_discinfo(di_path)
|
|
data["disc_numbers"] = [disc_num]
|
|
new_di_path = os.path.join(iso_dir, ".discinfo")
|
|
write_discinfo(new_di_path, **data)
|
|
|
|
if not disc_count or disc_count == 1:
|
|
data = iso.get_graft_points(compose.paths.compose.topdir(), [tree_dir, iso_dir])
|
|
else:
|
|
data = iso.get_graft_points(
|
|
compose.paths.compose.topdir(),
|
|
[iso._paths_from_list(tree_dir, split_iso_data["files"]), iso_dir],
|
|
)
|
|
|
|
if compose.conf["createiso_break_hardlinks"]:
|
|
compose.log_debug(
|
|
"Breaking hardlinks for ISO %s for %s.%s" % (filename, variant, arch)
|
|
)
|
|
break_hardlinks(
|
|
data, compose.paths.work.iso_staging_dir(arch, variant, filename)
|
|
)
|
|
# Create hardlinks for files with duplicate contents.
|
|
compose.log_debug(
|
|
"Creating hardlinks for ISO %s for %s.%s" % (filename, variant, arch)
|
|
)
|
|
create_hardlinks(
|
|
compose.paths.work.iso_staging_dir(arch, variant, filename),
|
|
log_file=compose.paths.log.log_file(
|
|
arch, "iso-hardlink-%s.log" % variant.uid
|
|
),
|
|
)
|
|
|
|
# TODO: /content /graft-points
|
|
gp = "%s-graft-points" % iso_dir
|
|
iso.write_graft_points(gp, data, exclude=["*/lost+found", "*/boot.iso"])
|
|
return gp
|
|
|
|
|
|
def load_and_tweak_treeinfo(ti_path, disc_num=1, disc_count=1):
|
|
"""Treeinfo on the media should not contain any reference to boot.iso and
|
|
it should also have a valid [media] section.
|
|
"""
|
|
ti = productmd.treeinfo.TreeInfo()
|
|
ti.load(ti_path)
|
|
ti.media.totaldiscs = disc_count or 1
|
|
ti.media.discnum = disc_num
|
|
|
|
# remove boot.iso from all sections
|
|
paths = set()
|
|
for platform in ti.images.images:
|
|
if "boot.iso" in ti.images.images[platform]:
|
|
paths.add(ti.images.images[platform].pop("boot.iso"))
|
|
|
|
# remove boot.iso from checksums
|
|
for i in paths:
|
|
if i in ti.checksums.checksums.keys():
|
|
del ti.checksums.checksums[i]
|
|
|
|
return ti
|
|
|
|
|
|
def copy_boot_images(src, dest):
|
|
"""When mkisofs is called it tries to modify isolinux/isolinux.bin and
|
|
images/boot.img. Therefore we need to make copies of them.
|
|
"""
|
|
for i in ("isolinux/isolinux.bin", "images/boot.img"):
|
|
src_path = os.path.join(src, i)
|
|
dst_path = os.path.join(dest, i)
|
|
if os.path.exists(src_path):
|
|
makedirs(os.path.dirname(dst_path))
|
|
shutil.copy2(src_path, dst_path)
|
|
|
|
|
|
def break_hardlinks(graft_points, staging_dir):
|
|
"""Iterate over graft points and copy any file that has more than 1
|
|
hardlink into the staging directory. Replace the entry in the dict.
|
|
"""
|
|
for f in graft_points:
|
|
info = os.stat(graft_points[f])
|
|
if stat.S_ISREG(info.st_mode) and info.st_nlink > 1:
|
|
dest_path = os.path.join(staging_dir, graft_points[f].lstrip("/"))
|
|
makedirs(os.path.dirname(dest_path))
|
|
shutil.copy2(graft_points[f], dest_path)
|
|
graft_points[f] = dest_path
|
|
|
|
|
|
def create_hardlinks(staging_dir, log_file):
|
|
"""Create hardlinks within the staging directory.
|
|
Should happen after break_hardlinks()
|
|
"""
|
|
cmd = ["/usr/sbin/hardlink", "-c", "-vv", staging_dir]
|
|
run(cmd, logfile=log_file, show_cmd=True)
|
|
|
|
|
|
class OldFileLinker(object):
|
|
"""
|
|
A wrapper around os.link that remembers which files were linked and can
|
|
clean them up.
|
|
"""
|
|
|
|
def __init__(self, logger):
|
|
self.logger = logger
|
|
self.linked_files = []
|
|
|
|
def link(self, src, dst):
|
|
self.logger.debug("Hardlinking %s to %s", src, dst)
|
|
os.link(src, dst)
|
|
self.linked_files.append(dst)
|
|
|
|
def abort(self):
|
|
"""Clean up all files created by this instance."""
|
|
for f in self.linked_files:
|
|
os.unlink(f)
|
|
|
|
|
|
def get_iso_level_config(compose, variant, arch):
|
|
"""
|
|
Get configured ISO level for this variant and architecture.
|
|
"""
|
|
level = compose.conf.get("iso_level")
|
|
if isinstance(level, list):
|
|
level = None
|
|
for c in get_arch_variant_data(compose.conf, "iso_level", arch, variant):
|
|
level = c
|
|
return level
|