0b9077ceaa
This will make it possible to use sphinx-argparse to generate all the documentation and manual pages.
1399 lines
53 KiB
Python
Executable File
1399 lines
53 KiB
Python
Executable File
#!/usr/bin/python3
|
|
#
|
|
# Live Media Creator
|
|
#
|
|
# Copyright (C) 2011-2015 Red Hat, Inc.
|
|
#
|
|
# 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; either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# 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 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 <http://www.gnu.org/licenses/>.
|
|
#
|
|
# Author(s): Brian C. Lane <bcl@redhat.com>
|
|
#
|
|
import logging
|
|
log = logging.getLogger("livemedia-creator")
|
|
|
|
import os
|
|
import sys
|
|
import tempfile
|
|
import subprocess
|
|
import shutil
|
|
import hashlib
|
|
import glob
|
|
import json
|
|
from math import ceil
|
|
import socket
|
|
|
|
# Use pykickstart to calculate disk image size
|
|
from pykickstart.parser import KickstartParser
|
|
from pykickstart.version import makeVersion
|
|
from pykickstart.constants import KS_SHUTDOWN
|
|
|
|
# Use Mako templates for appliance builder descriptions
|
|
from mako.template import Template
|
|
from mako.exceptions import text_error_template
|
|
|
|
# Use the Lorax treebuilder branch for iso creation
|
|
from pylorax import ArchData, setup_logging, find_templates
|
|
from pylorax.base import DataHolder
|
|
from pylorax.treebuilder import TreeBuilder, RuntimeBuilder, udev_escape
|
|
from pylorax.treebuilder import findkernels
|
|
from pylorax.sysutils import joinpaths, remove
|
|
from pylorax.imgutils import PartitionMount, mksparse, mkext4img, loop_detach
|
|
from pylorax.imgutils import get_loop_name, dm_detach, mount, umount, Mount
|
|
from pylorax.imgutils import mksquashfs, mkqemu_img, mktar, mkrootfsimg
|
|
from pylorax.imgutils import copytree, mkcpio
|
|
from pylorax.executils import execWithRedirect, execReadlines, runcmd
|
|
from pylorax.monitor import LogMonitor
|
|
from pylorax.mount import IsoMountpoint
|
|
from pylorax.cmdline import lmc_parser
|
|
|
|
# Default parameters for rebuilding initramfs, override with --dracut-args
|
|
DRACUT_DEFAULT = ["--xz", "--add", "livenet dmsquash-live convertfs pollcdrom qemu qemu-net",
|
|
"--omit", "plymouth", "--no-hostonly", "--debug", "--no-early-microcode"]
|
|
|
|
ROOT_PATH = "/mnt/sysimage/"
|
|
RUNTIME = "images/install.img"
|
|
UEFI_FIRMWARE="loader={0}/OVMF_CODE.fd,loader_ro=yes,loader_type=pflash,nvram_template={0}/OVMF_VARS.fd"
|
|
|
|
|
|
class InstallError(Exception):
|
|
pass
|
|
|
|
|
|
class FakeDNF(object):
|
|
"""
|
|
A minimal DNF object suitable for passing to RuntimeBuilder
|
|
|
|
lmc uses RuntimeBuilder to run the arch specific iso creation
|
|
templates, so the the installroot config value is the important part of
|
|
this. Everything else should be a nop.
|
|
"""
|
|
def __init__(self, conf):
|
|
self.conf = conf
|
|
|
|
def reset(self):
|
|
pass
|
|
|
|
|
|
def find_free_port(start=5900, end=5999, host="127.0.0.1"):
|
|
""" Return first free port in range.
|
|
|
|
:param int start: Starting port number
|
|
:param int end: Ending port number
|
|
:param str host: Host IP to search
|
|
:returns: First free port or -1 if none found
|
|
:rtype: int
|
|
"""
|
|
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
|
for port in range(start, end+1):
|
|
try:
|
|
s.bind((host, port))
|
|
s.close()
|
|
return port
|
|
except OSError:
|
|
pass
|
|
|
|
return -1
|
|
|
|
|
|
def append_initrd(initrd, files):
|
|
""" Append files to an initrd.
|
|
|
|
:param str initrd: Path to initrd
|
|
:param list files: list of file paths to add
|
|
:returns: Path to a new initrd
|
|
:rtype: str
|
|
|
|
The files are added to the initrd by creating a cpio image
|
|
of the files (stored at /) and writing the cpio to the end of a
|
|
copy of the initrd.
|
|
|
|
The initrd is not changed, a copy is made before appending the
|
|
cpio archive.
|
|
"""
|
|
qemu_initrd = tempfile.mktemp(prefix="lmc-initrd-", suffix=".img")
|
|
shutil.copy2(initrd, qemu_initrd)
|
|
ks_dir = tempfile.mkdtemp(prefix="lmc-ksdir-")
|
|
for ks in files:
|
|
shutil.copy2(ks, ks_dir)
|
|
ks_initrd = tempfile.mktemp(prefix="lmc-ks-", suffix=".img")
|
|
mkcpio(ks_dir, ks_initrd)
|
|
shutil.rmtree(ks_dir)
|
|
with open(qemu_initrd, "ab") as initrd_fp:
|
|
with open(ks_initrd, "rb") as ks_fp:
|
|
while True:
|
|
data = ks_fp.read(1024**2)
|
|
if not data:
|
|
break
|
|
initrd_fp.write(data)
|
|
os.unlink(ks_initrd)
|
|
|
|
return qemu_initrd
|
|
|
|
|
|
class QEMUInstall(object):
|
|
"""
|
|
Run qemu using an iso and a kickstart
|
|
"""
|
|
# Mapping of arch to qemu command
|
|
QEMU_CMDS = {"x86_64": "qemu-system-x86_64",
|
|
"i386": "qemu-system-i386",
|
|
"arm": "qemu-system-arm",
|
|
"aarch64": "qemu-system-aarch64",
|
|
"ppc": "qemu-system-ppc",
|
|
"ppc64": "qemu-system-ppc64"
|
|
}
|
|
|
|
def __init__(self, opts, iso, ks_paths, disk_img, img_size=2048,
|
|
kernel_args=None, memory=1024, vcpus=None, vnc=None, arch=None,
|
|
log_check=None, virtio_host="127.0.0.1", virtio_port=6080,
|
|
image_type=None, boot_uefi=False, ovmf_path=None):
|
|
"""
|
|
Start the installation
|
|
|
|
:param iso: Information about the iso to use for the installation
|
|
:type iso: IsoMountpoint
|
|
:param list ks_paths: Paths to kickstart files. All are injected, the
|
|
first one is the one executed.
|
|
:param str disk_img: Path to a disk image, created it it doesn't exist
|
|
:param int img_size: The image size, in MiB, to create if it doesn't exist
|
|
:param str kernel_args: Extra kernel arguments to pass on the kernel cmdline
|
|
:param int memory: Amount of RAM to assign to the virt, in MiB
|
|
:param int vcpus: Number of virtual cpus
|
|
:param str vnc: Arguments to pass to qemu -display
|
|
:param str arch: Optional architecture to use in the virt
|
|
:param log_check: Method that returns True if the installation fails
|
|
:type log_check: method
|
|
:param str virtio_host: Hostname to connect virtio log to
|
|
:param int virtio_port: Port to connect virtio log to
|
|
:param str image_type: Type of qemu-img disk to create, or None.
|
|
:param bool boot_uefi: Use OVMF to boot the VM in UEFI mode
|
|
:param str ovmf_path: Path to the OVMF firmware
|
|
"""
|
|
# Lookup qemu-system- for arch if passed, or try to guess using host arch
|
|
qemu_cmd = [self.QEMU_CMDS.get(arch or os.uname().machine, "qemu-system-"+os.uname().machine)]
|
|
if not os.path.exists("/usr/bin/"+qemu_cmd[0]):
|
|
raise InstallError("%s does not exist, cannot run qemu" % qemu_cmd[0])
|
|
|
|
qemu_cmd += ["-nodefconfig"]
|
|
qemu_cmd += ["-m", str(memory)]
|
|
if vcpus:
|
|
qemu_cmd += ["-smp", str(vcpus)]
|
|
|
|
if not opts.no_kvm and os.path.exists("/dev/kvm"):
|
|
qemu_cmd += ["--machine", "accel=kvm"]
|
|
|
|
# Copy the initrd from the iso, create a cpio archive of the kickstart files
|
|
# and append it to the temporary initrd.
|
|
qemu_initrd = append_initrd(iso.initrd, ks_paths)
|
|
qemu_cmd += ["-kernel", iso.kernel]
|
|
qemu_cmd += ["-initrd", qemu_initrd]
|
|
|
|
# Add the disk and cdrom
|
|
if not os.path.isfile(disk_img):
|
|
mksparse(disk_img, img_size * 1024**2)
|
|
drive_args = "file=%s" % disk_img
|
|
drive_args += ",cache=unsafe,discard=unmap"
|
|
if image_type:
|
|
drive_args += ",format=%s" % image_type
|
|
else:
|
|
drive_args += ",format=raw"
|
|
qemu_cmd += ["-drive", drive_args]
|
|
|
|
drive_args = "file=%s,media=cdrom,readonly=on" % iso.iso_path
|
|
qemu_cmd += ["-drive", drive_args]
|
|
|
|
# Setup the cmdline args
|
|
# ======================
|
|
cmdline_args = "ks=file:/%s" % os.path.basename(ks_paths[0])
|
|
cmdline_args += " inst.stage2=hd:LABEL=%s" % udev_escape(iso.label)
|
|
if opts.proxy:
|
|
cmdline_args += " inst.proxy=%s" % opts.proxy
|
|
if kernel_args:
|
|
cmdline_args += " "+kernel_args
|
|
cmdline_args += " inst.text inst.cmdline"
|
|
|
|
qemu_cmd += ["-append", cmdline_args]
|
|
|
|
if not opts.vnc:
|
|
vnc_port = find_free_port()
|
|
if vnc_port == -1:
|
|
raise InstallError("No free VNC ports")
|
|
display_args = "vnc=127.0.0.1:%d" % (vnc_port - 5900)
|
|
else:
|
|
display_args = opts.vnc
|
|
log.info("qemu %s", display_args)
|
|
qemu_cmd += ["-nographic", "-display", display_args ]
|
|
|
|
# Setup the virtio log port
|
|
qemu_cmd += ["-device", "virtio-serial-pci,id=virtio-serial0"]
|
|
qemu_cmd += ["-device", "virtserialport,bus=virtio-serial0.0,nr=1,chardev=charchannel0"
|
|
",id=channel0,name=org.fedoraproject.anaconda.log.0"]
|
|
qemu_cmd += ["-chardev", "socket,id=charchannel0,host=%s,port=%s" % (virtio_host, virtio_port)]
|
|
|
|
# PAss through rng from host
|
|
qemu_cmd += ["-object", "rng-random,id=virtio-rng0,filename=/dev/random"]
|
|
qemu_cmd += ["-device", "virtio-rng-pci,rng=virtio-rng0,id=rng0,bus=pci.0,addr=0x9"]
|
|
|
|
if boot_uefi and ovmf_path:
|
|
qemu_cmd += ["-drive", "file=%s/OVMF_CODE.fd,if=pflash,format=raw,unit=0,readonly=on" % ovmf_path]
|
|
qemu_cmd += ["-drive", "file=%sOVMF_VARS.fd,if=pflash,format=raw,unit=1" % ovmf_path]
|
|
|
|
log.info("Running qemu")
|
|
log.debug(qemu_cmd)
|
|
try:
|
|
execWithRedirect(qemu_cmd[0], qemu_cmd[1:], reset_lang=False, raise_err=True,
|
|
callback=lambda p: not log_check())
|
|
except subprocess.CalledProcessError as e:
|
|
log.error("Running qemu failed:")
|
|
log.error("cmd: %s", " ".join(e.cmd))
|
|
log.error("output: %s", e.output or "")
|
|
raise InstallError("QEMUInstall failed")
|
|
except (OSError, KeyboardInterrupt) as e:
|
|
log.error("Running qemu failed: %s", str(e))
|
|
raise InstallError("QEMUInstall failed")
|
|
finally:
|
|
os.unlink(qemu_initrd)
|
|
|
|
if log_check():
|
|
log.error("Installation error detected. See logfile for details.")
|
|
raise InstallError("QEMUInstall failed")
|
|
else:
|
|
log.info("Installation finished without errors.")
|
|
|
|
|
|
def is_image_mounted(disk_img):
|
|
"""
|
|
Check to see if the disk_img is mounted
|
|
|
|
:returns: True if disk_img is in /proc/mounts
|
|
:rtype: bool
|
|
"""
|
|
with open("/proc/mounts") as mounts:
|
|
for mnt in mounts:
|
|
fields = mnt.split()
|
|
if len(fields) > 2 and fields[1] == disk_img:
|
|
return True
|
|
return False
|
|
|
|
def find_ostree_root(phys_root):
|
|
"""
|
|
Find root of ostree deployment
|
|
|
|
:param str phys_root: Path to physical root
|
|
:returns: Relative path of ostree deployment root
|
|
:rtype: str
|
|
:raise Exception: More than one deployment roots were found
|
|
"""
|
|
ostree_root = ""
|
|
ostree_sysroots = glob.glob(joinpaths(phys_root, "ostree/boot.0/*/*/0"))
|
|
if ostree_sysroots:
|
|
if len(ostree_sysroots) > 1:
|
|
raise Exception("Too many deployment roots found: %s" % ostree_sysroots)
|
|
ostree_root = os.path.relpath(ostree_sysroots[0], phys_root)
|
|
return ostree_root
|
|
|
|
def get_arch(mount_dir):
|
|
"""
|
|
Get the kernel arch
|
|
|
|
:returns: Arch of first kernel found at mount_dir/boot/ or i386
|
|
:rtype: str
|
|
"""
|
|
kernels = findkernels(mount_dir)
|
|
if not kernels:
|
|
return "i386"
|
|
return kernels[0].arch
|
|
|
|
|
|
def make_appliance(disk_img, name, template, outfile, networks=None, ram=1024,
|
|
vcpus=1, arch=None, title="Linux", project="Linux",
|
|
releasever="25"):
|
|
"""
|
|
Generate an appliance description file
|
|
|
|
:param str disk_img: Full path of the disk image
|
|
:param str name: Name of the appliance, passed to the template
|
|
:param str template: Full path of Mako template
|
|
:param str outfile: Full path of file to write, using template
|
|
:param list networks: List of networks(str) from the kickstart
|
|
:param int ram: Ram, in MiB, passed to template. Default is 1024
|
|
:param int vcpus: CPUs, passed to template. Default is 1
|
|
:param str arch: CPU architecture. Default is 'x86_64'
|
|
:param str title: Title, passed to template. Default is 'Linux'
|
|
:param str project: Project, passed to template. Default is 'Linux'
|
|
:param str releasever: Release version, passed to template. Default is 25
|
|
"""
|
|
if not (disk_img and template and outfile):
|
|
return None
|
|
|
|
log.info("Creating appliance definition using %s", template)
|
|
|
|
if not arch:
|
|
arch = "x86_64"
|
|
|
|
log.info("Calculating SHA256 checksum of %s", disk_img)
|
|
sha256 = hashlib.sha256()
|
|
with open(disk_img) as f:
|
|
while True:
|
|
data = f.read(1024**2)
|
|
if not data:
|
|
break
|
|
sha256.update(data)
|
|
log.info("SHA256 of %s is %s", disk_img, sha256.hexdigest())
|
|
disk_info = DataHolder(name=os.path.basename(disk_img), format="raw",
|
|
checksum_type="sha256", checksum=sha256.hexdigest())
|
|
try:
|
|
result = Template(filename=template).render(disks=[disk_info], name=name,
|
|
arch=arch, memory=ram, vcpus=vcpus, networks=networks,
|
|
title=title, project=project, releasever=releasever)
|
|
except Exception:
|
|
log.error(text_error_template().render())
|
|
raise
|
|
|
|
with open(outfile, "w") as f:
|
|
f.write(result)
|
|
|
|
|
|
def make_fsimage(diskimage, fsimage, img_size=None, label="Anaconda"):
|
|
"""
|
|
Copy the / partition of a partitioned disk image to an un-partitioned
|
|
disk image.
|
|
|
|
:param str diskimage: The full path to partitioned disk image with a /
|
|
:param str fsimage: The full path of the output fs image file
|
|
:param int img_size: Optional size of the fsimage in MiB or None to make
|
|
it as small as possible
|
|
:param str label: The label to apply to the image. Defaults to "Anaconda"
|
|
"""
|
|
with PartitionMount(diskimage) as img_mount:
|
|
if not img_mount or not img_mount.mount_dir:
|
|
return None
|
|
|
|
log.info("Creating fsimage %s (%s)", fsimage, img_size or "minimized")
|
|
if img_size:
|
|
# convert to Bytes
|
|
img_size *= 1024**2
|
|
|
|
mkext4img(img_mount.mount_dir, fsimage, size=img_size, label=label)
|
|
|
|
|
|
def make_runtime(opts, mount_dir, work_dir, size=None):
|
|
"""
|
|
Make the squashfs image from a directory
|
|
|
|
:param opts: options passed to livemedia-creator
|
|
:type opts: argparse options
|
|
:param str mount_dir: Directory tree to compress
|
|
:param str work_dir: Output compressed image to work_dir+images/install.img
|
|
:param int size: Size of disk image, in GiB
|
|
"""
|
|
kernel_arch = get_arch(mount_dir)
|
|
|
|
# Fake dnf object
|
|
fake_dbo = FakeDNF(conf=DataHolder(installroot=mount_dir))
|
|
# Fake arch with only basearch set
|
|
arch = ArchData(kernel_arch)
|
|
# TODO: Need to get release info from someplace...
|
|
product = DataHolder(name=opts.project, version=opts.releasever, release="",
|
|
variant="", bugurl="", isfinal=False)
|
|
|
|
# This is a mounted image partition, cannot hardlink to it, so just use it
|
|
# symlink mount_dir/images to work_dir/images so we don't run out of space
|
|
os.makedirs(joinpaths(work_dir, "images"))
|
|
|
|
rb = RuntimeBuilder(product, arch, fake_dbo)
|
|
log.info("Creating runtime")
|
|
rb.create_runtime(joinpaths(work_dir, RUNTIME), size=size)
|
|
|
|
def rebuild_initrds_for_live(opts, sys_root_dir, results_dir):
|
|
"""
|
|
Rebuild intrds for pxe live image (root=live:http://)
|
|
|
|
:param opts: options passed to livemedia-creator
|
|
:type opts: argparse options
|
|
:param str sys_root_dir: Path to root of the system
|
|
:param str results_dir: Path of directory for storing results
|
|
"""
|
|
if not opts.dracut_args:
|
|
dracut_args = DRACUT_DEFAULT
|
|
else:
|
|
dracut_args = []
|
|
for arg in opts.dracut_args:
|
|
dracut_args += arg.split(" ", 1)
|
|
log.info("dracut args = %s", dracut_args)
|
|
|
|
dracut = ["dracut", "--nomdadmconf", "--nolvmconf"] + dracut_args
|
|
|
|
kdir = "boot"
|
|
if opts.ostree:
|
|
kernels_dir = glob.glob(joinpaths(sys_root_dir, "boot/ostree/*"))[0]
|
|
kdir = os.path.relpath(kernels_dir, sys_root_dir)
|
|
|
|
kernels = [kernel for kernel in findkernels(sys_root_dir, kdir)
|
|
if hasattr(kernel, "initrd")]
|
|
if not kernels:
|
|
raise Exception("No initrds found, cannot rebuild_initrds")
|
|
|
|
# Hush some dracut warnings. TODO: bind-mount proc in place?
|
|
open(joinpaths(sys_root_dir,"/proc/modules"),"w")
|
|
|
|
if opts.ostree:
|
|
# Dracut assumes to have some dirs in disk image
|
|
# /var/tmp for temp files
|
|
vartmp_dir = joinpaths(sys_root_dir, "var/tmp")
|
|
if not os.path.isdir(vartmp_dir):
|
|
os.mkdir(vartmp_dir)
|
|
# /root (maybe not fatal)
|
|
root_dir = joinpaths(sys_root_dir, "var/roothome")
|
|
if not os.path.isdir(root_dir):
|
|
os.mkdir(root_dir)
|
|
# /tmp (maybe not fatal)
|
|
tmp_dir = joinpaths(sys_root_dir, "sysroot/tmp")
|
|
if not os.path.isdir(tmp_dir):
|
|
os.mkdir(tmp_dir)
|
|
|
|
for kernel in kernels:
|
|
outfile = kernel.initrd.path + ".live"
|
|
log.info("rebuilding %s", outfile)
|
|
|
|
kver = kernel.version
|
|
|
|
cmd = dracut + [outfile, kver]
|
|
runcmd(cmd, root=sys_root_dir)
|
|
|
|
new_initrd_path = joinpaths(results_dir, os.path.basename(kernel.initrd.path))
|
|
shutil.move(joinpaths(sys_root_dir, outfile), new_initrd_path)
|
|
os.chmod(new_initrd_path, 0o644)
|
|
shutil.copy2(joinpaths(sys_root_dir, kernel.path), results_dir)
|
|
|
|
os.unlink(joinpaths(sys_root_dir,"/proc/modules"))
|
|
|
|
def create_pxe_config(template, images_dir, live_image_name, add_args = None):
|
|
"""
|
|
Create template for pxe to live configuration
|
|
|
|
:param str images_dir: Path of directory with images to be used
|
|
:param str live_image_name: Name of live rootfs image file
|
|
:param list add_args: Arguments to be added to initrd= pxe config
|
|
"""
|
|
|
|
add_args = add_args or []
|
|
|
|
kernels = [kernel for kernel in findkernels(images_dir, kdir="")
|
|
if hasattr(kernel, "initrd")]
|
|
if not kernels:
|
|
return
|
|
|
|
kernel = kernels[0]
|
|
|
|
add_args_str = " ".join(add_args)
|
|
|
|
|
|
try:
|
|
result = Template(filename=template).render(kernel=kernel.path,
|
|
initrd=kernel.initrd.path, liveimg=live_image_name,
|
|
addargs=add_args_str)
|
|
except Exception:
|
|
log.error(text_error_template().render())
|
|
raise
|
|
|
|
with open (joinpaths(images_dir, "PXE_CONFIG"), "w") as f:
|
|
f.write(result)
|
|
|
|
|
|
def create_vagrant_metadata(path, size=0):
|
|
""" Create a default Vagrant metadata.json file
|
|
|
|
:param str path: Path to metadata.json file
|
|
:param int size: Disk size in MiB
|
|
"""
|
|
metadata = { "provider":"libvirt", "format":"qcow2", "virtual_size": ceil(size / 1024) }
|
|
with open(path, "wt") as f:
|
|
json.dump(metadata, f, indent=4)
|
|
|
|
|
|
def update_vagrant_metadata(path, size):
|
|
""" Update the Vagrant metadata.json file
|
|
|
|
:param str path: Path to metadata.json file
|
|
:param int size: Disk size in MiB
|
|
|
|
This function makes sure that the provider, format and virtual size of the
|
|
metadata file are set correctly. All other values are left untouched.
|
|
"""
|
|
with open(path, "rt") as f:
|
|
try:
|
|
metadata = json.load(f)
|
|
except ValueError as e:
|
|
log.error("Problem reading metadata file %s: %s", path, e)
|
|
return
|
|
|
|
metadata["provider"] = "libvirt"
|
|
metadata["format"] = "qcow2"
|
|
metadata["virtual_size"] = ceil(size / 1024)
|
|
with open(path, "wt") as f:
|
|
json.dump(metadata, f, indent=4)
|
|
|
|
|
|
def make_livecd(opts, mount_dir, work_dir):
|
|
"""
|
|
Take the content from the disk image and make a livecd out of it
|
|
|
|
:param opts: options passed to livemedia-creator
|
|
:type opts: argparse options
|
|
:param str mount_dir: Directory tree to compress
|
|
:param str work_dir: Output compressed image to work_dir+images/install.img
|
|
|
|
This uses wwood's squashfs live initramfs method:
|
|
* put the real / into LiveOS/rootfs.img
|
|
* make a squashfs of the LiveOS/rootfs.img tree
|
|
* This is loaded by dracut when the cmdline is passed to the kernel:
|
|
root=live:CDLABEL=<volid> rd.live.image
|
|
"""
|
|
kernel_arch = get_arch(mount_dir)
|
|
|
|
arch = ArchData(kernel_arch)
|
|
# TODO: Need to get release info from someplace...
|
|
product = DataHolder(name=opts.project, version=opts.releasever, release="",
|
|
variant="", bugurl="", isfinal=False)
|
|
|
|
# Link /images to work_dir/images to make the templates happy
|
|
if os.path.islink(joinpaths(mount_dir, "images")):
|
|
os.unlink(joinpaths(mount_dir, "images"))
|
|
execWithRedirect("/bin/ln", ["-s", joinpaths(work_dir, "images"),
|
|
joinpaths(mount_dir, "images")])
|
|
|
|
# The templates expect the config files to be in /tmp/config_files
|
|
# I think these should be release specific, not from lorax, but for now
|
|
configdir = joinpaths(opts.lorax_templates,"live/config_files/")
|
|
configdir_path = "tmp/config_files"
|
|
fullpath = joinpaths(mount_dir, configdir_path)
|
|
if os.path.exists(fullpath):
|
|
remove(fullpath)
|
|
copytree(configdir, fullpath)
|
|
|
|
isolabel = opts.volid or "{0.name}-{0.version}-{1.basearch}".format(product, arch)
|
|
if len(isolabel) > 32:
|
|
isolabel = isolabel[:32]
|
|
log.warning("Truncating isolabel to 32 chars: %s", isolabel)
|
|
|
|
tb = TreeBuilder(product=product, arch=arch, domacboot=opts.domacboot,
|
|
inroot=mount_dir, outroot=work_dir,
|
|
runtime=RUNTIME, isolabel=isolabel,
|
|
templatedir=joinpaths(opts.lorax_templates,"live/"))
|
|
log.info("Rebuilding initrds")
|
|
if not opts.dracut_args:
|
|
dracut_args = DRACUT_DEFAULT
|
|
else:
|
|
dracut_args = []
|
|
for arg in opts.dracut_args:
|
|
dracut_args += arg.split(" ", 1)
|
|
log.info("dracut args = %s", dracut_args)
|
|
tb.rebuild_initrds(add_args=dracut_args)
|
|
log.info("Building boot.iso")
|
|
tb.build()
|
|
|
|
return work_dir
|
|
|
|
def mount_boot_part_over_root(img_mount):
|
|
"""
|
|
Mount boot partition to /boot of root fs mounted in img_mount
|
|
|
|
Used for OSTree so it finds deployment configurations on live rootfs
|
|
|
|
param img_mount: object with mounted disk image root partition
|
|
type img_mount: imgutils.PartitionMount
|
|
"""
|
|
root_dir = img_mount.mount_dir
|
|
is_boot_part = lambda dir: os.path.exists(dir+"/loader.0")
|
|
tmp_mount_dir = tempfile.mkdtemp(prefix="lmc-tmpdir-")
|
|
sys_root = find_ostree_root(root_dir)
|
|
sysroot_boot_dir = None
|
|
for dev, _size in img_mount.loop_devices:
|
|
if dev is img_mount.mount_dev:
|
|
continue
|
|
try:
|
|
mount("/dev/mapper/"+dev, mnt=tmp_mount_dir)
|
|
if is_boot_part(tmp_mount_dir):
|
|
umount(tmp_mount_dir)
|
|
sysroot_boot_dir = joinpaths(joinpaths(root_dir, sys_root), "boot")
|
|
mount("/dev/mapper/"+dev, mnt=sysroot_boot_dir)
|
|
break
|
|
else:
|
|
umount(tmp_mount_dir)
|
|
except subprocess.CalledProcessError as e:
|
|
log.debug("Looking for boot partition error: %s", e)
|
|
remove(tmp_mount_dir)
|
|
return sysroot_boot_dir
|
|
|
|
def novirt_log_check(log_check, proc):
|
|
"""
|
|
Check to see if there has been an error in the logs
|
|
|
|
:param log_check: method to call to check for an error in the logs
|
|
:param proc: Popen object for the anaconda process
|
|
:returns: True if the process has been terminated
|
|
|
|
The log_check method should return a True if an error has been detected.
|
|
When an error is detected the process is terminated and this returns True
|
|
"""
|
|
if log_check():
|
|
proc.terminate()
|
|
return True
|
|
return False
|
|
|
|
|
|
def novirt_install(opts, disk_img, disk_size):
|
|
"""
|
|
Use Anaconda to install to a disk image
|
|
|
|
:param opts: options passed to livemedia-creator
|
|
:type opts: argparse options
|
|
:param str disk_img: The full path to the disk image to be created
|
|
:param int disk_size: The size of the disk_img in MiB
|
|
|
|
This method makes sure SELinux is permissive during the install, runs anaconda
|
|
to create the image and then based on the opts passed create a qemu disk image
|
|
or tarfile.
|
|
"""
|
|
import selinux
|
|
dirinstall_path = ROOT_PATH
|
|
|
|
# Set selinux to Permissive if it is Enforcing
|
|
selinux_enforcing = False
|
|
if selinux.is_selinux_enabled() and selinux.security_getenforce():
|
|
selinux_enforcing = True
|
|
selinux.security_setenforce(0)
|
|
|
|
# Clean up /tmp/ from previous runs to prevent stale info from being used
|
|
for path in ["/tmp/yum.repos.d/", "/tmp/yum.cache/"]:
|
|
if os.path.isdir(path):
|
|
shutil.rmtree(path)
|
|
|
|
args = ["--kickstart", opts.ks[0], "--cmdline"]
|
|
if opts.anaconda_args:
|
|
for arg in opts.anaconda_args:
|
|
args += arg.split(" ", 1)
|
|
if opts.proxy:
|
|
args += ["--proxy", opts.proxy]
|
|
if opts.armplatform:
|
|
args += ["--armplatform", opts.armplatform]
|
|
|
|
if opts.make_iso or opts.make_fsimage:
|
|
# Make a blank fs image
|
|
args += ["--dirinstall"]
|
|
|
|
mkext4img(None, disk_img, label=opts.fs_label, size=disk_size * 1024**2)
|
|
if not os.path.isdir(dirinstall_path):
|
|
os.mkdir(dirinstall_path)
|
|
mount(disk_img, opts="loop", mnt=dirinstall_path)
|
|
elif opts.make_tar or opts.make_oci:
|
|
# Install under dirinstall_path, make sure it starts clean
|
|
if os.path.exists(dirinstall_path):
|
|
shutil.rmtree(dirinstall_path)
|
|
|
|
if opts.make_oci:
|
|
# OCI installs under /rootfs/
|
|
dirinstall_path = joinpaths(dirinstall_path, "rootfs")
|
|
args += ["--dirinstall", dirinstall_path]
|
|
else:
|
|
args += ["--dirinstall"]
|
|
|
|
os.makedirs(dirinstall_path)
|
|
else:
|
|
args += ["--image", disk_img]
|
|
|
|
# Create the sparse image
|
|
mksparse(disk_img, disk_size * 1024**2)
|
|
|
|
log_monitor = LogMonitor(timeout=opts.timeout)
|
|
args += ["--remotelog", "%s:%s" % (log_monitor.host, log_monitor.port)]
|
|
|
|
# Make sure anaconda has the right product and release
|
|
log.info("Running anaconda.")
|
|
try:
|
|
for line in execReadlines("anaconda", args, reset_lang=False,
|
|
env_add={"ANACONDA_PRODUCTNAME": opts.project,
|
|
"ANACONDA_PRODUCTVERSION": opts.releasever},
|
|
callback=lambda p: not novirt_log_check(log_monitor.server.log_check, p)):
|
|
log.info(line)
|
|
|
|
# Make sure the new filesystem is correctly labeled
|
|
setfiles_args = ["-e", "/proc", "-e", "/sys", "-e", "/dev",
|
|
"/etc/selinux/targeted/contexts/files/file_contexts", "/"]
|
|
if "--dirinstall" in args:
|
|
execWithRedirect("setfiles", setfiles_args, root=dirinstall_path)
|
|
else:
|
|
with PartitionMount(disk_img) as img_mount:
|
|
if img_mount and img_mount.mount_dir:
|
|
execWithRedirect("setfiles", setfiles_args, root=img_mount.mount_dir)
|
|
except (subprocess.CalledProcessError, OSError) as e:
|
|
log.error("Running anaconda failed: %s", e)
|
|
raise InstallError("novirt_install failed")
|
|
finally:
|
|
log_monitor.shutdown()
|
|
|
|
# If anaconda failed there may be things needing cleanup
|
|
execWithRedirect("anaconda-cleanup", [])
|
|
|
|
# Move the anaconda logs over to a log directory
|
|
log_dir = os.path.abspath(os.path.dirname(opts.logfile))
|
|
log_anaconda = joinpaths(log_dir, "anaconda")
|
|
if not os.path.isdir(log_anaconda):
|
|
os.mkdir(log_anaconda)
|
|
for l in glob.glob("/tmp/*log")+glob.glob("/tmp/anaconda-tb-*"):
|
|
shutil.copy2(l, log_anaconda)
|
|
os.unlink(l)
|
|
|
|
if not opts.make_iso and not opts.make_fsimage:
|
|
dm_name = os.path.splitext(os.path.basename(disk_img))[0]
|
|
dm_path = "/dev/mapper/"+dm_name
|
|
if os.path.exists(dm_path):
|
|
dm_detach(dm_path)
|
|
loop_detach(get_loop_name(disk_img))
|
|
|
|
if selinux_enforcing:
|
|
selinux.security_setenforce(1)
|
|
|
|
# qemu disk image is used by bare qcow2 images and by Vagrant
|
|
if opts.image_type:
|
|
log.info("Converting %s to %s", disk_img, opts.image_type)
|
|
qemu_args = []
|
|
for arg in opts.qemu_args:
|
|
qemu_args += arg.split(" ", 1)
|
|
|
|
# convert the image to the selected format
|
|
if "-O" not in qemu_args:
|
|
qemu_args.extend(["-O", opts.image_type])
|
|
qemu_img = tempfile.mktemp(prefix="lmc-disk-", suffix=".img")
|
|
execWithRedirect("qemu-img", ["convert"] + qemu_args + [disk_img, qemu_img], raise_err=True)
|
|
if not opts.make_vagrant:
|
|
execWithRedirect("mv", ["-f", qemu_img, disk_img], raise_err=True)
|
|
else:
|
|
# Take the new qcow2 image and package it up for Vagrant
|
|
compress_args = []
|
|
for arg in opts.compress_args:
|
|
compress_args += arg.split(" ", 1)
|
|
|
|
vagrant_dir = tempfile.mkdtemp(prefix="lmc-tmpdir-")
|
|
metadata_path = joinpaths(vagrant_dir, "metadata.json")
|
|
execWithRedirect("mv", ["-f", qemu_img, joinpaths(vagrant_dir, "box.img")], raise_err=True)
|
|
if opts.vagrant_metadata:
|
|
shutil.copy2(opts.vagrant_metadata, metadata_path)
|
|
else:
|
|
create_vagrant_metadata(metadata_path)
|
|
update_vagrant_metadata(metadata_path, disk_size)
|
|
if opts.vagrantfile:
|
|
shutil.copy2(opts.vagrantfile, joinpaths(vagrant_dir, "vagrantfile"))
|
|
|
|
log.info("Creating Vagrant image")
|
|
rc = mktar(vagrant_dir, disk_img, opts.compression, compress_args, selinux=False)
|
|
if rc:
|
|
raise InstallError("novirt_install mktar failed: rc=%s" % rc)
|
|
shutil.rmtree(vagrant_dir)
|
|
elif opts.make_tar:
|
|
compress_args = []
|
|
for arg in opts.compress_args:
|
|
compress_args += arg.split(" ", 1)
|
|
|
|
rc = mktar(dirinstall_path, disk_img, opts.compression, compress_args)
|
|
shutil.rmtree(dirinstall_path)
|
|
|
|
if rc:
|
|
raise InstallError("novirt_install mktar failed: rc=%s" % rc)
|
|
elif opts.make_oci:
|
|
# An OCI image places the filesystem under /rootfs/ and adds the json files at the top
|
|
# And then creates a tar of the whole thing.
|
|
compress_args = []
|
|
for arg in opts.compress_args:
|
|
compress_args += arg.split(" ", 1)
|
|
|
|
shutil.copy2(opts.oci_config, ROOT_PATH)
|
|
shutil.copy2(opts.oci_runtime, ROOT_PATH)
|
|
rc = mktar(ROOT_PATH, disk_img, opts.compression, compress_args)
|
|
|
|
if rc:
|
|
raise InstallError("novirt_install mktar failed: rc=%s" % rc)
|
|
|
|
|
|
def virt_install(opts, install_log, disk_img, disk_size):
|
|
"""
|
|
Use qemu to install to a disk image
|
|
|
|
:param opts: options passed to livemedia-creator
|
|
:type opts: argparse options
|
|
:param str install_log: The path to write the log from qemu
|
|
:param str disk_img: The full path to the disk image to be created
|
|
:param int disk_size: The size of the disk_img in MiB
|
|
|
|
This uses qemu with a boot.iso and a kickstart to create a disk
|
|
image and then optionally, based on the opts passed, creates tarfile.
|
|
"""
|
|
iso_mount = IsoMountpoint(opts.iso, opts.location)
|
|
if not iso_mount.stage2:
|
|
iso_mount.umount()
|
|
raise InstallError("ISO is missing stage2, cannot continue")
|
|
|
|
log_monitor = LogMonitor(install_log, timeout=opts.timeout)
|
|
|
|
kernel_args = ""
|
|
if opts.kernel_args:
|
|
kernel_args += opts.kernel_args
|
|
if opts.proxy:
|
|
kernel_args += " proxy="+opts.proxy
|
|
|
|
if opts.image_type and not opts.make_fsimage:
|
|
qemu_args = []
|
|
for arg in opts.qemu_args:
|
|
qemu_args += arg.split(" ", 1)
|
|
if "-f" not in qemu_args:
|
|
qemu_args += ["-f", opts.image_type]
|
|
|
|
mkqemu_img(disk_img, disk_size*1024**2, qemu_args)
|
|
|
|
if opts.make_fsimage or opts.make_tar or opts.make_oci:
|
|
diskimg_path = tempfile.mktemp(prefix="lmc-disk-", suffix=".img")
|
|
else:
|
|
diskimg_path = disk_img
|
|
|
|
try:
|
|
QEMUInstall(opts, iso_mount, opts.ks, diskimg_path, disk_size,
|
|
kernel_args, opts.ram, opts.vcpus, opts.vnc, opts.arch,
|
|
log_check = log_monitor.server.log_check,
|
|
virtio_host = log_monitor.host,
|
|
virtio_port = log_monitor.port,
|
|
image_type=opts.image_type, boot_uefi=opts.virt_uefi,
|
|
ovmf_path=opts.ovmf_path)
|
|
log_monitor.shutdown()
|
|
except InstallError as e:
|
|
log.error("VirtualInstall failed: %s", e)
|
|
raise
|
|
finally:
|
|
log.info("unmounting the iso")
|
|
iso_mount.umount()
|
|
|
|
if log_monitor.server.log_check():
|
|
if not log_monitor.server.error_line and opts.timeout:
|
|
msg = "virt_install failed due to timeout"
|
|
else:
|
|
msg = "virt_install failed on line: %s" % log_monitor.server.error_line
|
|
raise InstallError(msg)
|
|
|
|
if opts.make_fsimage:
|
|
make_fsimage(diskimg_path, disk_img, disk_size, label=opts.fs_label)
|
|
os.unlink(diskimg_path)
|
|
elif opts.make_tar:
|
|
compress_args = []
|
|
for arg in opts.compress_args:
|
|
compress_args += arg.split(" ", 1)
|
|
|
|
with PartitionMount(diskimg_path) as img_mount:
|
|
if img_mount and img_mount.mount_dir:
|
|
rc = mktar(img_mount.mount_dir, disk_img, opts.compression, compress_args)
|
|
else:
|
|
rc = 1
|
|
os.unlink(diskimg_path)
|
|
|
|
if rc:
|
|
raise InstallError("virt_install failed")
|
|
elif opts.make_oci:
|
|
# An OCI image places the filesystem under /rootfs/ and adds the json files at the top
|
|
# And then creates a tar of the whole thing.
|
|
compress_args = []
|
|
for arg in opts.compress_args:
|
|
compress_args += arg.split(" ", 1)
|
|
|
|
with PartitionMount(diskimg_path, submount="rootfs") as img_mount:
|
|
if img_mount and img_mount.temp_dir:
|
|
shutil.copy2(opts.oci_config, img_mount.temp_dir)
|
|
shutil.copy2(opts.oci_runtime, img_mount.temp_dir)
|
|
rc = mktar(img_mount.temp_dir, disk_img, opts.compression, compress_args)
|
|
else:
|
|
rc = 1
|
|
os.unlink(diskimg_path)
|
|
|
|
if rc:
|
|
raise InstallError("virt_install failed")
|
|
elif opts.make_vagrant:
|
|
compress_args = []
|
|
for arg in opts.compress_args:
|
|
compress_args += arg.split(" ", 1)
|
|
|
|
vagrant_dir = tempfile.mkdtemp(prefix="lmc-tmpdir-")
|
|
metadata_path = joinpaths(vagrant_dir, "metadata.json")
|
|
execWithRedirect("mv", ["-f", disk_img, joinpaths(vagrant_dir, "box.img")], raise_err=True)
|
|
if opts.vagrant_metadata:
|
|
shutil.copy2(opts.vagrant_metadata, metadata_path)
|
|
else:
|
|
create_vagrant_metadata(metadata_path)
|
|
update_vagrant_metadata(metadata_path, disk_size)
|
|
if opts.vagrantfile:
|
|
shutil.copy2(opts.vagrantfile, joinpaths(vagrant_dir, "vagrantfile"))
|
|
|
|
rc = mktar(vagrant_dir, disk_img, opts.compression, compress_args, selinux=False)
|
|
if rc:
|
|
raise InstallError("virt_install failed")
|
|
shutil.rmtree(vagrant_dir)
|
|
|
|
|
|
def make_squashfs(disk_img, work_dir, compression="xz", compressargs=None):
|
|
"""
|
|
Create a squashfs image of an unpartitioned filesystem disk image
|
|
|
|
:param str disk_img: Path to the unpartitioned filesystem disk image
|
|
:param str work_dir: Output compressed image to work_dir+images/install.img
|
|
:param str compression: Compression type to use
|
|
:returns: True if squashfs creation was successful. False if there was an error.
|
|
:rtype: bool
|
|
|
|
Take disk_img and put it into LiveOS/rootfs.img and squashfs this
|
|
tree into work_dir+images/install.img
|
|
|
|
fsck.ext4 is run on the disk image to make sure there are no errors and to zero
|
|
out any deleted blocks to make it compress better. If this fails for any reason
|
|
it will return False and log the error.
|
|
"""
|
|
# Make sure free blocks are actually zeroed so it will compress
|
|
rc = execWithRedirect("/usr/sbin/fsck.ext4", ["-y", "-f", "-E", "discard", disk_img])
|
|
if rc != 0:
|
|
log.error("Problem zeroing free blocks of %s", disk_img)
|
|
return False
|
|
|
|
liveos_dir = joinpaths(work_dir, "runtime/LiveOS")
|
|
os.makedirs(liveos_dir)
|
|
os.makedirs(os.path.dirname(joinpaths(work_dir, RUNTIME)))
|
|
|
|
rc = execWithRedirect("/bin/ln", [disk_img, joinpaths(liveos_dir, "rootfs.img")])
|
|
if rc != 0:
|
|
shutil.copy2(disk_img, joinpaths(liveos_dir, "rootfs.img"))
|
|
|
|
mksquashfs(joinpaths(work_dir, "runtime"),
|
|
joinpaths(work_dir, RUNTIME), compression, compressargs)
|
|
remove(joinpaths(work_dir, "runtime"))
|
|
return True
|
|
|
|
def calculate_disk_size(opts, ks):
|
|
""" Calculate the disk size from the kickstart
|
|
|
|
:param opts: options passed to livemedia-creator
|
|
:type opts: argparse options
|
|
:param str ks: Path to the kickstart to use for the installation
|
|
:returns: Disk size in MiB
|
|
:rtype: int
|
|
"""
|
|
# Disk size for a filesystem image should only be the size of /
|
|
# to prevent surprises when using the same kickstart for different installations.
|
|
unique_partitions = dict((p.mountpoint, p) for p in ks.handler.partition.partitions)
|
|
if opts.no_virt and (opts.make_iso or opts.make_fsimage):
|
|
disk_size = 2 + sum(p.size for p in unique_partitions.values() if p.mountpoint == "/")
|
|
else:
|
|
disk_size = 2 + sum(p.size for p in unique_partitions.values())
|
|
log.info("Using disk size of %sMiB", disk_size)
|
|
return disk_size
|
|
|
|
def make_image(opts, ks):
|
|
"""
|
|
Install to a disk image
|
|
|
|
:param opts: options passed to livemedia-creator
|
|
:type opts: argparse options
|
|
:param str ks: Path to the kickstart to use for the installation
|
|
:returns: Path of the image created
|
|
:rtype: str
|
|
|
|
Use qemu+boot.iso or anaconda to install to a disk image.
|
|
"""
|
|
if opts.image_name:
|
|
disk_img = joinpaths(opts.result_dir, opts.image_name)
|
|
else:
|
|
disk_img = tempfile.mktemp(prefix="lmc-disk-", suffix=".img", dir=opts.result_dir)
|
|
log.info("disk_img = %s", disk_img)
|
|
disk_size = calculate_disk_size(opts, ks)
|
|
try:
|
|
if opts.no_virt:
|
|
novirt_install(opts, disk_img, disk_size)
|
|
else:
|
|
install_log = os.path.abspath(os.path.dirname(opts.logfile))+"/virt-install.log"
|
|
log.info("install_log = %s", install_log)
|
|
|
|
virt_install(opts, install_log, disk_img, disk_size)
|
|
except InstallError as e:
|
|
log.error("Install failed: %s", e)
|
|
if not opts.keep_image and os.path.exists(disk_img):
|
|
log.info("Removing bad disk image")
|
|
os.unlink(disk_img)
|
|
raise
|
|
|
|
log.info("Disk Image install successful")
|
|
return disk_img
|
|
|
|
|
|
def make_live_images(opts, work_dir, root_dir, rootfs_image=None, size=None):
|
|
"""
|
|
Create live images from direcory or rootfs image
|
|
|
|
:param opts: options passed to livemedia-creator
|
|
:type opts: argparse options
|
|
:param str work_dir: Directory for storing results
|
|
:param str root_dir: Root directory of live filesystem tree
|
|
:param str rootfs_image: Path to live rootfs image to be used
|
|
:returns: Path of directory with created images or None
|
|
:rtype: str
|
|
|
|
fsck.ext4 is run on the rootfs_image to make sure there are no errors and to zero
|
|
out any deleted blocks to make it compress better. If this fails for any reason
|
|
it will return None and log the error.
|
|
"""
|
|
sys_root = ""
|
|
if opts.ostree:
|
|
sys_root = find_ostree_root(root_dir)
|
|
|
|
squashfs_root_dir = joinpaths(work_dir, "squashfs_root")
|
|
liveos_dir = joinpaths(squashfs_root_dir, "LiveOS")
|
|
os.makedirs(liveos_dir)
|
|
|
|
if rootfs_image:
|
|
# Make sure free blocks are actually zeroed so it will compress
|
|
rc = execWithRedirect("/usr/sbin/fsck.ext4", ["-y", "-f", "-E", "discard", rootfs_image])
|
|
if rc != 0:
|
|
log.error("Problem zeroing free blocks of %s", rootfs_image)
|
|
return None
|
|
|
|
rc = execWithRedirect("/bin/ln", [rootfs_image, joinpaths(liveos_dir, "rootfs.img")])
|
|
if rc != 0:
|
|
shutil.copy2(rootfs_image, joinpaths(liveos_dir, "rootfs.img"))
|
|
else:
|
|
log.info("Creating live rootfs image")
|
|
mkrootfsimg(root_dir, joinpaths(liveos_dir, "rootfs.img"), "LiveOS", size=size, sysroot=sys_root)
|
|
|
|
log.info("Packing live rootfs image")
|
|
add_pxe_args = []
|
|
live_image_name = "live-rootfs.squashfs.img"
|
|
mksquashfs(squashfs_root_dir,
|
|
joinpaths(work_dir, live_image_name),
|
|
opts.compression,
|
|
opts.compress_args)
|
|
|
|
remove(squashfs_root_dir)
|
|
|
|
log.info("Rebuilding initramfs for live")
|
|
rebuild_initrds_for_live(opts, joinpaths(root_dir, sys_root), work_dir)
|
|
|
|
if opts.ostree:
|
|
add_pxe_args.append("ostree=/%s" % sys_root)
|
|
template = joinpaths(opts.lorax_templates, "pxe-live/pxe-config.tmpl")
|
|
create_pxe_config(template, work_dir, live_image_name, add_pxe_args)
|
|
|
|
return work_dir
|
|
|
|
|
|
def main():
|
|
parser = lmc_parser()
|
|
opts = parser.parse_args()
|
|
|
|
setup_logging(opts.logfile, log)
|
|
|
|
log.debug( opts )
|
|
|
|
# Find the lorax templates
|
|
opts.lorax_templates = find_templates(opts.lorax_templates or "/usr/share/lorax")
|
|
|
|
# Check for invalid combinations of options, print all the errors and exit.
|
|
errors = []
|
|
if not opts.disk_image and not opts.fs_image and not opts.ks:
|
|
errors.append("Image creation requires a kickstart file")
|
|
|
|
if opts.ks and not os.path.exists(opts.ks[0]):
|
|
errors.append("kickstart file (%s) is missing." % opts.ks[0])
|
|
|
|
if opts.make_iso and not os.path.exists(opts.lorax_templates):
|
|
errors.append("The lorax templates directory (%s) doesn't "
|
|
"exist." % opts.lorax_templates)
|
|
|
|
if opts.result_dir and os.path.exists(opts.result_dir):
|
|
errors.append("The results_dir (%s) should not exist, please delete or "
|
|
"move its contents" % opts.result_dir)
|
|
|
|
# Default to putting results under tmp
|
|
if not opts.result_dir:
|
|
opts.result_dir = opts.tmp
|
|
|
|
if opts.iso and not os.path.exists(opts.iso):
|
|
errors.append("The iso %s is missing." % opts.iso)
|
|
|
|
if opts.disk_image and not os.path.exists(opts.disk_image):
|
|
errors.append("The disk image %s is missing." % opts.disk_image)
|
|
|
|
if opts.fs_image and not os.path.exists(opts.fs_image):
|
|
errors.append("The filesystem image %s is missing." % opts.fs_image)
|
|
|
|
is_install = not (opts.disk_image or opts.fs_image)
|
|
if is_install and not opts.no_virt and not opts.iso:
|
|
errors.append("virt install needs an install iso.")
|
|
|
|
if opts.volid and len(opts.volid) > 32:
|
|
errors.append("the volume id cannot be longer than 32 characters")
|
|
|
|
if is_install and not opts.no_virt \
|
|
and not any(glob.glob("/usr/bin/qemu-system-*")):
|
|
errors.append("qemu needs to be installed.")
|
|
|
|
if is_install and opts.no_virt \
|
|
and not os.path.exists("/usr/sbin/anaconda"):
|
|
errors.append("no-virt requires anaconda to be installed.")
|
|
|
|
if opts.make_appliance and not opts.app_template:
|
|
opts.app_template = joinpaths(opts.lorax_templates,
|
|
"appliance/libvirt.tmpl")
|
|
|
|
if opts.make_appliance and not os.path.exists(opts.app_template):
|
|
errors.append("The appliance template (%s) doesn't "
|
|
"exist" % opts.app_template)
|
|
|
|
if opts.image_name and os.path.exists(joinpaths(opts.result_dir, opts.image_name)):
|
|
errors.append("The disk image to be created should not exist.")
|
|
|
|
# Vagrant creates a qcow2 inside a tar, turn on qcow2
|
|
if opts.make_vagrant:
|
|
opts.image_type = "qcow2"
|
|
|
|
# Alias --qcow2 to --image-type=qcow2
|
|
if opts.qcow2:
|
|
opts.image_type = "qcow2"
|
|
|
|
if opts.image_type and not os.path.exists("/usr/bin/qemu-img"):
|
|
errors.append("image-type requires the qemu-img utility to be installed." % opts.image_type)
|
|
|
|
if opts.image_type and opts.make_iso:
|
|
errors.append("image-type cannot be used to make a bootable iso.")
|
|
|
|
if opts.image_type and opts.make_fsimage:
|
|
errors.append("image-type cannot be used to make filesystem images.")
|
|
|
|
if opts.image_type and opts.make_tar:
|
|
errors.append("image-type cannot be used to make a tar.")
|
|
|
|
if opts.make_oci and not (opts.oci_config and opts.oci_runtime):
|
|
errors.append("--make-oci requires --oci-config and --oci-runtime")
|
|
|
|
if opts.make_oci and not os.path.exists(opts.oci_config):
|
|
errors.append("oci % file is missing" % opts.oci_config)
|
|
|
|
if opts.make_oci and not os.path.exists(opts.oci_runtime):
|
|
errors.append("oci % file is missing" % opts.oci_runtime)
|
|
|
|
if opts.make_vagrant and opts.vagrant_metadata and not os.path.exists(opts.vagrant_metadata):
|
|
errors.append("Vagrant metadata file %s is missing" % opts.vagrant_metadata)
|
|
|
|
if opts.virt_uefi and not os.path.isdir(opts.ovmf_path):
|
|
errors.append("The OVMF firmware is missing from %s" % opts.ovmf_path)
|
|
|
|
if os.getuid() != 0:
|
|
errors.append("You need to run this as root")
|
|
|
|
if errors:
|
|
list(log.error(e) for e in errors)
|
|
sys.exit(1)
|
|
|
|
if not os.path.exists(opts.result_dir):
|
|
os.makedirs(opts.result_dir)
|
|
|
|
# AMI image is just a fsimage with an AMI label
|
|
if opts.make_ami:
|
|
opts.make_fsimage = True
|
|
if not opts.image_name:
|
|
opts.image_name = "ami-root.img"
|
|
if opts.fs_label == "Anaconda":
|
|
opts.fs_label = "AMI"
|
|
elif opts.make_tar:
|
|
if not opts.image_name:
|
|
opts.image_name = "root.tar.xz"
|
|
if opts.compression == "xz" and not opts.compress_args:
|
|
opts.compress_args = ["-9"]
|
|
elif opts.make_oci:
|
|
if not opts.image_name:
|
|
opts.image_name = "bundle.tar.xz"
|
|
if opts.compression == "xz" and not opts.compress_args:
|
|
opts.compress_args = ["-9"]
|
|
elif opts.make_vagrant:
|
|
if not opts.image_name:
|
|
opts.image_name = "vagrant.tar.xz"
|
|
if opts.compression == "xz" and not opts.compress_args:
|
|
opts.compress_args = ["-9"]
|
|
|
|
if opts.app_file:
|
|
opts.app_file = joinpaths(opts.result_dir, opts.app_file)
|
|
|
|
if opts.make_ostree_live:
|
|
opts.make_pxe_live = True
|
|
opts.ostree = True
|
|
else:
|
|
opts.ostree = False
|
|
|
|
tempfile.tempdir = opts.tmp
|
|
disk_img = None
|
|
|
|
# Parse the kickstart
|
|
if opts.ks:
|
|
ks_version = makeVersion()
|
|
ks = KickstartParser(ks_version, errorsAreFatal=False, missingIncludeIsFatal=False)
|
|
ks.readKickstart(opts.ks[0])
|
|
|
|
# Make the disk or filesystem image
|
|
if not opts.disk_image and not opts.fs_image:
|
|
errors = []
|
|
if opts.no_virt and ks.handler.method.method not in ("url", "nfs"):
|
|
errors.append("Only url and nfs install methods are currently supported. Please "
|
|
"fix your kickstart file." )
|
|
|
|
if ks.handler.method.method in ("url", "nfs") and not ks.handler.network.seen:
|
|
errors.append("The kickstart must activate networking if "
|
|
"the url or nfs install method is used.")
|
|
|
|
if ks.handler.displaymode.displayMode is not None:
|
|
errors.append("The kickstart must not set a display mode (text, cmdline, "
|
|
"graphical), this will interfere with livemedia-creator.")
|
|
|
|
if opts.make_fsimage:
|
|
# Make sure the kickstart isn't using autopart and only has a / mountpoint
|
|
part_ok = not any(p for p in ks.handler.partition.partitions
|
|
if p.mountpoint not in ["/", "swap"])
|
|
if not part_ok or ks.handler.autopart.seen:
|
|
errors.append("Filesystem images must use a single / part, not autopart or "
|
|
"multiple partitions. swap is allowed but not used.")
|
|
|
|
if not opts.no_virt and ks.handler.reboot.action != KS_SHUTDOWN:
|
|
errors.append("The kickstart must include shutdown when using virt installation.")
|
|
|
|
if errors:
|
|
list(log.error(e) for e in errors)
|
|
sys.exit(1)
|
|
|
|
# Make the image. Output of this is either a partitioned disk image or a fsimage
|
|
try:
|
|
disk_img = make_image(opts, ks)
|
|
except InstallError as e:
|
|
log.error("ERROR: Image creation failed: %s", e)
|
|
sys.exit(1)
|
|
|
|
if not opts.image_only:
|
|
result_dir = None
|
|
if opts.make_iso:
|
|
work_dir = tempfile.mkdtemp(prefix="lmc-work-")
|
|
log.info("working dir is %s", work_dir)
|
|
|
|
if (opts.fs_image or opts.no_virt) and not opts.disk_image:
|
|
# Create iso from a filesystem image
|
|
disk_img = opts.fs_image or disk_img
|
|
|
|
compression = opts.compression or "xz"
|
|
if not opts.compress_args:
|
|
arch = ArchData(opts.arch or os.uname().machine)
|
|
if arch.bcj:
|
|
compressargs = ["-Xbcj", arch.bcj]
|
|
else:
|
|
log.info("no BCJ filter for arch %s", arch.basearch)
|
|
|
|
if not make_squashfs(disk_img, work_dir, compression, compressargs):
|
|
log.error("squashfs.img creation failed")
|
|
sys.exit(1)
|
|
|
|
with Mount(disk_img, opts="loop") as mount_dir:
|
|
result_dir = make_livecd(opts, mount_dir, work_dir)
|
|
else:
|
|
# Create iso from a partitioned disk image
|
|
disk_img = opts.disk_image or disk_img
|
|
with PartitionMount(disk_img) as img_mount:
|
|
if img_mount and img_mount.mount_dir:
|
|
make_runtime(opts, img_mount.mount_dir, work_dir, calculate_disk_size(opts, ks)/1024.0)
|
|
result_dir = make_livecd(opts, img_mount.mount_dir, work_dir)
|
|
|
|
# --iso-only removes the extra build artifacts, keeping only the boot.iso
|
|
if opts.iso_only and result_dir:
|
|
boot_iso = joinpaths(result_dir, "images/boot.iso")
|
|
if not os.path.exists(boot_iso):
|
|
log.error("%s is missing, skipping --iso-only.", boot_iso)
|
|
else:
|
|
iso_dir = tempfile.mkdtemp(prefix="lmc-result-")
|
|
dest_file = joinpaths(iso_dir, opts.iso_name or "boot.iso")
|
|
shutil.move(boot_iso, dest_file)
|
|
shutil.rmtree(result_dir)
|
|
result_dir = iso_dir
|
|
|
|
# cleanup the mess
|
|
# cleanup work_dir?
|
|
if disk_img and not (opts.keep_image or opts.disk_image or opts.fs_image):
|
|
os.unlink(disk_img)
|
|
log.info("Disk image erased")
|
|
disk_img = None
|
|
elif opts.make_appliance:
|
|
if not opts.ks:
|
|
networks = []
|
|
else:
|
|
networks = ks.handler.network.network
|
|
make_appliance(opts.disk_image or disk_img, opts.app_name,
|
|
opts.app_template, opts.app_file, networks, opts.ram,
|
|
opts.vcpus or 1, opts.arch, opts.title, opts.project, opts.releasever)
|
|
elif opts.make_pxe_live:
|
|
work_dir = tempfile.mkdtemp(prefix="lmc-work-")
|
|
log.info("working dir is %s", work_dir)
|
|
|
|
if opts.fs_image and not opts.disk_image:
|
|
# Create pxe live images from a filesystem image
|
|
disk_img = opts.fs_image or disk_img
|
|
with Mount(disk_img, opts="loop") as mnt_dir:
|
|
result_dir = make_live_images(opts, work_dir, mnt_dir, rootfs_image=disk_img)
|
|
else:
|
|
# Create pxe live images from a partitioned disk image
|
|
disk_img = opts.disk_image or disk_img
|
|
is_root_part = None
|
|
if opts.ostree:
|
|
is_root_part = lambda dir: os.path.exists(dir+"/ostree/deploy")
|
|
with PartitionMount(disk_img, mount_ok=is_root_part) as img_mount:
|
|
if img_mount and img_mount.mount_dir:
|
|
try:
|
|
mounted_sysroot_boot_dir = None
|
|
if opts.ostree:
|
|
mounted_sysroot_boot_dir = mount_boot_part_over_root(img_mount)
|
|
if opts.live_rootfs_keep_size:
|
|
size = img_mount.mount_size / 1024**3
|
|
else:
|
|
size = opts.live_rootfs_size or None
|
|
result_dir = make_live_images(opts, work_dir, img_mount.mount_dir, size=size)
|
|
finally:
|
|
if mounted_sysroot_boot_dir:
|
|
umount(mounted_sysroot_boot_dir)
|
|
if result_dir is None:
|
|
log.error("Creating live image failed.")
|
|
sys.exit(1)
|
|
|
|
if opts.result_dir != opts.tmp and result_dir:
|
|
copytree(result_dir, opts.result_dir, preserve=False)
|
|
shutil.rmtree(result_dir)
|
|
result_dir = None
|
|
|
|
log.info("SUMMARY")
|
|
log.info("-------")
|
|
log.info("Logs are in %s", os.path.abspath(os.path.dirname(opts.logfile)))
|
|
if disk_img:
|
|
log.info("Disk image is at %s", disk_img)
|
|
if opts.make_appliance:
|
|
log.info("Appliance description is in %s", opts.app_file)
|
|
log.info("Results are in %s", result_dir or opts.result_dir)
|
|
|
|
sys.exit( 0 )
|
|
|
|
if __name__ == '__main__':
|
|
main()
|