494 lines
14 KiB
Python
494 lines
14 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
|
|
from fnmatch import fnmatch
|
|
import contextlib
|
|
from six.moves import shlex_quote
|
|
|
|
from kobo.shortcuts import force_list, relative_path, run
|
|
from pungi import util
|
|
|
|
|
|
def get_boot_options(arch, createfrom, efi=True, hfs_compat=True):
|
|
"""Checks to see what we need as the -b option for mkisofs"""
|
|
|
|
if arch in ("arm", "armhfp"):
|
|
result = []
|
|
return result
|
|
|
|
if arch in ("aarch64",):
|
|
result = [
|
|
"-eltorito-alt-boot",
|
|
"-e",
|
|
"images/efiboot.img",
|
|
"-no-emul-boot",
|
|
]
|
|
return result
|
|
|
|
if arch in ("i386", "i686", "x86_64"):
|
|
result = [
|
|
"-b",
|
|
"isolinux/isolinux.bin",
|
|
"-c",
|
|
"isolinux/boot.cat",
|
|
"-no-emul-boot",
|
|
"-boot-load-size",
|
|
"4",
|
|
"-boot-info-table",
|
|
]
|
|
|
|
# EFI args
|
|
if arch == "x86_64":
|
|
result.extend(
|
|
["-eltorito-alt-boot", "-e", "images/efiboot.img", "-no-emul-boot"]
|
|
)
|
|
return result
|
|
|
|
if arch == "ia64":
|
|
result = [
|
|
"-b",
|
|
"images/boot.img",
|
|
"-no-emul-boot",
|
|
]
|
|
return result
|
|
|
|
if arch in ("ppc", "ppc64") or (arch == "ppc64le" and hfs_compat):
|
|
result = [
|
|
"-part",
|
|
"-hfs",
|
|
"-r",
|
|
"-l",
|
|
"-sysid",
|
|
"PPC",
|
|
"-no-desktop",
|
|
"-allow-multidot",
|
|
"-chrp-boot",
|
|
"-map",
|
|
os.path.join(createfrom, "mapping"), # -map %s/ppc/mapping
|
|
"-hfs-bless",
|
|
"/ppc/mac", # must be the last
|
|
]
|
|
return result
|
|
|
|
if arch == "ppc64le" and not hfs_compat:
|
|
result = [
|
|
"-r",
|
|
"-l",
|
|
"-sysid",
|
|
"PPC",
|
|
"-chrp-boot",
|
|
]
|
|
return result
|
|
|
|
if arch == "sparc":
|
|
result = [
|
|
"-G",
|
|
"/boot/isofs.b",
|
|
"-B",
|
|
"...",
|
|
"-s",
|
|
"/boot/silo.conf",
|
|
"-sparc-label",
|
|
'"sparc"',
|
|
]
|
|
return result
|
|
|
|
if arch in ("s390", "s390x"):
|
|
result = [
|
|
"-eltorito-boot",
|
|
"images/cdboot.img",
|
|
"-no-emul-boot",
|
|
]
|
|
return result
|
|
|
|
raise ValueError("Unknown arch: %s" % arch)
|
|
|
|
|
|
def _truncate_volid(volid):
|
|
if len(volid) > 32:
|
|
volid = volid.replace("-", "")
|
|
|
|
if len(volid) > 32:
|
|
volid = volid.replace(" ", "")
|
|
|
|
if len(volid) > 32:
|
|
volid = volid.replace("Supplementary", "Supp")
|
|
|
|
if len(volid) > 32:
|
|
raise ValueError("Volume ID must be less than 32 character: %s" % volid)
|
|
|
|
return volid
|
|
|
|
|
|
def get_mkisofs_cmd(
|
|
iso,
|
|
paths,
|
|
appid=None,
|
|
volid=None,
|
|
volset=None,
|
|
exclude=None,
|
|
verbose=False,
|
|
boot_args=None,
|
|
input_charset="utf-8",
|
|
graft_points=None,
|
|
):
|
|
# following options are always enabled
|
|
untranslated_filenames = True
|
|
translation_table = True
|
|
joliet = True
|
|
joliet_long = True
|
|
rock = True
|
|
|
|
cmd = ["/usr/bin/genisoimage"]
|
|
if appid:
|
|
cmd.extend(["-appid", appid])
|
|
|
|
if untranslated_filenames:
|
|
cmd.append("-untranslated-filenames")
|
|
|
|
if volid:
|
|
cmd.extend(["-volid", _truncate_volid(volid)])
|
|
|
|
if joliet:
|
|
cmd.append("-J")
|
|
|
|
if joliet_long:
|
|
cmd.append("-joliet-long")
|
|
|
|
if volset:
|
|
cmd.extend(["-volset", volset])
|
|
|
|
if rock:
|
|
cmd.append("-rational-rock")
|
|
|
|
if verbose:
|
|
cmd.append("-verbose")
|
|
|
|
if translation_table:
|
|
cmd.append("-translation-table")
|
|
|
|
if input_charset:
|
|
cmd.extend(["-input-charset", input_charset])
|
|
|
|
if exclude:
|
|
for i in force_list(exclude):
|
|
cmd.extend(["-x", i])
|
|
|
|
if boot_args:
|
|
cmd.extend(boot_args)
|
|
|
|
cmd.extend(["-o", iso])
|
|
|
|
if graft_points:
|
|
cmd.append("-graft-points")
|
|
cmd.extend(["-path-list", graft_points])
|
|
else:
|
|
# we're either using graft points or file lists, not both
|
|
cmd.extend(force_list(paths))
|
|
|
|
return cmd
|
|
|
|
|
|
def get_implantisomd5_cmd(iso_path, supported=False):
|
|
cmd = ["/usr/bin/implantisomd5"]
|
|
if supported:
|
|
cmd.append("--supported-iso")
|
|
cmd.append(iso_path)
|
|
return cmd
|
|
|
|
|
|
def get_checkisomd5_cmd(iso_path, just_print=False):
|
|
cmd = ["/usr/bin/checkisomd5"]
|
|
if just_print:
|
|
cmd.append("--md5sumonly")
|
|
cmd.append(iso_path)
|
|
return cmd
|
|
|
|
|
|
def get_checkisomd5_data(iso_path, logger=None):
|
|
cmd = get_checkisomd5_cmd(iso_path, just_print=True)
|
|
retcode, output = run(cmd, universal_newlines=True)
|
|
items = [line.strip().rsplit(":", 1) for line in output.splitlines()]
|
|
items = dict([(k, v.strip()) for k, v in items])
|
|
md5 = items.get(iso_path, "")
|
|
if len(md5) != 32:
|
|
# We have seen cases where the command finished successfully, but
|
|
# returned garbage value. We need to handle it, otherwise there would
|
|
# be a crash once we try to write image metadata.
|
|
# This only logs information about the problem and leaves the hash
|
|
# empty, which is valid from productmd point of view.
|
|
if logger:
|
|
logger.critical("Implanted MD5 in %s is not valid: %r", iso_path, md5)
|
|
logger.critical(
|
|
"Ran command %r; exit code %r; output %r", cmd, retcode, output
|
|
)
|
|
return None
|
|
return items
|
|
|
|
|
|
def get_implanted_md5(iso_path, logger=None):
|
|
return (get_checkisomd5_data(iso_path, logger=logger) or {}).get(iso_path)
|
|
|
|
|
|
def get_isohybrid_cmd(iso_path, arch):
|
|
# isohybrid is in syslinux which is x86 only
|
|
cmd = ["/usr/bin/isohybrid"]
|
|
# uefi is only supported on x86_64
|
|
if arch == "x86_64":
|
|
cmd.append("--uefi")
|
|
cmd.append(iso_path)
|
|
return cmd
|
|
|
|
|
|
def get_manifest_cmd(iso_name):
|
|
return "isoinfo -R -f -i %s | grep -v '/TRANS.TBL$' | sort >> %s.manifest" % (
|
|
shlex_quote(iso_name),
|
|
shlex_quote(iso_name),
|
|
)
|
|
|
|
|
|
def get_volume_id(path):
|
|
cmd = ["isoinfo", "-d", "-i", path]
|
|
retcode, output = run(cmd, universal_newlines=True)
|
|
|
|
for line in output.splitlines():
|
|
line = line.strip()
|
|
if line.startswith("Volume id:"):
|
|
return line[11:].strip()
|
|
|
|
raise RuntimeError("Could not read Volume ID")
|
|
|
|
|
|
def get_graft_points(compose, paths, exclusive_paths=None, exclude=None):
|
|
# path priority in ascending order (1st = lowest prio)
|
|
# paths merge according to priority
|
|
# exclusive paths override whole dirs
|
|
|
|
result = {}
|
|
exclude = exclude or []
|
|
exclusive_paths = exclusive_paths or []
|
|
|
|
for i in paths:
|
|
if isinstance(i, dict):
|
|
tree = i
|
|
else:
|
|
tree = _scan_tree(i)
|
|
result = _merge_trees(result, tree)
|
|
|
|
for i in exclusive_paths:
|
|
tree = _scan_tree(i)
|
|
result = _merge_trees(result, tree, exclusive=True)
|
|
|
|
# Resolve possible symlinks pointing outside of the compose.topdir.
|
|
# This fixes an issue if link_type is set to "symlink" and therefore
|
|
# the RPM packages are symbolic links to /mnt/koji filesystem.
|
|
# Without this, the symbolic links would be simply copied into the ISO
|
|
# without the real RPMs.
|
|
topdir = compose.paths.compose.topdir()
|
|
for key in result.keys():
|
|
path = result[key]
|
|
if os.path.islink(path):
|
|
real_path = os.readlink(path)
|
|
abspath = os.path.normpath(os.path.join(os.path.dirname(path), real_path))
|
|
if not abspath.startswith(topdir):
|
|
result[key] = abspath
|
|
|
|
# TODO: exclude
|
|
return result
|
|
|
|
|
|
def _paths_from_list(root, paths):
|
|
root = os.path.abspath(root).rstrip("/") + "/"
|
|
result = {}
|
|
for i in paths:
|
|
i = os.path.normpath(os.path.join(root, i))
|
|
key = i[len(root) :]
|
|
result[key] = i
|
|
return result
|
|
|
|
|
|
def _scan_tree(path):
|
|
path = os.path.abspath(path)
|
|
result = {}
|
|
for root, dirs, files in os.walk(path):
|
|
for f in files:
|
|
abspath = os.path.join(root, f)
|
|
relpath = relative_path(abspath, path.rstrip("/") + "/")
|
|
result[relpath] = abspath
|
|
|
|
# include empty dirs
|
|
if root != path:
|
|
abspath = os.path.join(root, "")
|
|
relpath = relative_path(abspath, path.rstrip("/") + "/")
|
|
result[relpath] = abspath
|
|
|
|
return result
|
|
|
|
|
|
def _merge_trees(tree1, tree2, exclusive=False):
|
|
# tree2 has higher priority
|
|
result = tree2.copy()
|
|
all_dirs = set(
|
|
[os.path.dirname(i).rstrip("/") for i in result if os.path.dirname(i) != ""]
|
|
)
|
|
|
|
for i in tree1:
|
|
dn = os.path.dirname(i)
|
|
if exclusive:
|
|
match = False
|
|
for a in all_dirs:
|
|
if dn == a or dn.startswith("%s/" % a):
|
|
match = True
|
|
break
|
|
if match:
|
|
continue
|
|
|
|
if i in result:
|
|
continue
|
|
|
|
result[i] = tree1[i]
|
|
return result
|
|
|
|
|
|
def write_graft_points(file_name, h, exclude=None):
|
|
exclude = exclude or []
|
|
result = {}
|
|
seen_dirs = set()
|
|
for i in sorted(h, reverse=True):
|
|
dn = os.path.dirname(i)
|
|
|
|
if not i.endswith("/"):
|
|
result[i] = h[i]
|
|
seen_dirs.add(dn)
|
|
continue
|
|
|
|
found = False
|
|
for j in seen_dirs:
|
|
if j.startswith(dn):
|
|
found = True
|
|
break
|
|
if not found:
|
|
result[i] = h[i]
|
|
seen_dirs.add(dn)
|
|
|
|
f = open(file_name, "w")
|
|
for i in sorted(result, key=graft_point_sort_key):
|
|
# make sure all files required for boot come first,
|
|
# otherwise there may be problems with booting (large LBA address, etc.)
|
|
found = False
|
|
for excl in exclude:
|
|
if fnmatch(i, excl):
|
|
found = True
|
|
break
|
|
if found:
|
|
continue
|
|
f.write("%s=%s\n" % (i, h[i]))
|
|
f.close()
|
|
|
|
|
|
def _is_rpm(path):
|
|
return path.endswith(".rpm")
|
|
|
|
|
|
def _is_image(path):
|
|
if path.startswith("images/"):
|
|
return True
|
|
if path.startswith("isolinux/"):
|
|
return True
|
|
if path.startswith("EFI/"):
|
|
return True
|
|
if path.startswith("etc/"):
|
|
return True
|
|
if path.startswith("ppc/"):
|
|
return True
|
|
if path.endswith(".img"):
|
|
return True
|
|
if path.endswith(".ins"):
|
|
return True
|
|
return False
|
|
|
|
|
|
def graft_point_sort_key(x):
|
|
"""
|
|
Images are sorted first, followed by other files. RPMs always come last.
|
|
In the same group paths are sorted alphabetically.
|
|
"""
|
|
return (0 if _is_image(x) else 2 if _is_rpm(x) else 1, x)
|
|
|
|
|
|
@contextlib.contextmanager
|
|
def mount(image, logger=None, use_guestmount=True):
|
|
"""Mount an image and make sure it's unmounted.
|
|
|
|
The yielded path will only be valid in the with block and is removed once
|
|
the image is unmounted.
|
|
"""
|
|
with util.temp_dir(prefix="iso-mount-") as mount_dir:
|
|
ret, __ = run(["which", "guestmount"], can_fail=True)
|
|
# return code 0 means that guestmount is available
|
|
guestmount_available = use_guestmount and not bool(ret)
|
|
if guestmount_available:
|
|
# use guestmount to mount the image, which doesn't require root privileges
|
|
# LIBGUESTFS_BACKEND=direct: running qemu directly without libvirt
|
|
env = {
|
|
"LIBGUESTFS_BACKEND": "direct",
|
|
"LIBGUESTFS_DEBUG": "1",
|
|
"LIBGUESTFS_TRACE": "1",
|
|
}
|
|
cmd = ["guestmount", "-a", image, "-m", "/dev/sda", mount_dir]
|
|
# guestmount caches files for faster mounting. However,
|
|
# systemd-tmpfiles is cleaning it up if the files have not been
|
|
# used in 30 days. It seems to be leaving an empty appliance.d
|
|
# directory in place, which is causing guestmount to fail because
|
|
# the files are missing and it only checks the directory.
|
|
#
|
|
# Thus we check if the directory is empty, and remove it in such
|
|
# case. There is still a possible race condition that the cleanup
|
|
# will happen between our check and libguestfs using the directory.
|
|
# The performance penalty for never reusing the cached files is too
|
|
# high given how unlikely the race condition is.
|
|
#
|
|
# https://bugzilla.redhat.com/show_bug.cgi?id=1771976
|
|
guestfs_tmp_dir = "/var/tmp/.guestfs-%d" % os.getuid()
|
|
try:
|
|
if not os.listdir(os.path.join(guestfs_tmp_dir, "appliance.d")):
|
|
if logger:
|
|
logger.info("Cleaning up %s", guestfs_tmp_dir)
|
|
util.rmtree(guestfs_tmp_dir)
|
|
except OSError:
|
|
# The directory is missing. That's fine for us too.
|
|
pass
|
|
else:
|
|
env = {}
|
|
cmd = ["mount", "-o", "loop", image, mount_dir]
|
|
ret, out = run(cmd, env=env, can_fail=True, universal_newlines=True)
|
|
if ret != 0:
|
|
# The mount command failed, something is wrong.
|
|
# Log the output and raise an exception.
|
|
if logger:
|
|
logger.error(
|
|
"Command %s exited with %s and output:\n%s" % (cmd, ret, out)
|
|
)
|
|
raise RuntimeError("Failed to mount %s" % image)
|
|
try:
|
|
yield mount_dir
|
|
finally:
|
|
if guestmount_available:
|
|
util.run_unmount_cmd(["fusermount", "-u", mount_dir], path=mount_dir)
|
|
else:
|
|
util.run_unmount_cmd(["umount", mount_dir], path=mount_dir)
|