From d73230306b827972cdc99f21d247c54d5d7c0b6d Mon Sep 17 00:00:00 2001 From: Tom Zanussi Date: Sun, 3 Aug 2014 12:14:16 -0500 Subject: wic: Remove mic chroot mic chroot allows users to chroot into an existing mic image and isn't used by wic, so remove it. Removing chroot.py leads in turn to various plugin-loading failures for a number of plugins that wic doesn't use either, so remove those as well. The existing source plugins refer to chroot but don't use it, so fix those up. Signed-off-by: Tom Zanussi --- scripts/lib/mic/chroot.py | 343 ----------- scripts/lib/mic/imager/fs.py | 99 --- scripts/lib/mic/imager/livecd.py | 750 ----------------------- scripts/lib/mic/imager/liveusb.py | 308 ---------- scripts/lib/mic/imager/loop.py | 418 ------------- scripts/lib/mic/imager/raw.py | 501 --------------- scripts/lib/mic/plugins/imager/direct_plugin.py | 2 +- scripts/lib/mic/plugins/imager/fs_plugin.py | 143 ----- scripts/lib/mic/plugins/imager/livecd_plugin.py | 255 -------- scripts/lib/mic/plugins/imager/liveusb_plugin.py | 260 -------- scripts/lib/mic/plugins/imager/loop_plugin.py | 255 -------- scripts/lib/mic/plugins/imager/raw_plugin.py | 275 --------- scripts/lib/mic/plugins/source/bootimg-efi.py | 2 +- scripts/lib/mic/plugins/source/bootimg-pcbios.py | 2 +- scripts/lib/mic/plugins/source/rootfs.py | 2 +- 15 files changed, 4 insertions(+), 3611 deletions(-) delete mode 100644 scripts/lib/mic/chroot.py delete mode 100644 scripts/lib/mic/imager/fs.py delete mode 100644 scripts/lib/mic/imager/livecd.py delete mode 100644 scripts/lib/mic/imager/liveusb.py delete mode 100644 scripts/lib/mic/imager/loop.py delete mode 100644 scripts/lib/mic/imager/raw.py delete mode 100644 scripts/lib/mic/plugins/imager/fs_plugin.py delete mode 100644 scripts/lib/mic/plugins/imager/livecd_plugin.py delete mode 100644 scripts/lib/mic/plugins/imager/liveusb_plugin.py delete mode 100644 scripts/lib/mic/plugins/imager/loop_plugin.py delete mode 100644 scripts/lib/mic/plugins/imager/raw_plugin.py (limited to 'scripts') diff --git a/scripts/lib/mic/chroot.py b/scripts/lib/mic/chroot.py deleted file mode 100644 index 99fb9a2c17..0000000000 --- a/scripts/lib/mic/chroot.py +++ /dev/null @@ -1,343 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2009, 2010, 2011 Intel, 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; 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 General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -from __future__ import with_statement -import os -import shutil -import subprocess - -from mic import msger -from mic.conf import configmgr -from mic.utils import misc, errors, runner, fs_related - -chroot_lockfd = -1 -chroot_lock = "" -BIND_MOUNTS = ( - "/proc", - "/proc/sys/fs/binfmt_misc", - "/sys", - "/dev", - "/dev/pts", - "/dev/shm", - "/var/lib/dbus", - "/var/run/dbus", - "/var/lock", - ) - -def cleanup_after_chroot(targettype,imgmount,tmpdir,tmpmnt): - if imgmount and targettype == "img": - imgmount.cleanup() - - if tmpdir: - shutil.rmtree(tmpdir, ignore_errors = True) - - if tmpmnt: - shutil.rmtree(tmpmnt, ignore_errors = True) - -def check_bind_mounts(chrootdir, bindmounts): - chrootmounts = [] - for mount in bindmounts.split(";"): - if not mount: - continue - - srcdst = mount.split(":") - if len(srcdst) == 1: - srcdst.append("none") - - if not os.path.isdir(srcdst[0]): - return False - - if srcdst[1] == "" or srcdst[1] == "none": - srcdst[1] = None - - if srcdst[0] in BIND_MOUNTS or srcdst[0] == '/': - continue - - if chrootdir: - if not srcdst[1]: - srcdst[1] = os.path.abspath(os.path.expanduser(srcdst[0])) - else: - srcdst[1] = os.path.abspath(os.path.expanduser(srcdst[1])) - - tmpdir = chrootdir + "/" + srcdst[1] - if os.path.isdir(tmpdir): - msger.warning("Warning: dir %s has existed." % tmpdir) - - return True - -def cleanup_mounts(chrootdir): - umountcmd = misc.find_binary_path("umount") - abs_chrootdir = os.path.abspath(chrootdir) - mounts = open('/proc/mounts').readlines() - for line in reversed(mounts): - if abs_chrootdir not in line: - continue - - point = line.split()[1] - - # '/' to avoid common name prefix - if abs_chrootdir == point or point.startswith(abs_chrootdir + '/'): - args = [ umountcmd, "-l", point ] - ret = runner.quiet(args) - if ret != 0: - msger.warning("failed to unmount %s" % point) - - return 0 - -def setup_chrootenv(chrootdir, bindmounts = None, mountparent = True): - global chroot_lockfd, chroot_lock - - def get_bind_mounts(chrootdir, bindmounts, mountparent = True): - chrootmounts = [] - if bindmounts in ("", None): - bindmounts = "" - - for mount in bindmounts.split(";"): - if not mount: - continue - - srcdst = mount.split(":") - srcdst[0] = os.path.abspath(os.path.expanduser(srcdst[0])) - if len(srcdst) == 1: - srcdst.append("none") - - # if some bindmount is not existed, but it's created inside - # chroot, this is not expected - if not os.path.exists(srcdst[0]): - os.makedirs(srcdst[0]) - - if not os.path.isdir(srcdst[0]): - continue - - if srcdst[0] in BIND_MOUNTS or srcdst[0] == '/': - msger.verbose("%s will be mounted by default." % srcdst[0]) - continue - - if srcdst[1] == "" or srcdst[1] == "none": - srcdst[1] = None - else: - srcdst[1] = os.path.abspath(os.path.expanduser(srcdst[1])) - if os.path.isdir(chrootdir + "/" + srcdst[1]): - msger.warning("%s has existed in %s , skip it."\ - % (srcdst[1], chrootdir)) - continue - - chrootmounts.append(fs_related.BindChrootMount(srcdst[0], - chrootdir, - srcdst[1])) - - """Default bind mounts""" - for pt in BIND_MOUNTS: - if not os.path.exists(pt): - continue - chrootmounts.append(fs_related.BindChrootMount(pt, - chrootdir, - None)) - - if mountparent: - chrootmounts.append(fs_related.BindChrootMount("/", - chrootdir, - "/parentroot", - "ro")) - - for kernel in os.listdir("/lib/modules"): - chrootmounts.append(fs_related.BindChrootMount( - "/lib/modules/"+kernel, - chrootdir, - None, - "ro")) - - return chrootmounts - - def bind_mount(chrootmounts): - for b in chrootmounts: - msger.verbose("bind_mount: %s -> %s" % (b.src, b.dest)) - b.mount() - - def setup_resolv(chrootdir): - try: - shutil.copyfile("/etc/resolv.conf", chrootdir + "/etc/resolv.conf") - except: - pass - - globalmounts = get_bind_mounts(chrootdir, bindmounts, mountparent) - bind_mount(globalmounts) - - setup_resolv(chrootdir) - - mtab = "/etc/mtab" - dstmtab = chrootdir + mtab - if not os.path.islink(dstmtab): - shutil.copyfile(mtab, dstmtab) - - chroot_lock = os.path.join(chrootdir, ".chroot.lock") - chroot_lockfd = open(chroot_lock, "w") - - return globalmounts - -def cleanup_chrootenv(chrootdir, bindmounts=None, globalmounts=()): - global chroot_lockfd, chroot_lock - - def bind_unmount(chrootmounts): - for b in reversed(chrootmounts): - msger.verbose("bind_unmount: %s -> %s" % (b.src, b.dest)) - b.unmount() - - def cleanup_resolv(chrootdir): - try: - fd = open(chrootdir + "/etc/resolv.conf", "w") - fd.truncate(0) - fd.close() - except: - pass - - def kill_processes(chrootdir): - import glob - for fp in glob.glob("/proc/*/root"): - try: - if os.readlink(fp) == chrootdir: - pid = int(fp.split("/")[2]) - os.kill(pid, 9) - except: - pass - - def cleanup_mountdir(chrootdir, bindmounts): - if bindmounts == "" or bindmounts == None: - return - chrootmounts = [] - for mount in bindmounts.split(";"): - if not mount: - continue - - srcdst = mount.split(":") - - if len(srcdst) == 1: - srcdst.append("none") - - if srcdst[0] == "/": - continue - - if srcdst[1] == "" or srcdst[1] == "none": - srcdst[1] = srcdst[0] - - srcdst[1] = os.path.abspath(os.path.expanduser(srcdst[1])) - tmpdir = chrootdir + "/" + srcdst[1] - if os.path.isdir(tmpdir): - if len(os.listdir(tmpdir)) == 0: - shutil.rmtree(tmpdir, ignore_errors = True) - else: - msger.warning("Warning: dir %s isn't empty." % tmpdir) - - chroot_lockfd.close() - bind_unmount(globalmounts) - - if not fs_related.my_fuser(chroot_lock): - tmpdir = chrootdir + "/parentroot" - if os.path.exists(tmpdir) and len(os.listdir(tmpdir)) == 0: - shutil.rmtree(tmpdir, ignore_errors = True) - - cleanup_resolv(chrootdir) - - if os.path.exists(chrootdir + "/etc/mtab"): - os.unlink(chrootdir + "/etc/mtab") - - kill_processes(chrootdir) - - cleanup_mountdir(chrootdir, bindmounts) - -def chroot(chrootdir, bindmounts = None, execute = "/bin/bash"): - def mychroot(): - os.chroot(chrootdir) - os.chdir("/") - - if configmgr.chroot['saveto']: - savefs = True - saveto = configmgr.chroot['saveto'] - wrnmsg = "Can't save chroot fs for dir %s exists" % saveto - if saveto == chrootdir: - savefs = False - wrnmsg = "Dir %s is being used to chroot" % saveto - elif os.path.exists(saveto): - if msger.ask("Dir %s already exists, cleanup and continue?" % - saveto): - shutil.rmtree(saveto, ignore_errors = True) - savefs = True - else: - savefs = False - - if savefs: - msger.info("Saving image to directory %s" % saveto) - fs_related.makedirs(os.path.dirname(os.path.abspath(saveto))) - runner.quiet("cp -af %s %s" % (chrootdir, saveto)) - devs = ['dev/fd', - 'dev/stdin', - 'dev/stdout', - 'dev/stderr', - 'etc/mtab'] - ignlst = [os.path.join(saveto, x) for x in devs] - map(os.unlink, filter(os.path.exists, ignlst)) - else: - msger.warning(wrnmsg) - - dev_null = os.open("/dev/null", os.O_WRONLY) - files_to_check = ["/bin/bash", "/sbin/init"] - - architecture_found = False - - """ Register statically-linked qemu-arm if it is an ARM fs """ - qemu_emulator = None - - for ftc in files_to_check: - ftc = "%s/%s" % (chrootdir,ftc) - - # Return code of 'file' is "almost always" 0 based on some man pages - # so we need to check the file existance first. - if not os.path.exists(ftc): - continue - - for line in runner.outs(['file', ftc]).splitlines(): - if 'ARM' in line: - qemu_emulator = misc.setup_qemu_emulator(chrootdir, "arm") - architecture_found = True - break - - if 'Intel' in line: - architecture_found = True - break - - if architecture_found: - break - - os.close(dev_null) - if not architecture_found: - raise errors.CreatorError("Failed to get architecture from any of the " - "following files %s from chroot." \ - % files_to_check) - - try: - msger.info("Launching shell. Exit to continue.\n" - "----------------------------------") - globalmounts = setup_chrootenv(chrootdir, bindmounts) - subprocess.call(execute, preexec_fn = mychroot, shell=True) - - except OSError, err: - raise errors.CreatorError("chroot err: %s" % str(err)) - - finally: - cleanup_chrootenv(chrootdir, bindmounts, globalmounts) - if qemu_emulator: - os.unlink(chrootdir + qemu_emulator) diff --git a/scripts/lib/mic/imager/fs.py b/scripts/lib/mic/imager/fs.py deleted file mode 100644 index d53b29cb47..0000000000 --- a/scripts/lib/mic/imager/fs.py +++ /dev/null @@ -1,99 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2011 Intel, 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; 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 General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os - -from mic import msger -from mic.utils import runner, misc -from mic.utils.errors import CreatorError -from mic.utils.fs_related import find_binary_path -from mic.imager.baseimager import BaseImageCreator - -class FsImageCreator(BaseImageCreator): - def __init__(self, cfgmgr = None, pkgmgr = None): - self.zips = { - "tar.bz2" : "" - } - BaseImageCreator.__init__(self, cfgmgr, pkgmgr) - self._fstype = None - self._fsopts = None - self._include_src = False - - def package(self, destdir = "."): - - ignores = ["/dev/fd", - "/dev/stdin", - "/dev/stdout", - "/dev/stderr", - "/etc/mtab"] - - if not os.path.exists(destdir): - os.makedirs(destdir) - - if self._recording_pkgs: - self._save_recording_pkgs(destdir) - - if not self.pack_to: - fsdir = os.path.join(destdir, self.name) - - misc.check_space_pre_cp(self._instroot, destdir) - msger.info("Copying %s to %s ..." % (self._instroot, fsdir)) - runner.show(['cp', "-af", self._instroot, fsdir]) - - for exclude in ignores: - if os.path.exists(fsdir + exclude): - os.unlink(fsdir + exclude) - - self.outimage.append(fsdir) - - else: - (tar, comp) = os.path.splitext(self.pack_to) - try: - tarcreat = {'.tar': '-cf', - '.gz': '-czf', - '.bz2': '-cjf', - '.tgz': '-czf', - '.tbz': '-cjf'}[comp] - except KeyError: - raise CreatorError("Unsupported comression for this image type:" - " '%s', try '.tar', '.tar.gz', etc" % comp) - - dst = os.path.join(destdir, self.pack_to) - msger.info("Pack rootfs to %s. Please wait..." % dst) - - tar = find_binary_path('tar') - tar_cmdline = [tar, "--numeric-owner", - "--preserve-permissions", - "--preserve-order", - "--one-file-system", - "--directory", - self._instroot] - for ignore_entry in ignores: - if ignore_entry.startswith('/'): - ignore_entry = ignore_entry[1:] - - tar_cmdline.append("--exclude=%s" % (ignore_entry)) - - tar_cmdline.extend([tarcreat, dst, "."]) - - rc = runner.show(tar_cmdline) - if rc: - raise CreatorError("Failed compress image with tar.bz2. " - "Cmdline: %s" % (" ".join(tar_cmdline))) - - self.outimage.append(dst) - diff --git a/scripts/lib/mic/imager/livecd.py b/scripts/lib/mic/imager/livecd.py deleted file mode 100644 index e36f4a76c6..0000000000 --- a/scripts/lib/mic/imager/livecd.py +++ /dev/null @@ -1,750 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2011 Intel, 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; 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 General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os, sys -import glob -import shutil - -from mic import kickstart, msger -from mic.utils import fs_related, runner, misc -from mic.utils.errors import CreatorError -from mic.imager.loop import LoopImageCreator - - -class LiveImageCreatorBase(LoopImageCreator): - """A base class for LiveCD image creators. - - This class serves as a base class for the architecture-specific LiveCD - image creator subclass, LiveImageCreator. - - LiveImageCreator creates a bootable ISO containing the system image, - bootloader, bootloader configuration, kernel and initramfs. - """ - - def __init__(self, creatoropts = None, pkgmgr = None): - """Initialise a LiveImageCreator instance. - - This method takes the same arguments as ImageCreator.__init__(). - """ - LoopImageCreator.__init__(self, creatoropts, pkgmgr) - - #Controls whether to use squashfs to compress the image. - self.skip_compression = False - - #Controls whether an image minimizing snapshot should be created. - # - #This snapshot can be used when copying the system image from the ISO in - #order to minimize the amount of data that needs to be copied; simply, - #it makes it possible to create a version of the image's filesystem with - #no spare space. - self.skip_minimize = False - - #A flag which indicates i act as a convertor default false - self.actasconvertor = False - - #The bootloader timeout from kickstart. - if self.ks: - self._timeout = kickstart.get_timeout(self.ks, 10) - else: - self._timeout = 10 - - #The default kernel type from kickstart. - if self.ks: - self._default_kernel = kickstart.get_default_kernel(self.ks, - "kernel") - else: - self._default_kernel = None - - if self.ks: - parts = kickstart.get_partitions(self.ks) - if len(parts) > 1: - raise CreatorError("Can't support multi partitions in ks file " - "for this image type") - # FIXME: rename rootfs img to self.name, - # else can't find files when create iso - self._instloops[0]['name'] = self.name + ".img" - - self.__isodir = None - - self.__modules = ["=ata", - "sym53c8xx", - "aic7xxx", - "=usb", - "=firewire", - "=mmc", - "=pcmcia", - "mptsas"] - if self.ks: - self.__modules.extend(kickstart.get_modules(self.ks)) - - self._dep_checks.extend(["isohybrid", - "unsquashfs", - "mksquashfs", - "dd", - "genisoimage"]) - - # - # Hooks for subclasses - # - def _configure_bootloader(self, isodir): - """Create the architecture specific booloader configuration. - - This is the hook where subclasses must create the booloader - configuration in order to allow a bootable ISO to be built. - - isodir -- the directory where the contents of the ISO are to - be staged - """ - raise CreatorError("Bootloader configuration is arch-specific, " - "but not implemented for this arch!") - def _get_menu_options(self): - """Return a menu options string for syslinux configuration. - """ - if self.ks is None: - return "liveinst autoinst" - r = kickstart.get_menu_args(self.ks) - return r - - def _get_kernel_options(self): - """Return a kernel options string for bootloader configuration. - - This is the hook where subclasses may specify a set of kernel - options which should be included in the images bootloader - configuration. - - A sensible default implementation is provided. - """ - - if self.ks is None: - r = "ro rd.live.image" - else: - r = kickstart.get_kernel_args(self.ks) - - return r - - def _get_mkisofs_options(self, isodir): - """Return the architecture specific mkisosfs options. - - This is the hook where subclasses may specify additional arguments - to mkisofs, e.g. to enable a bootable ISO to be built. - - By default, an empty list is returned. - """ - return [] - - # - # Helpers for subclasses - # - def _has_checkisomd5(self): - """Check whether checkisomd5 is available in the install root.""" - def _exists(path): - return os.path.exists(self._instroot + path) - - if _exists("/usr/bin/checkisomd5") and os.path.exists("/usr/bin/implantisomd5"): - return True - - return False - - def __restore_file(self,path): - try: - os.unlink(path) - except: - pass - if os.path.exists(path + '.rpmnew'): - os.rename(path + '.rpmnew', path) - - def _mount_instroot(self, base_on = None): - LoopImageCreator._mount_instroot(self, base_on) - self.__write_initrd_conf(self._instroot + "/etc/sysconfig/mkinitrd") - self.__write_dracut_conf(self._instroot + "/etc/dracut.conf.d/02livecd.conf") - - def _unmount_instroot(self): - self.__restore_file(self._instroot + "/etc/sysconfig/mkinitrd") - self.__restore_file(self._instroot + "/etc/dracut.conf.d/02livecd.conf") - LoopImageCreator._unmount_instroot(self) - - def __ensure_isodir(self): - if self.__isodir is None: - self.__isodir = self._mkdtemp("iso-") - return self.__isodir - - def _get_isodir(self): - return self.__ensure_isodir() - - def _set_isodir(self, isodir = None): - self.__isodir = isodir - - def _create_bootconfig(self): - """Configure the image so that it's bootable.""" - self._configure_bootloader(self.__ensure_isodir()) - - def _get_post_scripts_env(self, in_chroot): - env = LoopImageCreator._get_post_scripts_env(self, in_chroot) - - if not in_chroot: - env["LIVE_ROOT"] = self.__ensure_isodir() - - return env - def __write_dracut_conf(self, path): - if not os.path.exists(os.path.dirname(path)): - fs_related.makedirs(os.path.dirname(path)) - f = open(path, "a") - f.write('add_dracutmodules+=" dmsquash-live pollcdrom "') - f.close() - - def __write_initrd_conf(self, path): - content = "" - if not os.path.exists(os.path.dirname(path)): - fs_related.makedirs(os.path.dirname(path)) - f = open(path, "w") - - content += 'LIVEOS="yes"\n' - content += 'PROBE="no"\n' - content += 'MODULES+="squashfs ext3 ext2 vfat msdos "\n' - content += 'MODULES+="sr_mod sd_mod ide-cd cdrom "\n' - - for module in self.__modules: - if module == "=usb": - content += 'MODULES+="ehci_hcd uhci_hcd ohci_hcd "\n' - content += 'MODULES+="usb_storage usbhid "\n' - elif module == "=firewire": - content += 'MODULES+="firewire-sbp2 firewire-ohci "\n' - content += 'MODULES+="sbp2 ohci1394 ieee1394 "\n' - elif module == "=mmc": - content += 'MODULES+="mmc_block sdhci sdhci-pci "\n' - elif module == "=pcmcia": - content += 'MODULES+="pata_pcmcia "\n' - else: - content += 'MODULES+="' + module + ' "\n' - f.write(content) - f.close() - - def __create_iso(self, isodir): - iso = self._outdir + "/" + self.name + ".iso" - genisoimage = fs_related.find_binary_path("genisoimage") - args = [genisoimage, - "-J", "-r", - "-hide-rr-moved", "-hide-joliet-trans-tbl", - "-V", self.fslabel, - "-o", iso] - - args.extend(self._get_mkisofs_options(isodir)) - - args.append(isodir) - - if runner.show(args) != 0: - raise CreatorError("ISO creation failed!") - - """ It should be ok still even if you haven't isohybrid """ - isohybrid = None - try: - isohybrid = fs_related.find_binary_path("isohybrid") - except: - pass - - if isohybrid: - args = [isohybrid, "-partok", iso ] - if runner.show(args) != 0: - raise CreatorError("Hybrid ISO creation failed!") - - self.__implant_md5sum(iso) - - def __implant_md5sum(self, iso): - """Implant an isomd5sum.""" - if os.path.exists("/usr/bin/implantisomd5"): - implantisomd5 = "/usr/bin/implantisomd5" - else: - msger.warning("isomd5sum not installed; not setting up mediacheck") - implantisomd5 = "" - return - - runner.show([implantisomd5, iso]) - - def _stage_final_image(self): - try: - fs_related.makedirs(self.__ensure_isodir() + "/LiveOS") - - minimal_size = self._resparse() - - if not self.skip_minimize: - fs_related.create_image_minimizer(self.__isodir + \ - "/LiveOS/osmin.img", - self._image, - minimal_size) - - if self.skip_compression: - shutil.move(self._image, self.__isodir + "/LiveOS/ext3fs.img") - else: - fs_related.makedirs(os.path.join( - os.path.dirname(self._image), - "LiveOS")) - shutil.move(self._image, - os.path.join(os.path.dirname(self._image), - "LiveOS", "ext3fs.img")) - fs_related.mksquashfs(os.path.dirname(self._image), - self.__isodir + "/LiveOS/squashfs.img") - - self.__create_iso(self.__isodir) - - if self.pack_to: - isoimg = os.path.join(self._outdir, self.name + ".iso") - packimg = os.path.join(self._outdir, self.pack_to) - misc.packing(packimg, isoimg) - os.unlink(isoimg) - - finally: - shutil.rmtree(self.__isodir, ignore_errors = True) - self.__isodir = None - -class x86LiveImageCreator(LiveImageCreatorBase): - """ImageCreator for x86 machines""" - def _get_mkisofs_options(self, isodir): - return [ "-b", "isolinux/isolinux.bin", - "-c", "isolinux/boot.cat", - "-no-emul-boot", "-boot-info-table", - "-boot-load-size", "4" ] - - def _get_required_packages(self): - return ["syslinux", "syslinux-extlinux"] + \ - LiveImageCreatorBase._get_required_packages(self) - - def _get_isolinux_stanzas(self, isodir): - return "" - - def __find_syslinux_menu(self): - for menu in ["vesamenu.c32", "menu.c32"]: - if os.path.isfile(self._instroot + "/usr/share/syslinux/" + menu): - return menu - - raise CreatorError("syslinux not installed : " - "no suitable /usr/share/syslinux/*menu.c32 found") - - def __find_syslinux_mboot(self): - # - # We only need the mboot module if we have any xen hypervisors - # - if not glob.glob(self._instroot + "/boot/xen.gz*"): - return None - - return "mboot.c32" - - def __copy_syslinux_files(self, isodir, menu, mboot = None): - files = ["isolinux.bin", menu] - if mboot: - files += [mboot] - - for f in files: - path = self._instroot + "/usr/share/syslinux/" + f - - if not os.path.isfile(path): - raise CreatorError("syslinux not installed : " - "%s not found" % path) - - shutil.copy(path, isodir + "/isolinux/") - - def __copy_syslinux_background(self, isodest): - background_path = self._instroot + \ - "/usr/share/branding/default/syslinux/syslinux-vesa-splash.jpg" - - if not os.path.exists(background_path): - return False - - shutil.copyfile(background_path, isodest) - - return True - - def __copy_kernel_and_initramfs(self, isodir, version, index): - bootdir = self._instroot + "/boot" - isDracut = False - - if self._alt_initrd_name: - src_initrd_path = os.path.join(bootdir, self._alt_initrd_name) - else: - if os.path.exists(bootdir + "/initramfs-" + version + ".img"): - src_initrd_path = os.path.join(bootdir, "initramfs-" +version+ ".img") - isDracut = True - else: - src_initrd_path = os.path.join(bootdir, "initrd-" +version+ ".img") - - try: - msger.debug("copy %s to %s" % (bootdir + "/vmlinuz-" + version, isodir + "/isolinux/vmlinuz" + index)) - shutil.copyfile(bootdir + "/vmlinuz-" + version, - isodir + "/isolinux/vmlinuz" + index) - - msger.debug("copy %s to %s" % (src_initrd_path, isodir + "/isolinux/initrd" + index + ".img")) - shutil.copyfile(src_initrd_path, - isodir + "/isolinux/initrd" + index + ".img") - except: - raise CreatorError("Unable to copy valid kernels or initrds, " - "please check the repo.") - - is_xen = False - if os.path.exists(bootdir + "/xen.gz-" + version[:-3]): - shutil.copyfile(bootdir + "/xen.gz-" + version[:-3], - isodir + "/isolinux/xen" + index + ".gz") - is_xen = True - - return (is_xen,isDracut) - - def __is_default_kernel(self, kernel, kernels): - if len(kernels) == 1: - return True - - if kernel == self._default_kernel: - return True - - if kernel.startswith("kernel-") and kernel[7:] == self._default_kernel: - return True - - return False - - def __get_basic_syslinux_config(self, **args): - return """ -default %(menu)s -timeout %(timeout)d - -%(background)s -menu title Welcome to %(distroname)s! -menu color border 0 #ffffffff #00000000 -menu color sel 7 #ff000000 #ffffffff -menu color title 0 #ffffffff #00000000 -menu color tabmsg 0 #ffffffff #00000000 -menu color unsel 0 #ffffffff #00000000 -menu color hotsel 0 #ff000000 #ffffffff -menu color hotkey 7 #ffffffff #ff000000 -menu color timeout_msg 0 #ffffffff #00000000 -menu color timeout 0 #ffffffff #00000000 -menu color cmdline 0 #ffffffff #00000000 -menu hidden -menu clear -""" % args - - def __get_image_stanza(self, is_xen, isDracut, **args): - if isDracut: - args["rootlabel"] = "live:CDLABEL=%(fslabel)s" % args - else: - args["rootlabel"] = "CDLABEL=%(fslabel)s" % args - if not is_xen: - template = """label %(short)s - menu label %(long)s - kernel vmlinuz%(index)s - append initrd=initrd%(index)s.img root=%(rootlabel)s rootfstype=iso9660 %(liveargs)s %(extra)s -""" - else: - template = """label %(short)s - menu label %(long)s - kernel mboot.c32 - append xen%(index)s.gz --- vmlinuz%(index)s root=%(rootlabel)s rootfstype=iso9660 %(liveargs)s %(extra)s --- initrd%(index)s.img -""" - return template % args - - def __get_image_stanzas(self, isodir): - versions = [] - kernels = self._get_kernel_versions() - for kernel in kernels: - for version in kernels[kernel]: - versions.append(version) - - if not versions: - raise CreatorError("Unable to find valid kernels, " - "please check the repo") - - kernel_options = self._get_kernel_options() - - """ menu can be customized highly, the format is: - - short_name1:long_name1:extra_opts1;short_name2:long_name2:extra_opts2 - - e.g.: autoinst:InstallationOnly:systemd.unit=installer-graphical.service - but in order to keep compatible with old format, these are still ok: - - liveinst autoinst - liveinst;autoinst - liveinst::;autoinst:: - """ - oldmenus = {"basic": { - "short": "basic", - "long": "Installation Only (Text based)", - "extra": "basic nosplash 4" - }, - "liveinst": { - "short": "liveinst", - "long": "Installation Only", - "extra": "liveinst nosplash 4" - }, - "autoinst": { - "short": "autoinst", - "long": "Autoinstall (Deletes all existing content)", - "extra": "autoinst nosplash 4" - }, - "netinst": { - "short": "netinst", - "long": "Network Installation", - "extra": "netinst 4" - }, - "verify": { - "short": "check", - "long": "Verify and", - "extra": "check" - } - } - menu_options = self._get_menu_options() - menus = menu_options.split(";") - for i in range(len(menus)): - menus[i] = menus[i].split(":") - if len(menus) == 1 and len(menus[0]) == 1: - """ Keep compatible with the old usage way """ - menus = menu_options.split() - for i in range(len(menus)): - menus[i] = [menus[i]] - - cfg = "" - - default_version = None - default_index = None - index = "0" - netinst = None - for version in versions: - (is_xen, isDracut) = self.__copy_kernel_and_initramfs(isodir, version, index) - if index == "0": - self._isDracut = isDracut - - default = self.__is_default_kernel(kernel, kernels) - - if default: - long = "Boot %s" % self.distro_name - elif kernel.startswith("kernel-"): - long = "Boot %s(%s)" % (self.name, kernel[7:]) - else: - long = "Boot %s(%s)" % (self.name, kernel) - - oldmenus["verify"]["long"] = "%s %s" % (oldmenus["verify"]["long"], - long) - # tell dracut not to ask for LUKS passwords or activate mdraid sets - if isDracut: - kern_opts = kernel_options + " rd.luks=0 rd.md=0 rd.dm=0" - else: - kern_opts = kernel_options - - cfg += self.__get_image_stanza(is_xen, isDracut, - fslabel = self.fslabel, - liveargs = kern_opts, - long = long, - short = "linux" + index, - extra = "", - index = index) - - if default: - cfg += "menu default\n" - default_version = version - default_index = index - - for menu in menus: - if not menu[0]: - continue - short = menu[0] + index - - if len(menu) >= 2: - long = menu[1] - else: - if menu[0] in oldmenus.keys(): - if menu[0] == "verify" and not self._has_checkisomd5(): - continue - if menu[0] == "netinst": - netinst = oldmenus[menu[0]] - continue - long = oldmenus[menu[0]]["long"] - extra = oldmenus[menu[0]]["extra"] - else: - long = short.upper() + " X" + index - extra = "" - - if len(menu) >= 3: - extra = menu[2] - - cfg += self.__get_image_stanza(is_xen, isDracut, - fslabel = self.fslabel, - liveargs = kernel_options, - long = long, - short = short, - extra = extra, - index = index) - - index = str(int(index) + 1) - - if not default_version: - default_version = versions[0] - if not default_index: - default_index = "0" - - if netinst: - cfg += self.__get_image_stanza(is_xen, isDracut, - fslabel = self.fslabel, - liveargs = kernel_options, - long = netinst["long"], - short = netinst["short"], - extra = netinst["extra"], - index = default_index) - - return cfg - - def __get_memtest_stanza(self, isodir): - memtest = glob.glob(self._instroot + "/boot/memtest86*") - if not memtest: - return "" - - shutil.copyfile(memtest[0], isodir + "/isolinux/memtest") - - return """label memtest - menu label Memory Test - kernel memtest -""" - - def __get_local_stanza(self, isodir): - return """label local - menu label Boot from local drive - localboot 0xffff -""" - - def _configure_syslinux_bootloader(self, isodir): - """configure the boot loader""" - fs_related.makedirs(isodir + "/isolinux") - - menu = self.__find_syslinux_menu() - - self.__copy_syslinux_files(isodir, menu, - self.__find_syslinux_mboot()) - - background = "" - if self.__copy_syslinux_background(isodir + "/isolinux/splash.jpg"): - background = "menu background splash.jpg" - - cfg = self.__get_basic_syslinux_config(menu = menu, - background = background, - name = self.name, - timeout = self._timeout * 10, - distroname = self.distro_name) - - cfg += self.__get_image_stanzas(isodir) - cfg += self.__get_memtest_stanza(isodir) - cfg += self.__get_local_stanza(isodir) - cfg += self._get_isolinux_stanzas(isodir) - - cfgf = open(isodir + "/isolinux/isolinux.cfg", "w") - cfgf.write(cfg) - cfgf.close() - - def __copy_efi_files(self, isodir): - if not os.path.exists(self._instroot + "/boot/efi/EFI/redhat/grub.efi"): - return False - shutil.copy(self._instroot + "/boot/efi/EFI/redhat/grub.efi", - isodir + "/EFI/boot/grub.efi") - shutil.copy(self._instroot + "/boot/grub/splash.xpm.gz", - isodir + "/EFI/boot/splash.xpm.gz") - - return True - - def __get_basic_efi_config(self, **args): - return """ -default=0 -splashimage=/EFI/boot/splash.xpm.gz -timeout %(timeout)d -hiddenmenu - -""" %args - - def __get_efi_image_stanza(self, **args): - return """title %(long)s - kernel /EFI/boot/vmlinuz%(index)s root=CDLABEL=%(fslabel)s rootfstype=iso9660 %(liveargs)s %(extra)s - initrd /EFI/boot/initrd%(index)s.img -""" %args - - def __get_efi_image_stanzas(self, isodir, name): - # FIXME: this only supports one kernel right now... - - kernel_options = self._get_kernel_options() - checkisomd5 = self._has_checkisomd5() - - cfg = "" - - for index in range(0, 9): - # we don't support xen kernels - if os.path.exists("%s/EFI/boot/xen%d.gz" %(isodir, index)): - continue - cfg += self.__get_efi_image_stanza(fslabel = self.fslabel, - liveargs = kernel_options, - long = name, - extra = "", index = index) - if checkisomd5: - cfg += self.__get_efi_image_stanza( - fslabel = self.fslabel, - liveargs = kernel_options, - long = "Verify and Boot " + name, - extra = "check", - index = index) - break - - return cfg - - def _configure_efi_bootloader(self, isodir): - """Set up the configuration for an EFI bootloader""" - fs_related.makedirs(isodir + "/EFI/boot") - - if not self.__copy_efi_files(isodir): - shutil.rmtree(isodir + "/EFI") - return - - for f in os.listdir(isodir + "/isolinux"): - os.link("%s/isolinux/%s" %(isodir, f), - "%s/EFI/boot/%s" %(isodir, f)) - - - cfg = self.__get_basic_efi_config(name = self.name, - timeout = self._timeout) - cfg += self.__get_efi_image_stanzas(isodir, self.name) - - cfgf = open(isodir + "/EFI/boot/grub.conf", "w") - cfgf.write(cfg) - cfgf.close() - - # first gen mactel machines get the bootloader name wrong apparently - if rpmmisc.getBaseArch() == "i386": - os.link(isodir + "/EFI/boot/grub.efi", - isodir + "/EFI/boot/boot.efi") - os.link(isodir + "/EFI/boot/grub.conf", - isodir + "/EFI/boot/boot.conf") - - # for most things, we want them named boot$efiarch - efiarch = {"i386": "ia32", "x86_64": "x64"} - efiname = efiarch[rpmmisc.getBaseArch()] - os.rename(isodir + "/EFI/boot/grub.efi", - isodir + "/EFI/boot/boot%s.efi" %(efiname,)) - os.link(isodir + "/EFI/boot/grub.conf", - isodir + "/EFI/boot/boot%s.conf" %(efiname,)) - - - def _configure_bootloader(self, isodir): - self._configure_syslinux_bootloader(isodir) - self._configure_efi_bootloader(isodir) - -arch = "i386" -if arch in ("i386", "x86_64"): - LiveCDImageCreator = x86LiveImageCreator -elif arch.startswith("arm"): - LiveCDImageCreator = LiveImageCreatorBase -else: - raise CreatorError("Architecture not supported!") diff --git a/scripts/lib/mic/imager/liveusb.py b/scripts/lib/mic/imager/liveusb.py deleted file mode 100644 index a909928a4c..0000000000 --- a/scripts/lib/mic/imager/liveusb.py +++ /dev/null @@ -1,308 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2011 Intel, 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; 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 General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os -import shutil -import re - -from mic import msger -from mic.utils import misc, fs_related, runner -from mic.utils.errors import CreatorError, MountError -from mic.utils.partitionedfs import PartitionedMount -from mic.imager.livecd import LiveCDImageCreator - - -class LiveUSBImageCreator(LiveCDImageCreator): - def __init__(self, *args): - LiveCDImageCreator.__init__(self, *args) - - self._dep_checks.extend(["kpartx", "parted"]) - - # remove dependency of genisoimage in parent class - if "genisoimage" in self._dep_checks: - self._dep_checks.remove("genisoimage") - - def _create_usbimg(self, isodir): - overlaysizemb = 64 #default - #skipcompress = self.skip_compression? - fstype = "vfat" - homesizemb=0 - swapsizemb=0 - homefile="home.img" - plussize=128 - kernelargs=None - - if fstype == 'vfat': - if overlaysizemb > 2047: - raise CreatorError("Can't have an overlay of 2048MB or " - "greater on VFAT") - - if homesizemb > 2047: - raise CreatorError("Can't have an home overlay of 2048MB or " - "greater on VFAT") - - if swapsizemb > 2047: - raise CreatorError("Can't have an swap overlay of 2048MB or " - "greater on VFAT") - - livesize = misc.get_file_size(isodir + "/LiveOS") - - usbimgsize = (overlaysizemb + \ - homesizemb + \ - swapsizemb + \ - livesize + \ - plussize) * 1024L * 1024L - - disk = fs_related.SparseLoopbackDisk("%s/%s.usbimg" \ - % (self._outdir, self.name), - usbimgsize) - usbmnt = self._mkdtemp("usb-mnt") - usbloop = PartitionedMount(usbmnt) - usbloop.add_disk('/dev/sdb', disk) - - usbloop.add_partition(usbimgsize/1024/1024, - "/dev/sdb", - "/", - fstype, - boot=True) - - usbloop.mount() - - try: - fs_related.makedirs(usbmnt + "/LiveOS") - - if os.path.exists(isodir + "/LiveOS/squashfs.img"): - shutil.copyfile(isodir + "/LiveOS/squashfs.img", - usbmnt + "/LiveOS/squashfs.img") - else: - fs_related.mksquashfs(os.path.dirname(self._image), - usbmnt + "/LiveOS/squashfs.img") - - if os.path.exists(isodir + "/LiveOS/osmin.img"): - shutil.copyfile(isodir + "/LiveOS/osmin.img", - usbmnt + "/LiveOS/osmin.img") - - if fstype == "vfat" or fstype == "msdos": - uuid = usbloop.partitions[0]['mount'].uuid - label = usbloop.partitions[0]['mount'].fslabel - usblabel = "UUID=%s-%s" % (uuid[0:4], uuid[4:8]) - overlaysuffix = "-%s-%s-%s" % (label, uuid[0:4], uuid[4:8]) - else: - diskmount = usbloop.partitions[0]['mount'] - usblabel = "UUID=%s" % diskmount.uuid - overlaysuffix = "-%s-%s" % (diskmount.fslabel, diskmount.uuid) - - args = ['cp', "-Rf", isodir + "/isolinux", usbmnt + "/syslinux"] - rc = runner.show(args) - if rc: - raise CreatorError("Can't copy isolinux directory %s" \ - % (isodir + "/isolinux/*")) - - if os.path.isfile("/usr/share/syslinux/isolinux.bin"): - syslinux_path = "/usr/share/syslinux" - elif os.path.isfile("/usr/lib/syslinux/isolinux.bin"): - syslinux_path = "/usr/lib/syslinux" - else: - raise CreatorError("syslinux not installed : " - "cannot find syslinux installation path") - - for f in ("isolinux.bin", "vesamenu.c32"): - path = os.path.join(syslinux_path, f) - if os.path.isfile(path): - args = ['cp', path, usbmnt + "/syslinux/"] - rc = runner.show(args) - if rc: - raise CreatorError("Can't copy syslinux file " + path) - else: - raise CreatorError("syslinux not installed: " - "syslinux file %s not found" % path) - - fd = open(isodir + "/isolinux/isolinux.cfg", "r") - text = fd.read() - fd.close() - pattern = re.compile('CDLABEL=[^ ]*') - text = pattern.sub(usblabel, text) - pattern = re.compile('rootfstype=[^ ]*') - text = pattern.sub("rootfstype=" + fstype, text) - if kernelargs: - text = text.replace("rd.live.image", "rd.live.image " + kernelargs) - - if overlaysizemb > 0: - msger.info("Initializing persistent overlay file") - overfile = "overlay" + overlaysuffix - if fstype == "vfat": - args = ['dd', - "if=/dev/zero", - "of=" + usbmnt + "/LiveOS/" + overfile, - "count=%d" % overlaysizemb, - "bs=1M"] - else: - args = ['dd', - "if=/dev/null", - "of=" + usbmnt + "/LiveOS/" + overfile, - "count=1", - "bs=1M", - "seek=%d" % overlaysizemb] - rc = runner.show(args) - if rc: - raise CreatorError("Can't create overlay file") - text = text.replace("rd.live.image", "rd.live.image rd.live.overlay=" + usblabel) - text = text.replace(" ro ", " rw ") - - if swapsizemb > 0: - msger.info("Initializing swap file") - swapfile = usbmnt + "/LiveOS/" + "swap.img" - args = ['dd', - "if=/dev/zero", - "of=" + swapfile, - "count=%d" % swapsizemb, - "bs=1M"] - rc = runner.show(args) - if rc: - raise CreatorError("Can't create swap file") - args = ["mkswap", "-f", swapfile] - rc = runner.show(args) - if rc: - raise CreatorError("Can't mkswap on swap file") - - if homesizemb > 0: - msger.info("Initializing persistent /home") - homefile = usbmnt + "/LiveOS/" + homefile - if fstype == "vfat": - args = ['dd', - "if=/dev/zero", - "of=" + homefile, - "count=%d" % homesizemb, - "bs=1M"] - else: - args = ['dd', - "if=/dev/null", - "of=" + homefile, - "count=1", - "bs=1M", - "seek=%d" % homesizemb] - rc = runner.show(args) - if rc: - raise CreatorError("Can't create home file") - - mkfscmd = fs_related.find_binary_path("/sbin/mkfs." + fstype) - if fstype == "ext2" or fstype == "ext3": - args = [mkfscmd, "-F", "-j", homefile] - else: - args = [mkfscmd, homefile] - rc = runner.show(args) - if rc: - raise CreatorError("Can't mke2fs home file") - if fstype == "ext2" or fstype == "ext3": - tune2fs = fs_related.find_binary_path("tune2fs") - args = [tune2fs, - "-c0", - "-i0", - "-ouser_xattr,acl", - homefile] - rc = runner.show(args) - if rc: - raise CreatorError("Can't tune2fs home file") - - if fstype == "vfat" or fstype == "msdos": - syslinuxcmd = fs_related.find_binary_path("syslinux") - syslinuxcfg = usbmnt + "/syslinux/syslinux.cfg" - args = [syslinuxcmd, - "-d", - "syslinux", - usbloop.partitions[0]["device"]] - - elif fstype == "ext2" or fstype == "ext3": - extlinuxcmd = fs_related.find_binary_path("extlinux") - syslinuxcfg = usbmnt + "/syslinux/extlinux.conf" - args = [extlinuxcmd, - "-i", - usbmnt + "/syslinux"] - - else: - raise CreatorError("Invalid file system type: %s" % (fstype)) - - os.unlink(usbmnt + "/syslinux/isolinux.cfg") - fd = open(syslinuxcfg, "w") - fd.write(text) - fd.close() - rc = runner.show(args) - if rc: - raise CreatorError("Can't install boot loader.") - - finally: - usbloop.unmount() - usbloop.cleanup() - - # Need to do this after image is unmounted and device mapper is closed - msger.info("set MBR") - mbrfile = "/usr/lib/syslinux/mbr.bin" - if not os.path.exists(mbrfile): - mbrfile = "/usr/share/syslinux/mbr.bin" - if not os.path.exists(mbrfile): - raise CreatorError("mbr.bin file didn't exist.") - mbrsize = os.path.getsize(mbrfile) - outimg = "%s/%s.usbimg" % (self._outdir, self.name) - - args = ['dd', - "if=" + mbrfile, - "of=" + outimg, - "seek=0", - "conv=notrunc", - "bs=1", - "count=%d" % (mbrsize)] - rc = runner.show(args) - if rc: - raise CreatorError("Can't set MBR.") - - def _stage_final_image(self): - try: - isodir = self._get_isodir() - fs_related.makedirs(isodir + "/LiveOS") - - minimal_size = self._resparse() - - if not self.skip_minimize: - fs_related.create_image_minimizer(isodir + "/LiveOS/osmin.img", - self._image, - minimal_size) - - if self.skip_compression: - shutil.move(self._image, - isodir + "/LiveOS/ext3fs.img") - else: - fs_related.makedirs(os.path.join( - os.path.dirname(self._image), - "LiveOS")) - shutil.move(self._image, - os.path.join(os.path.dirname(self._image), - "LiveOS", "ext3fs.img")) - fs_related.mksquashfs(os.path.dirname(self._image), - isodir + "/LiveOS/squashfs.img") - - self._create_usbimg(isodir) - - if self.pack_to: - usbimg = os.path.join(self._outdir, self.name + ".usbimg") - packimg = os.path.join(self._outdir, self.pack_to) - misc.packing(packimg, usbimg) - os.unlink(usbimg) - - finally: - shutil.rmtree(isodir, ignore_errors = True) - self._set_isodir(None) - diff --git a/scripts/lib/mic/imager/loop.py b/scripts/lib/mic/imager/loop.py deleted file mode 100644 index 4d05ef271d..0000000000 --- a/scripts/lib/mic/imager/loop.py +++ /dev/null @@ -1,418 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2011 Intel, 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; 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 General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os -import glob -import shutil - -from mic import kickstart, msger -from mic.utils.errors import CreatorError, MountError -from mic.utils import misc, runner, fs_related as fs -from mic.imager.baseimager import BaseImageCreator - - -# The maximum string length supported for LoopImageCreator.fslabel -FSLABEL_MAXLEN = 32 - - -def save_mountpoints(fpath, loops, arch = None): - """Save mount points mapping to file - - :fpath, the xml file to store partition info - :loops, dict of partition info - :arch, image arch - """ - - if not fpath or not loops: - return - - from xml.dom import minidom - doc = minidom.Document() - imgroot = doc.createElement("image") - doc.appendChild(imgroot) - if arch: - imgroot.setAttribute('arch', arch) - for loop in loops: - part = doc.createElement("partition") - imgroot.appendChild(part) - for (key, val) in loop.items(): - if isinstance(val, fs.Mount): - continue - part.setAttribute(key, str(val)) - - with open(fpath, 'w') as wf: - wf.write(doc.toprettyxml(indent=' ')) - - return - -def load_mountpoints(fpath): - """Load mount points mapping from file - - :fpath, file path to load - """ - - if not fpath: - return - - from xml.dom import minidom - mount_maps = [] - with open(fpath, 'r') as rf: - dom = minidom.parse(rf) - imgroot = dom.documentElement - for part in imgroot.getElementsByTagName("partition"): - p = dict(part.attributes.items()) - - try: - mp = (p['mountpoint'], p['label'], p['name'], - int(p['size']), p['fstype']) - except KeyError: - msger.warning("Wrong format line in file: %s" % fpath) - except ValueError: - msger.warning("Invalid size '%s' in file: %s" % (p['size'], fpath)) - else: - mount_maps.append(mp) - - return mount_maps - -class LoopImageCreator(BaseImageCreator): - """Installs a system into a loopback-mountable filesystem image. - - LoopImageCreator is a straightforward ImageCreator subclass; the system - is installed into an ext3 filesystem on a sparse file which can be - subsequently loopback-mounted. - - When specifying multiple partitions in kickstart file, each partition - will be created as a separated loop image. - """ - - def __init__(self, creatoropts=None, pkgmgr=None, - compress_image=None, - shrink_image=False): - """Initialize a LoopImageCreator instance. - - This method takes the same arguments as ImageCreator.__init__() - with the addition of: - - fslabel -- A string used as a label for any filesystems created. - """ - - BaseImageCreator.__init__(self, creatoropts, pkgmgr) - - self.compress_image = compress_image - self.shrink_image = shrink_image - - self.__fslabel = None - self.fslabel = self.name - - self.__blocksize = 4096 - if self.ks: - self.__fstype = kickstart.get_image_fstype(self.ks, - "ext3") - self.__fsopts = kickstart.get_image_fsopts(self.ks, - "defaults,noatime") - - allloops = [] - for part in sorted(kickstart.get_partitions(self.ks), - key=lambda p: p.mountpoint): - if part.fstype == "swap": - continue - - label = part.label - mp = part.mountpoint - if mp == '/': - # the base image - if not label: - label = self.name - else: - mp = mp.rstrip('/') - if not label: - msger.warning('no "label" specified for loop img at %s' - ', use the mountpoint as the name' % mp) - label = mp.split('/')[-1] - - imgname = misc.strip_end(label, '.img') + '.img' - allloops.append({ - 'mountpoint': mp, - 'label': label, - 'name': imgname, - 'size': part.size or 4096L * 1024 * 1024, - 'fstype': part.fstype or 'ext3', - 'extopts': part.extopts or None, - 'loop': None, # to be created in _mount_instroot - }) - self._instloops = allloops - - else: - self.__fstype = None - self.__fsopts = None - self._instloops = [] - - self.__imgdir = None - - if self.ks: - self.__image_size = kickstart.get_image_size(self.ks, - 4096L * 1024 * 1024) - else: - self.__image_size = 0 - - self._img_name = self.name + ".img" - - def get_image_names(self): - if not self._instloops: - return None - - return [lo['name'] for lo in self._instloops] - - def _set_fstype(self, fstype): - self.__fstype = fstype - - def _set_image_size(self, imgsize): - self.__image_size = imgsize - - - # - # Properties - # - def __get_fslabel(self): - if self.__fslabel is None: - return self.name - else: - return self.__fslabel - def __set_fslabel(self, val): - if val is None: - self.__fslabel = None - else: - self.__fslabel = val[:FSLABEL_MAXLEN] - #A string used to label any filesystems created. - # - #Some filesystems impose a constraint on the maximum allowed size of the - #filesystem label. In the case of ext3 it's 16 characters, but in the case - #of ISO9660 it's 32 characters. - # - #mke2fs silently truncates the label, but mkisofs aborts if the label is - #too long. So, for convenience sake, any string assigned to this attribute - #is silently truncated to FSLABEL_MAXLEN (32) characters. - fslabel = property(__get_fslabel, __set_fslabel) - - def __get_image(self): - if self.__imgdir is None: - raise CreatorError("_image is not valid before calling mount()") - return os.path.join(self.__imgdir, self._img_name) - #The location of the image file. - # - #This is the path to the filesystem image. Subclasses may use this path - #in order to package the image in _stage_final_image(). - # - #Note, this directory does not exist before ImageCreator.mount() is called. - # - #Note also, this is a read-only attribute. - _image = property(__get_image) - - def __get_blocksize(self): - return self.__blocksize - def __set_blocksize(self, val): - if self._instloops: - raise CreatorError("_blocksize must be set before calling mount()") - try: - self.__blocksize = int(val) - except ValueError: - raise CreatorError("'%s' is not a valid integer value " - "for _blocksize" % val) - #The block size used by the image's filesystem. - # - #This is the block size used when creating the filesystem image. Subclasses - #may change this if they wish to use something other than a 4k block size. - # - #Note, this attribute may only be set before calling mount(). - _blocksize = property(__get_blocksize, __set_blocksize) - - def __get_fstype(self): - return self.__fstype - def __set_fstype(self, val): - if val != "ext2" and val != "ext3": - raise CreatorError("Unknown _fstype '%s' supplied" % val) - self.__fstype = val - #The type of filesystem used for the image. - # - #This is the filesystem type used when creating the filesystem image. - #Subclasses may change this if they wish to use something other ext3. - # - #Note, only ext2 and ext3 are currently supported. - # - #Note also, this attribute may only be set before calling mount(). - _fstype = property(__get_fstype, __set_fstype) - - def __get_fsopts(self): - return self.__fsopts - def __set_fsopts(self, val): - self.__fsopts = val - #Mount options of filesystem used for the image. - # - #This can be specified by --fsoptions="xxx,yyy" in part command in - #kickstart file. - _fsopts = property(__get_fsopts, __set_fsopts) - - - # - # Helpers for subclasses - # - def _resparse(self, size=None): - """Rebuild the filesystem image to be as sparse as possible. - - This method should be used by subclasses when staging the final image - in order to reduce the actual space taken up by the sparse image file - to be as little as possible. - - This is done by resizing the filesystem to the minimal size (thereby - eliminating any space taken up by deleted files) and then resizing it - back to the supplied size. - - size -- the size in, in bytes, which the filesystem image should be - resized to after it has been minimized; this defaults to None, - causing the original size specified by the kickstart file to - be used (or 4GiB if not specified in the kickstart). - """ - minsize = 0 - for item in self._instloops: - if item['name'] == self._img_name: - minsize = item['loop'].resparse(size) - else: - item['loop'].resparse(size) - - return minsize - - def _base_on(self, base_on=None): - if base_on and self._image != base_on: - shutil.copyfile(base_on, self._image) - - def _check_imgdir(self): - if self.__imgdir is None: - self.__imgdir = self._mkdtemp() - - - # - # Actual implementation - # - def _mount_instroot(self, base_on=None): - - if base_on and os.path.isfile(base_on): - self.__imgdir = os.path.dirname(base_on) - imgname = os.path.basename(base_on) - self._base_on(base_on) - self._set_image_size(misc.get_file_size(self._image)) - - # here, self._instloops must be [] - self._instloops.append({ - "mountpoint": "/", - "label": self.name, - "name": imgname, - "size": self.__image_size or 4096L, - "fstype": self.__fstype or "ext3", - "extopts": None, - "loop": None - }) - - self._check_imgdir() - - for loop in self._instloops: - fstype = loop['fstype'] - mp = os.path.join(self._instroot, loop['mountpoint'].lstrip('/')) - size = loop['size'] * 1024L * 1024L - imgname = loop['name'] - - if fstype in ("ext2", "ext3", "ext4"): - MyDiskMount = fs.ExtDiskMount - elif fstype == "btrfs": - MyDiskMount = fs.BtrfsDiskMount - elif fstype in ("vfat", "msdos"): - MyDiskMount = fs.VfatDiskMount - else: - msger.error('Cannot support fstype: %s' % fstype) - - loop['loop'] = MyDiskMount(fs.SparseLoopbackDisk( - os.path.join(self.__imgdir, imgname), - size), - mp, - fstype, - self._blocksize, - loop['label']) - - if fstype in ("ext2", "ext3", "ext4"): - loop['loop'].extopts = loop['extopts'] - - try: - msger.verbose('Mounting image "%s" on "%s"' % (imgname, mp)) - fs.makedirs(mp) - loop['loop'].mount() - except MountError, e: - raise - - def _unmount_instroot(self): - for item in reversed(self._instloops): - try: - item['loop'].cleanup() - except: - pass - - def _stage_final_image(self): - - if self.pack_to or self.shrink_image: - self._resparse(0) - else: - self._resparse() - - for item in self._instloops: - imgfile = os.path.join(self.__imgdir, item['name']) - if item['fstype'] == "ext4": - runner.show('/sbin/tune2fs -O ^huge_file,extents,uninit_bg %s ' - % imgfile) - if self.compress_image: - misc.compressing(imgfile, self.compress_image) - - if not self.pack_to: - for item in os.listdir(self.__imgdir): - shutil.move(os.path.join(self.__imgdir, item), - os.path.join(self._outdir, item)) - else: - msger.info("Pack all loop images together to %s" % self.pack_to) - dstfile = os.path.join(self._outdir, self.pack_to) - misc.packing(dstfile, self.__imgdir) - - if self.pack_to: - mountfp_xml = os.path.splitext(self.pack_to)[0] - mountfp_xml = misc.strip_end(mountfp_xml, '.tar') + ".xml" - else: - mountfp_xml = self.name + ".xml" - # save mount points mapping file to xml - save_mountpoints(os.path.join(self._outdir, mountfp_xml), - self._instloops, - self.target_arch) - - def copy_attachment(self): - if not hasattr(self, '_attachment') or not self._attachment: - return - - self._check_imgdir() - - msger.info("Copying attachment files...") - for item in self._attachment: - if not os.path.exists(item): - continue - dpath = os.path.join(self.__imgdir, os.path.basename(item)) - msger.verbose("Copy attachment %s to %s" % (item, dpath)) - shutil.copy(item, dpath) - diff --git a/scripts/lib/mic/imager/raw.py b/scripts/lib/mic/imager/raw.py deleted file mode 100644 index 838191a6f1..0000000000 --- a/scripts/lib/mic/imager/raw.py +++ /dev/null @@ -1,501 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2011 Intel, 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; 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 General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os -import stat -import shutil - -from mic import kickstart, msger -from mic.utils import fs_related, runner, misc -from mic.utils.partitionedfs import PartitionedMount -from mic.utils.errors import CreatorError, MountError -from mic.imager.baseimager import BaseImageCreator - - -class RawImageCreator(BaseImageCreator): - """Installs a system into a file containing a partitioned disk image. - - ApplianceImageCreator is an advanced ImageCreator subclass; a sparse file - is formatted with a partition table, each partition loopback mounted - and the system installed into an virtual disk. The disk image can - subsequently be booted in a virtual machine or accessed with kpartx - """ - - def __init__(self, creatoropts=None, pkgmgr=None, compress_image=None, generate_bmap=None, fstab_entry="uuid"): - """Initialize a ApplianceImageCreator instance. - - This method takes the same arguments as ImageCreator.__init__() - """ - BaseImageCreator.__init__(self, creatoropts, pkgmgr) - - self.__instloop = None - self.__imgdir = None - self.__disks = {} - self.__disk_format = "raw" - self._disk_names = [] - self._ptable_format = self.ks.handler.bootloader.ptable - self.vmem = 512 - self.vcpu = 1 - self.checksum = False - self.use_uuid = fstab_entry == "uuid" - self.appliance_version = None - self.appliance_release = None - self.compress_image = compress_image - self.bmap_needed = generate_bmap - self._need_extlinux = not kickstart.use_installerfw(self.ks, "extlinux") - #self.getsource = False - #self.listpkg = False - - self._dep_checks.extend(["sync", "kpartx", "parted"]) - if self._need_extlinux: - self._dep_checks.extend(["extlinux"]) - - def configure(self, repodata = None): - import subprocess - def chroot(): - os.chroot(self._instroot) - os.chdir("/") - - if os.path.exists(self._instroot + "/usr/bin/Xorg"): - subprocess.call(["/bin/chmod", "u+s", "/usr/bin/Xorg"], - preexec_fn = chroot) - - BaseImageCreator.configure(self, repodata) - - def _get_fstab(self): - if kickstart.use_installerfw(self.ks, "fstab"): - # The fstab file will be generated by installer framework scripts - # instead. - return None - - s = "" - for mp in self.__instloop.mountOrder: - p = None - for p1 in self.__instloop.partitions: - if p1['mountpoint'] == mp: - p = p1 - break - - if self.use_uuid and p['uuid']: - device = "UUID=%s" % p['uuid'] - else: - device = "/dev/%s%-d" % (p['disk_name'], p['num']) - - s += "%(device)s %(mountpoint)s %(fstype)s %(fsopts)s 0 0\n" % { - 'device': device, - 'mountpoint': p['mountpoint'], - 'fstype': p['fstype'], - 'fsopts': "defaults,noatime" if not p['fsopts'] else p['fsopts']} - - if p['mountpoint'] == "/": - for subvol in self.__instloop.subvolumes: - if subvol['mountpoint'] == "/": - continue - s += "%(device)s %(mountpoint)s %(fstype)s %(fsopts)s 0 0\n" % { - 'device': "/dev/%s%-d" % (p['disk_name'], p['num']), - 'mountpoint': subvol['mountpoint'], - 'fstype': p['fstype'], - 'fsopts': "defaults,noatime" if not subvol['fsopts'] else subvol['fsopts']} - - s += "devpts /dev/pts devpts gid=5,mode=620 0 0\n" - s += "tmpfs /dev/shm tmpfs defaults 0 0\n" - s += "proc /proc proc defaults 0 0\n" - s += "sysfs /sys sysfs defaults 0 0\n" - return s - - def _create_mkinitrd_config(self): - """write to tell which modules to be included in initrd""" - - mkinitrd = "" - mkinitrd += "PROBE=\"no\"\n" - mkinitrd += "MODULES+=\"ext3 ata_piix sd_mod libata scsi_mod\"\n" - mkinitrd += "rootfs=\"ext3\"\n" - mkinitrd += "rootopts=\"defaults\"\n" - - msger.debug("Writing mkinitrd config %s/etc/sysconfig/mkinitrd" \ - % self._instroot) - os.makedirs(self._instroot + "/etc/sysconfig/",mode=644) - cfg = open(self._instroot + "/etc/sysconfig/mkinitrd", "w") - cfg.write(mkinitrd) - cfg.close() - - def _get_parts(self): - if not self.ks: - raise CreatorError("Failed to get partition info, " - "please check your kickstart setting.") - - # Set a default partition if no partition is given out - if not self.ks.handler.partition.partitions: - partstr = "part / --size 1900 --ondisk sda --fstype=ext3" - args = partstr.split() - pd = self.ks.handler.partition.parse(args[1:]) - if pd not in self.ks.handler.partition.partitions: - self.ks.handler.partition.partitions.append(pd) - - # partitions list from kickstart file - return kickstart.get_partitions(self.ks) - - def get_disk_names(self): - """ Returns a list of physical target disk names (e.g., 'sdb') which - will be created. """ - - if self._disk_names: - return self._disk_names - - #get partition info from ks handler - parts = self._get_parts() - - for i in range(len(parts)): - if parts[i].disk: - disk_name = parts[i].disk - else: - raise CreatorError("Failed to create disks, no --ondisk " - "specified in partition line of ks file") - - if parts[i].mountpoint and not parts[i].fstype: - raise CreatorError("Failed to create disks, no --fstype " - "specified for partition with mountpoint " - "'%s' in the ks file") - - self._disk_names.append(disk_name) - - return self._disk_names - - def _full_name(self, name, extention): - """ Construct full file name for a file we generate. """ - return "%s-%s.%s" % (self.name, name, extention) - - def _full_path(self, path, name, extention): - """ Construct full file path to a file we generate. """ - return os.path.join(path, self._full_name(name, extention)) - - # - # Actual implemention - # - def _mount_instroot(self, base_on = None): - parts = self._get_parts() - self.__instloop = PartitionedMount(self._instroot) - - for p in parts: - self.__instloop.add_partition(int(p.size), - p.disk, - p.mountpoint, - p.fstype, - p.label, - fsopts = p.fsopts, - boot = p.active, - align = p.align, - part_type = p.part_type) - - self.__instloop.layout_partitions(self._ptable_format) - - # Create the disks - self.__imgdir = self._mkdtemp() - for disk_name, disk in self.__instloop.disks.items(): - full_path = self._full_path(self.__imgdir, disk_name, "raw") - msger.debug("Adding disk %s as %s with size %s bytes" \ - % (disk_name, full_path, disk['min_size'])) - - disk_obj = fs_related.SparseLoopbackDisk(full_path, - disk['min_size']) - self.__disks[disk_name] = disk_obj - self.__instloop.add_disk(disk_name, disk_obj) - - self.__instloop.mount() - self._create_mkinitrd_config() - - def _get_required_packages(self): - required_packages = BaseImageCreator._get_required_packages(self) - if self._need_extlinux: - if not self.target_arch or not self.target_arch.startswith("arm"): - required_packages += ["syslinux", "syslinux-extlinux"] - return required_packages - - def _get_excluded_packages(self): - return BaseImageCreator._get_excluded_packages(self) - - def _get_syslinux_boot_config(self): - rootdev = None - root_part_uuid = None - for p in self.__instloop.partitions: - if p['mountpoint'] == "/": - rootdev = "/dev/%s%-d" % (p['disk_name'], p['num']) - root_part_uuid = p['partuuid'] - - return (rootdev, root_part_uuid) - - def _create_syslinux_config(self): - - splash = os.path.join(self._instroot, "boot/extlinux") - if os.path.exists(splash): - splashline = "menu background splash.jpg" - else: - splashline = "" - - (rootdev, root_part_uuid) = self._get_syslinux_boot_config() - options = self.ks.handler.bootloader.appendLine - - #XXX don't hardcode default kernel - see livecd code - syslinux_conf = "" - syslinux_conf += "prompt 0\n" - syslinux_conf += "timeout 1\n" - syslinux_conf += "\n" - syslinux_conf += "default vesamenu.c32\n" - syslinux_conf += "menu autoboot Starting %s...\n" % self.distro_name - syslinux_conf += "menu hidden\n" - syslinux_conf += "\n" - syslinux_conf += "%s\n" % splashline - syslinux_conf += "menu title Welcome to %s!\n" % self.distro_name - syslinux_conf += "menu color border 0 #ffffffff #00000000\n" - syslinux_conf += "menu color sel 7 #ffffffff #ff000000\n" - syslinux_conf += "menu color title 0 #ffffffff #00000000\n" - syslinux_conf += "menu color tabmsg 0 #ffffffff #00000000\n" - syslinux_conf += "menu color unsel 0 #ffffffff #00000000\n" - syslinux_conf += "menu color hotsel 0 #ff000000 #ffffffff\n" - syslinux_conf += "menu color hotkey 7 #ffffffff #ff000000\n" - syslinux_conf += "menu color timeout_msg 0 #ffffffff #00000000\n" - syslinux_conf += "menu color timeout 0 #ffffffff #00000000\n" - syslinux_conf += "menu color cmdline 0 #ffffffff #00000000\n" - - versions = [] - kernels = self._get_kernel_versions() - symkern = "%s/boot/vmlinuz" % self._instroot - - if os.path.lexists(symkern): - v = os.path.realpath(symkern).replace('%s-' % symkern, "") - syslinux_conf += "label %s\n" % self.distro_name.lower() - syslinux_conf += "\tmenu label %s (%s)\n" % (self.distro_name, v) - syslinux_conf += "\tlinux ../vmlinuz\n" - if self._ptable_format == 'msdos': - rootstr = rootdev - else: - if not root_part_uuid: - raise MountError("Cannot find the root GPT partition UUID") - rootstr = "PARTUUID=%s" % root_part_uuid - syslinux_conf += "\tappend ro root=%s %s\n" % (rootstr, options) - syslinux_conf += "\tmenu default\n" - else: - for kernel in kernels: - for version in kernels[kernel]: - versions.append(version) - - footlabel = 0 - for v in versions: - syslinux_conf += "label %s%d\n" \ - % (self.distro_name.lower(), footlabel) - syslinux_conf += "\tmenu label %s (%s)\n" % (self.distro_name, v) - syslinux_conf += "\tlinux ../vmlinuz-%s\n" % v - syslinux_conf += "\tappend ro root=%s %s\n" \ - % (rootdev, options) - if footlabel == 0: - syslinux_conf += "\tmenu default\n" - footlabel += 1; - - msger.debug("Writing syslinux config %s/boot/extlinux/extlinux.conf" \ - % self._instroot) - cfg = open(self._instroot + "/boot/extlinux/extlinux.conf", "w") - cfg.write(syslinux_conf) - cfg.close() - - def _install_syslinux(self): - for name in self.__disks.keys(): - loopdev = self.__disks[name].device - - # Set MBR - mbrfile = "%s/usr/share/syslinux/" % self._instroot - if self._ptable_format == 'gpt': - mbrfile += "gptmbr.bin" - else: - mbrfile += "mbr.bin" - - msger.debug("Installing syslinux bootloader '%s' to %s" % \ - (mbrfile, loopdev)) - - mbrsize = os.stat(mbrfile)[stat.ST_SIZE] - rc = runner.show(['dd', 'if=%s' % mbrfile, 'of=' + loopdev]) - if rc != 0: - raise MountError("Unable to set MBR to %s" % loopdev) - - - # Ensure all data is flushed to disk before doing syslinux install - runner.quiet('sync') - - fullpathsyslinux = fs_related.find_binary_path("extlinux") - rc = runner.show([fullpathsyslinux, - "-i", - "%s/boot/extlinux" % self._instroot]) - if rc != 0: - raise MountError("Unable to install syslinux bootloader to %s" \ - % loopdev) - - def _create_bootconfig(self): - #If syslinux is available do the required configurations. - if self._need_extlinux \ - and os.path.exists("%s/usr/share/syslinux/" % (self._instroot)) \ - and os.path.exists("%s/boot/extlinux/" % (self._instroot)): - self._create_syslinux_config() - self._install_syslinux() - - def _unmount_instroot(self): - if not self.__instloop is None: - try: - self.__instloop.cleanup() - except MountError, err: - msger.warning("%s" % err) - - def _resparse(self, size = None): - return self.__instloop.resparse(size) - - def _get_post_scripts_env(self, in_chroot): - env = BaseImageCreator._get_post_scripts_env(self, in_chroot) - - # Export the file-system UUIDs and partition UUIDs (AKA PARTUUIDs) - for p in self.__instloop.partitions: - env.update(self._set_part_env(p['ks_pnum'], "UUID", p['uuid'])) - env.update(self._set_part_env(p['ks_pnum'], "PARTUUID", p['partuuid'])) - - return env - - def _stage_final_image(self): - """Stage the final system image in _outdir. - write meta data - """ - self._resparse() - - if self.compress_image: - for imgfile in os.listdir(self.__imgdir): - if imgfile.endswith('.raw') or imgfile.endswith('bin'): - imgpath = os.path.join(self.__imgdir, imgfile) - misc.compressing(imgpath, self.compress_image) - - if self.pack_to: - dst = os.path.join(self._outdir, self.pack_to) - msger.info("Pack all raw images to %s" % dst) - misc.packing(dst, self.__imgdir) - else: - msger.debug("moving disks to stage location") - for imgfile in os.listdir(self.__imgdir): - src = os.path.join(self.__imgdir, imgfile) - dst = os.path.join(self._outdir, imgfile) - msger.debug("moving %s to %s" % (src,dst)) - shutil.move(src,dst) - self._write_image_xml() - - def _write_image_xml(self): - imgarch = "i686" - if self.target_arch and self.target_arch.startswith("arm"): - imgarch = "arm" - xml = "\n" - - name_attributes = "" - if self.appliance_version: - name_attributes += " version='%s'" % self.appliance_version - if self.appliance_release: - name_attributes += " release='%s'" % self.appliance_release - xml += " %s\n" % (name_attributes, self.name) - xml += " \n" - # XXX don't hardcode - determine based on the kernel we installed for - # grub baremetal vs xen - xml += " \n" - xml += " \n" - xml += " %s\n" % imgarch - xml += " \n" - xml += " \n" - xml += " \n" - xml += " \n" - - i = 0 - for name in self.__disks.keys(): - full_name = self._full_name(name, self.__disk_format) - xml += " \n" \ - % (full_name, chr(ord('a') + i)) - i = i + 1 - - xml += " \n" - xml += " \n" - xml += " %s\n" % self.vcpu - xml += " %d\n" %(self.vmem * 1024) - for network in self.ks.handler.network.network: - xml += " \n" - xml += " \n" - xml += " \n" - xml += " \n" - xml += " \n" - - if self.checksum is True: - for name in self.__disks.keys(): - diskpath = self._full_path(self._outdir, name, \ - self.__disk_format) - full_name = self._full_name(name, self.__disk_format) - - msger.debug("Generating disk signature for %s" % full_name) - - xml += " \n" \ - % (full_name, self.__disk_format) - - hashes = misc.calc_hashes(diskpath, ('sha1', 'sha256')) - - xml += " %s\n" \ - % hashes[0] - xml += " %s\n" \ - % hashes[1] - xml += " \n" - else: - for name in self.__disks.keys(): - full_name = self._full_name(name, self.__disk_format) - xml += " \n" \ - % (full_name, self.__disk_format) - - xml += " \n" - xml += "\n" - - msger.debug("writing image XML to %s/%s.xml" %(self._outdir, self.name)) - cfg = open("%s/%s.xml" % (self._outdir, self.name), "w") - cfg.write(xml) - cfg.close() - - def generate_bmap(self): - """ Generate block map file for the image. The idea is that while disk - images we generate may be large (e.g., 4GiB), they may actually contain - only little real data, e.g., 512MiB. This data are files, directories, - file-system meta-data, partition table, etc. In other words, when - flashing the image to the target device, you do not have to copy all the - 4GiB of data, you can copy only 512MiB of it, which is 4 times faster. - - This function generates the block map file for an arbitrary image that - mic has generated. The block map file is basically an XML file which - contains a list of blocks which have to be copied to the target device. - The other blocks are not used and there is no need to copy them. """ - - if self.bmap_needed is None: - return - - from mic.utils import BmapCreate - msger.info("Generating the map file(s)") - - for name in self.__disks.keys(): - image = self._full_path(self.__imgdir, name, self.__disk_format) - bmap_file = self._full_path(self._outdir, name, "bmap") - - msger.debug("Generating block map file '%s'" % bmap_file) - - try: - creator = BmapCreate.BmapCreate(image, bmap_file) - creator.generate() - del creator - except BmapCreate.Error as err: - raise CreatorError("Failed to create bmap file: %s" % str(err)) diff --git a/scripts/lib/mic/plugins/imager/direct_plugin.py b/scripts/lib/mic/plugins/imager/direct_plugin.py index fc7c10c3df..d3a0ba75d3 100644 --- a/scripts/lib/mic/plugins/imager/direct_plugin.py +++ b/scripts/lib/mic/plugins/imager/direct_plugin.py @@ -30,7 +30,7 @@ import shutil import re import tempfile -from mic import chroot, msger +from mic import msger from mic.utils import misc, fs_related, errors, runner, cmdln from mic.conf import configmgr from mic.plugin import pluginmgr diff --git a/scripts/lib/mic/plugins/imager/fs_plugin.py b/scripts/lib/mic/plugins/imager/fs_plugin.py deleted file mode 100644 index 6bcaf00729..0000000000 --- a/scripts/lib/mic/plugins/imager/fs_plugin.py +++ /dev/null @@ -1,143 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2011 Intel, 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; 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 General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os -import sys - -from mic import chroot, msger -from mic.utils import cmdln, misc, errors, fs_related -from mic.imager import fs -from mic.conf import configmgr -from mic.plugin import pluginmgr - -from mic.pluginbase import ImagerPlugin -class FsPlugin(ImagerPlugin): - name = 'fs' - - @classmethod - @cmdln.option("--include-src", - dest="include_src", - action="store_true", - default=False, - help="Generate a image with source rpms included") - def do_create(self, subcmd, opts, *args): - """${cmd_name}: create fs image - - Usage: - ${name} ${cmd_name} [OPTS] - - ${cmd_option_list} - """ - - if len(args) != 1: - raise errors.Usage("Extra arguments given") - - creatoropts = configmgr.create - ksconf = args[0] - - if creatoropts['runtime'] == 'bootstrap': - configmgr._ksconf = ksconf - rt_util.bootstrap_mic() - - recording_pkgs = [] - if len(creatoropts['record_pkgs']) > 0: - recording_pkgs = creatoropts['record_pkgs'] - - if creatoropts['release'] is not None: - if 'name' not in recording_pkgs: - recording_pkgs.append('name') - if 'vcs' not in recording_pkgs: - recording_pkgs.append('vcs') - - configmgr._ksconf = ksconf - - # Called After setting the configmgr._ksconf as the creatoropts['name'] is reset there. - if creatoropts['release'] is not None: - creatoropts['outdir'] = "%s/%s/images/%s/" % (creatoropts['outdir'], creatoropts['release'], creatoropts['name']) - - # try to find the pkgmgr - pkgmgr = None - backends = pluginmgr.get_plugins('backend') - if 'auto' == creatoropts['pkgmgr']: - for key in configmgr.prefer_backends: - if key in backends: - pkgmgr = backends[key] - break - else: - for key in backends.keys(): - if key == creatoropts['pkgmgr']: - pkgmgr = backends[key] - break - - if not pkgmgr: - raise errors.CreatorError("Can't find backend: %s, " - "available choices: %s" % - (creatoropts['pkgmgr'], - ','.join(backends.keys()))) - - creator = fs.FsImageCreator(creatoropts, pkgmgr) - creator._include_src = opts.include_src - - if len(recording_pkgs) > 0: - creator._recording_pkgs = recording_pkgs - - self.check_image_exists(creator.destdir, - creator.pack_to, - [creator.name], - creatoropts['release']) - - try: - creator.check_depend_tools() - creator.mount(None, creatoropts["cachedir"]) - creator.install() - #Download the source packages ###private options - if opts.include_src: - installed_pkgs = creator.get_installed_packages() - msger.info('--------------------------------------------------') - msger.info('Generating the image with source rpms included ...') - if not misc.SrcpkgsDownload(installed_pkgs, creatoropts["repomd"], creator._instroot, creatoropts["cachedir"]): - msger.warning("Source packages can't be downloaded") - - creator.configure(creatoropts["repomd"]) - creator.copy_kernel() - creator.unmount() - creator.package(creatoropts["outdir"]) - if creatoropts['release'] is not None: - creator.release_output(ksconf, creatoropts['outdir'], creatoropts['release']) - creator.print_outimage_info() - except errors.CreatorError: - raise - finally: - creator.cleanup() - - msger.info("Finished.") - return 0 - - @classmethod - def do_chroot(self, target, cmd=[]):#chroot.py parse opts&args - try: - if len(cmd) != 0: - cmdline = ' '.join(cmd) - else: - cmdline = "/bin/bash" - envcmd = fs_related.find_binary_inchroot("env", target) - if envcmd: - cmdline = "%s HOME=/root %s" % (envcmd, cmdline) - chroot.chroot(target, None, cmdline) - finally: - chroot.cleanup_after_chroot("dir", None, None, None) - return 1 diff --git a/scripts/lib/mic/plugins/imager/livecd_plugin.py b/scripts/lib/mic/plugins/imager/livecd_plugin.py deleted file mode 100644 index 82cb1af7dc..0000000000 --- a/scripts/lib/mic/plugins/imager/livecd_plugin.py +++ /dev/null @@ -1,255 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2011 Intel, 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; 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 General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os -import shutil -import tempfile - -from mic import chroot, msger -from mic.utils import misc, fs_related, errors -from mic.conf import configmgr -import mic.imager.livecd as livecd -from mic.plugin import pluginmgr - -from mic.pluginbase import ImagerPlugin -class LiveCDPlugin(ImagerPlugin): - name = 'livecd' - - @classmethod - def do_create(self, subcmd, opts, *args): - """${cmd_name}: create livecd image - - Usage: - ${name} ${cmd_name} [OPTS] - - ${cmd_option_list} - """ - - if len(args) != 1: - raise errors.Usage("Extra arguments given") - - creatoropts = configmgr.create - ksconf = args[0] - - if creatoropts['runtime'] == 'bootstrap': - configmgr._ksconf = ksconf - rt_util.bootstrap_mic() - - if creatoropts['arch'] and creatoropts['arch'].startswith('arm'): - msger.warning('livecd cannot support arm images, Quit') - return - - recording_pkgs = [] - if len(creatoropts['record_pkgs']) > 0: - recording_pkgs = creatoropts['record_pkgs'] - - if creatoropts['release'] is not None: - if 'name' not in recording_pkgs: - recording_pkgs.append('name') - if 'vcs' not in recording_pkgs: - recording_pkgs.append('vcs') - - configmgr._ksconf = ksconf - - # Called After setting the configmgr._ksconf as the creatoropts['name'] is reset there. - if creatoropts['release'] is not None: - creatoropts['outdir'] = "%s/%s/images/%s/" % (creatoropts['outdir'], creatoropts['release'], creatoropts['name']) - - # try to find the pkgmgr - pkgmgr = None - backends = pluginmgr.get_plugins('backend') - if 'auto' == creatoropts['pkgmgr']: - for key in configmgr.prefer_backends: - if key in backends: - pkgmgr = backends[key] - break - else: - for key in backends.keys(): - if key == creatoropts['pkgmgr']: - pkgmgr = backends[key] - break - - if not pkgmgr: - raise errors.CreatorError("Can't find backend: %s, " - "available choices: %s" % - (creatoropts['pkgmgr'], - ','.join(backends.keys()))) - - creator = livecd.LiveCDImageCreator(creatoropts, pkgmgr) - - if len(recording_pkgs) > 0: - creator._recording_pkgs = recording_pkgs - - self.check_image_exists(creator.destdir, - creator.pack_to, - [creator.name + ".iso"], - creatoropts['release']) - - try: - creator.check_depend_tools() - creator.mount(None, creatoropts["cachedir"]) - creator.install() - creator.configure(creatoropts["repomd"]) - creator.copy_kernel() - creator.unmount() - creator.package(creatoropts["outdir"]) - if creatoropts['release'] is not None: - creator.release_output(ksconf, creatoropts['outdir'], creatoropts['release']) - creator.print_outimage_info() - - except errors.CreatorError: - raise - finally: - creator.cleanup() - - msger.info("Finished.") - return 0 - - @classmethod - def do_chroot(cls, target, cmd=[]): - os_image = cls.do_unpack(target) - os_image_dir = os.path.dirname(os_image) - - # unpack image to target dir - imgsize = misc.get_file_size(os_image) * 1024L * 1024L - imgtype = misc.get_image_type(os_image) - if imgtype == "btrfsimg": - fstype = "btrfs" - myDiskMount = fs_related.BtrfsDiskMount - elif imgtype in ("ext3fsimg", "ext4fsimg"): - fstype = imgtype[:4] - myDiskMount = fs_related.ExtDiskMount - else: - raise errors.CreatorError("Unsupported filesystem type: %s" % fstype) - - extmnt = misc.mkdtemp() - extloop = myDiskMount(fs_related.SparseLoopbackDisk(os_image, imgsize), - extmnt, - fstype, - 4096, - "%s label" % fstype) - try: - extloop.mount() - - except errors.MountError: - extloop.cleanup() - shutil.rmtree(extmnt, ignore_errors = True) - shutil.rmtree(os_image_dir, ignore_errors = True) - raise - - try: - if len(cmd) != 0: - cmdline = ' '.join(cmd) - else: - cmdline = "/bin/bash" - envcmd = fs_related.find_binary_inchroot("env", extmnt) - if envcmd: - cmdline = "%s HOME=/root %s" % (envcmd, cmdline) - chroot.chroot(extmnt, None, cmdline) - except: - raise errors.CreatorError("Failed to chroot to %s." %target) - finally: - chroot.cleanup_after_chroot("img", extloop, os_image_dir, extmnt) - - @classmethod - def do_pack(cls, base_on): - import subprocess - - def __mkinitrd(instance): - kernelver = instance._get_kernel_versions().values()[0][0] - args = [ "/usr/libexec/mkliveinitrd", "/boot/initrd-%s.img" % kernelver, "%s" % kernelver ] - try: - subprocess.call(args, preexec_fn = instance._chroot) - except OSError, (err, msg): - raise errors.CreatorError("Failed to execute /usr/libexec/mkliveinitrd: %s" % msg) - - def __run_post_cleanups(instance): - kernelver = instance._get_kernel_versions().values()[0][0] - args = ["rm", "-f", "/boot/initrd-%s.img" % kernelver] - - try: - subprocess.call(args, preexec_fn = instance._chroot) - except OSError, (err, msg): - raise errors.CreatorError("Failed to run post cleanups: %s" % msg) - - convertoropts = configmgr.convert - convertoropts['name'] = os.path.splitext(os.path.basename(base_on))[0] - convertor = livecd.LiveCDImageCreator(convertoropts) - imgtype = misc.get_image_type(base_on) - if imgtype == "btrfsimg": - fstype = "btrfs" - elif imgtype in ("ext3fsimg", "ext4fsimg"): - fstype = imgtype[:4] - else: - raise errors.CreatorError("Unsupported filesystem type: %s" % fstype) - convertor._set_fstype(fstype) - try: - convertor.mount(base_on) - __mkinitrd(convertor) - convertor._create_bootconfig() - __run_post_cleanups(convertor) - convertor.launch_shell(convertoropts['shell']) - convertor.unmount() - convertor.package() - convertor.print_outimage_info() - finally: - shutil.rmtree(os.path.dirname(base_on), ignore_errors = True) - - @classmethod - def do_unpack(cls, srcimg): - img = srcimg - imgmnt = misc.mkdtemp() - imgloop = fs_related.DiskMount(fs_related.LoopbackDisk(img, 0), imgmnt) - try: - imgloop.mount() - except errors.MountError: - imgloop.cleanup() - raise - - # legacy LiveOS filesystem layout support, remove for F9 or F10 - if os.path.exists(imgmnt + "/squashfs.img"): - squashimg = imgmnt + "/squashfs.img" - else: - squashimg = imgmnt + "/LiveOS/squashfs.img" - - tmpoutdir = misc.mkdtemp() - # unsquashfs requires outdir mustn't exist - shutil.rmtree(tmpoutdir, ignore_errors = True) - misc.uncompress_squashfs(squashimg, tmpoutdir) - - try: - # legacy LiveOS filesystem layout support, remove for F9 or F10 - if os.path.exists(tmpoutdir + "/os.img"): - os_image = tmpoutdir + "/os.img" - else: - os_image = tmpoutdir + "/LiveOS/ext3fs.img" - - if not os.path.exists(os_image): - raise errors.CreatorError("'%s' is not a valid live CD ISO : neither " - "LiveOS/ext3fs.img nor os.img exist" %img) - - imgname = os.path.basename(srcimg) - imgname = os.path.splitext(imgname)[0] + ".img" - rtimage = os.path.join(tempfile.mkdtemp(dir = "/var/tmp", prefix = "tmp"), imgname) - shutil.copyfile(os_image, rtimage) - - finally: - imgloop.cleanup() - shutil.rmtree(tmpoutdir, ignore_errors = True) - shutil.rmtree(imgmnt, ignore_errors = True) - - return rtimage diff --git a/scripts/lib/mic/plugins/imager/liveusb_plugin.py b/scripts/lib/mic/plugins/imager/liveusb_plugin.py deleted file mode 100644 index 3d53c84410..0000000000 --- a/scripts/lib/mic/plugins/imager/liveusb_plugin.py +++ /dev/null @@ -1,260 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2011 Intel, 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; 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 General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os -import shutil -import tempfile - -from mic import chroot, msger -from mic.utils import misc, fs_related, errors -from mic.utils.partitionedfs import PartitionedMount -from mic.conf import configmgr -from mic.plugin import pluginmgr - -import mic.imager.liveusb as liveusb - -from mic.pluginbase import ImagerPlugin -class LiveUSBPlugin(ImagerPlugin): - name = 'liveusb' - - @classmethod - def do_create(self, subcmd, opts, *args): - """${cmd_name}: create liveusb image - - Usage: - ${name} ${cmd_name} [OPTS] - - ${cmd_option_list} - """ - - if len(args) != 1: - raise errors.Usage("Extra arguments given") - - creatoropts = configmgr.create - ksconf = args[0] - - if creatoropts['runtime'] == "bootstrap": - configmgr._ksconf = ksconf - rt_util.bootstrap_mic() - - if creatoropts['arch'] and creatoropts['arch'].startswith('arm'): - msger.warning('liveusb cannot support arm images, Quit') - return - - recording_pkgs = [] - if len(creatoropts['record_pkgs']) > 0: - recording_pkgs = creatoropts['record_pkgs'] - - if creatoropts['release'] is not None: - if 'name' not in recording_pkgs: - recording_pkgs.append('name') - if 'vcs' not in recording_pkgs: - recording_pkgs.append('vcs') - - configmgr._ksconf = ksconf - - # Called After setting the configmgr._ksconf as the creatoropts['name'] is reset there. - if creatoropts['release'] is not None: - creatoropts['outdir'] = "%s/%s/images/%s/" % (creatoropts['outdir'], creatoropts['release'], creatoropts['name']) - - # try to find the pkgmgr - pkgmgr = None - backends = pluginmgr.get_plugins('backend') - if 'auto' == creatoropts['pkgmgr']: - for key in configmgr.prefer_backends: - if key in backends: - pkgmgr = backends[key] - break - else: - for key in backends.keys(): - if key == creatoropts['pkgmgr']: - pkgmgr = backends[key] - break - - if not pkgmgr: - raise errors.CreatorError("Can't find backend: %s, " - "available choices: %s" % - (creatoropts['pkgmgr'], - ','.join(backends.keys()))) - - creator = liveusb.LiveUSBImageCreator(creatoropts, pkgmgr) - - if len(recording_pkgs) > 0: - creator._recording_pkgs = recording_pkgs - - self.check_image_exists(creator.destdir, - creator.pack_to, - [creator.name + ".usbimg"], - creatoropts['release']) - try: - creator.check_depend_tools() - creator.mount(None, creatoropts["cachedir"]) - creator.install() - creator.configure(creatoropts["repomd"]) - creator.copy_kernel() - creator.unmount() - creator.package(creatoropts["outdir"]) - if creatoropts['release'] is not None: - creator.release_output(ksconf, creatoropts['outdir'], creatoropts['release']) - creator.print_outimage_info() - - except errors.CreatorError: - raise - finally: - creator.cleanup() - - msger.info("Finished.") - return 0 - - @classmethod - def do_chroot(cls, target, cmd=[]): - os_image = cls.do_unpack(target) - os_image_dir = os.path.dirname(os_image) - - # unpack image to target dir - imgsize = misc.get_file_size(os_image) * 1024L * 1024L - imgtype = misc.get_image_type(os_image) - if imgtype == "btrfsimg": - fstype = "btrfs" - myDiskMount = fs_related.BtrfsDiskMount - elif imgtype in ("ext3fsimg", "ext4fsimg"): - fstype = imgtype[:4] - myDiskMount = fs_related.ExtDiskMount - else: - raise errors.CreatorError("Unsupported filesystem type: %s" % fstype) - - extmnt = misc.mkdtemp() - extloop = myDiskMount(fs_related.SparseLoopbackDisk(os_image, imgsize), - extmnt, - fstype, - 4096, - "%s label" % fstype) - - try: - extloop.mount() - - except errors.MountError: - extloop.cleanup() - shutil.rmtree(extmnt, ignore_errors = True) - raise - - try: - if len(cmd) != 0: - cmdline = ' '.join(cmd) - else: - cmdline = "/bin/bash" - envcmd = fs_related.find_binary_inchroot("env", extmnt) - if envcmd: - cmdline = "%s HOME=/root %s" % (envcmd, cmdline) - chroot.chroot(extmnt, None, cmdline) - except: - raise errors.CreatorError("Failed to chroot to %s." %target) - finally: - chroot.cleanup_after_chroot("img", extloop, os_image_dir, extmnt) - - @classmethod - def do_pack(cls, base_on): - import subprocess - - def __mkinitrd(instance): - kernelver = instance._get_kernel_versions().values()[0][0] - args = [ "/usr/libexec/mkliveinitrd", "/boot/initrd-%s.img" % kernelver, "%s" % kernelver ] - try: - subprocess.call(args, preexec_fn = instance._chroot) - - except OSError, (err, msg): - raise errors.CreatorError("Failed to execute /usr/libexec/mkliveinitrd: %s" % msg) - - def __run_post_cleanups(instance): - kernelver = instance._get_kernel_versions().values()[0][0] - args = ["rm", "-f", "/boot/initrd-%s.img" % kernelver] - - try: - subprocess.call(args, preexec_fn = instance._chroot) - except OSError, (err, msg): - raise errors.CreatorError("Failed to run post cleanups: %s" % msg) - - convertoropts = configmgr.convert - convertoropts['name'] = os.path.splitext(os.path.basename(base_on))[0] - convertor = liveusb.LiveUSBImageCreator(convertoropts) - imgtype = misc.get_image_type(base_on) - if imgtype == "btrfsimg": - fstype = "btrfs" - elif imgtype in ("ext3fsimg", "ext4fsimg"): - fstype = imgtype[:4] - else: - raise errors.CreatorError("Unsupported filesystem type: %s" % fstyp) - convertor._set_fstype(fstype) - try: - convertor.mount(base_on) - __mkinitrd(convertor) - convertor._create_bootconfig() - __run_post_cleanups(convertor) - convertor.launch_shell(convertoropts['shell']) - convertor.unmount() - convertor.package() - convertor.print_outimage_info() - finally: - shutil.rmtree(os.path.dirname(base_on), ignore_errors = True) - - @classmethod - def do_unpack(cls, srcimg): - img = srcimg - imgsize = misc.get_file_size(img) * 1024L * 1024L - imgmnt = misc.mkdtemp() - disk = fs_related.SparseLoopbackDisk(img, imgsize) - imgloop = PartitionedMount(imgmnt, skipformat = True) - imgloop.add_disk('/dev/sdb', disk) - imgloop.add_partition(imgsize/1024/1024, "/dev/sdb", "/", "vfat", boot=False) - try: - imgloop.mount() - except errors.MountError: - imgloop.cleanup() - raise - - # legacy LiveOS filesystem layout support, remove for F9 or F10 - if os.path.exists(imgmnt + "/squashfs.img"): - squashimg = imgmnt + "/squashfs.img" - else: - squashimg = imgmnt + "/LiveOS/squashfs.img" - - tmpoutdir = misc.mkdtemp() - # unsquashfs requires outdir mustn't exist - shutil.rmtree(tmpoutdir, ignore_errors = True) - misc.uncompress_squashfs(squashimg, tmpoutdir) - - try: - # legacy LiveOS filesystem layout support, remove for F9 or F10 - if os.path.exists(tmpoutdir + "/os.img"): - os_image = tmpoutdir + "/os.img" - else: - os_image = tmpoutdir + "/LiveOS/ext3fs.img" - - if not os.path.exists(os_image): - raise errors.CreatorError("'%s' is not a valid live CD ISO : neither " - "LiveOS/ext3fs.img nor os.img exist" %img) - imgname = os.path.basename(srcimg) - imgname = os.path.splitext(imgname)[0] + ".img" - rtimage = os.path.join(tempfile.mkdtemp(dir = "/var/tmp", prefix = "tmp"), imgname) - shutil.copyfile(os_image, rtimage) - - finally: - imgloop.cleanup() - shutil.rmtree(tmpoutdir, ignore_errors = True) - shutil.rmtree(imgmnt, ignore_errors = True) - - return rtimage diff --git a/scripts/lib/mic/plugins/imager/loop_plugin.py b/scripts/lib/mic/plugins/imager/loop_plugin.py deleted file mode 100644 index 2a05b3c238..0000000000 --- a/scripts/lib/mic/plugins/imager/loop_plugin.py +++ /dev/null @@ -1,255 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2011 Intel, 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; 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 General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os -import shutil -import tempfile - -from mic import chroot, msger -from mic.utils import misc, fs_related, errors, cmdln -from mic.conf import configmgr -from mic.plugin import pluginmgr -from mic.imager.loop import LoopImageCreator, load_mountpoints - -from mic.pluginbase import ImagerPlugin -class LoopPlugin(ImagerPlugin): - name = 'loop' - - @classmethod - @cmdln.option("--compress-disk-image", dest="compress_image", - type='choice', choices=("gz", "bz2"), default=None, - help="Same with --compress-image") - # alias to compress-image for compatibility - @cmdln.option("--compress-image", dest="compress_image", - type='choice', choices=("gz", "bz2"), default=None, - help="Compress all loop images with 'gz' or 'bz2'") - @cmdln.option("--shrink", action='store_true', default=False, - help="Whether to shrink loop images to minimal size") - def do_create(self, subcmd, opts, *args): - """${cmd_name}: create loop image - - Usage: - ${name} ${cmd_name} [OPTS] - - ${cmd_option_list} - """ - - if len(args) != 1: - raise errors.Usage("Extra arguments given") - - creatoropts = configmgr.create - ksconf = args[0] - - if creatoropts['runtime'] == "bootstrap": - configmgr._ksconf = ksconf - rt_util.bootstrap_mic() - - recording_pkgs = [] - if len(creatoropts['record_pkgs']) > 0: - recording_pkgs = creatoropts['record_pkgs'] - - if creatoropts['release'] is not None: - if 'name' not in recording_pkgs: - recording_pkgs.append('name') - if 'vcs' not in recording_pkgs: - recording_pkgs.append('vcs') - - configmgr._ksconf = ksconf - - # Called After setting the configmgr._ksconf - # as the creatoropts['name'] is reset there. - if creatoropts['release'] is not None: - creatoropts['outdir'] = "%s/%s/images/%s/" % (creatoropts['outdir'], - creatoropts['release'], - creatoropts['name']) - # try to find the pkgmgr - pkgmgr = None - backends = pluginmgr.get_plugins('backend') - if 'auto' == creatoropts['pkgmgr']: - for key in configmgr.prefer_backends: - if key in backends: - pkgmgr = backends[key] - break - else: - for key in backends.keys(): - if key == creatoropts['pkgmgr']: - pkgmgr = backends[key] - break - - if not pkgmgr: - raise errors.CreatorError("Can't find backend: %s, " - "available choices: %s" % - (creatoropts['pkgmgr'], - ','.join(backends.keys()))) - - creator = LoopImageCreator(creatoropts, - pkgmgr, - opts.compress_image, - opts.shrink) - - if len(recording_pkgs) > 0: - creator._recording_pkgs = recording_pkgs - - image_names = [creator.name + ".img"] - image_names.extend(creator.get_image_names()) - self.check_image_exists(creator.destdir, - creator.pack_to, - image_names, - creatoropts['release']) - - try: - creator.check_depend_tools() - creator.mount(None, creatoropts["cachedir"]) - creator.install() - creator.configure(creatoropts["repomd"]) - creator.copy_kernel() - creator.unmount() - creator.package(creatoropts["outdir"]) - - if creatoropts['release'] is not None: - creator.release_output(ksconf, - creatoropts['outdir'], - creatoropts['release']) - creator.print_outimage_info() - - except errors.CreatorError: - raise - finally: - creator.cleanup() - - msger.info("Finished.") - return 0 - - @classmethod - def _do_chroot_tar(cls, target, cmd=[]): - mountfp_xml = os.path.splitext(target)[0] + '.xml' - if not os.path.exists(mountfp_xml): - raise errors.CreatorError("No mount point file found for this tar " - "image, please check %s" % mountfp_xml) - - import tarfile - tar = tarfile.open(target, 'r') - tmpdir = misc.mkdtemp() - tar.extractall(path=tmpdir) - tar.close() - - mntdir = misc.mkdtemp() - - loops = [] - for (mp, label, name, size, fstype) in load_mountpoints(mountfp_xml): - if fstype in ("ext2", "ext3", "ext4"): - myDiskMount = fs_related.ExtDiskMount - elif fstype == "btrfs": - myDiskMount = fs_related.BtrfsDiskMount - elif fstype in ("vfat", "msdos"): - myDiskMount = fs_related.VfatDiskMount - else: - msger.error("Cannot support fstype: %s" % fstype) - - name = os.path.join(tmpdir, name) - size = size * 1024L * 1024L - loop = myDiskMount(fs_related.SparseLoopbackDisk(name, size), - os.path.join(mntdir, mp.lstrip('/')), - fstype, size, label) - - try: - msger.verbose("Mount %s to %s" % (mp, mntdir + mp)) - fs_related.makedirs(os.path.join(mntdir, mp.lstrip('/'))) - loop.mount() - - except: - loop.cleanup() - for lp in reversed(loops): - chroot.cleanup_after_chroot("img", lp, None, mntdir) - - shutil.rmtree(tmpdir, ignore_errors=True) - raise - - loops.append(loop) - - try: - if len(cmd) != 0: - cmdline = "/usr/bin/env HOME=/root " + ' '.join(cmd) - else: - cmdline = "/usr/bin/env HOME=/root /bin/bash" - chroot.chroot(mntdir, None, cmdline) - except: - raise errors.CreatorError("Failed to chroot to %s." % target) - finally: - for loop in reversed(loops): - chroot.cleanup_after_chroot("img", loop, None, mntdir) - - shutil.rmtree(tmpdir, ignore_errors=True) - - @classmethod - def do_chroot(cls, target, cmd=[]): - if target.endswith('.tar'): - import tarfile - if tarfile.is_tarfile(target): - LoopPlugin._do_chroot_tar(target, cmd) - return - else: - raise errors.CreatorError("damaged tarball for loop images") - - img = target - imgsize = misc.get_file_size(img) * 1024L * 1024L - imgtype = misc.get_image_type(img) - if imgtype == "btrfsimg": - fstype = "btrfs" - myDiskMount = fs_related.BtrfsDiskMount - elif imgtype in ("ext3fsimg", "ext4fsimg"): - fstype = imgtype[:4] - myDiskMount = fs_related.ExtDiskMount - else: - raise errors.CreatorError("Unsupported filesystem type: %s" \ - % imgtype) - - extmnt = misc.mkdtemp() - extloop = myDiskMount(fs_related.SparseLoopbackDisk(img, imgsize), - extmnt, - fstype, - 4096, - "%s label" % fstype) - try: - extloop.mount() - - except errors.MountError: - extloop.cleanup() - shutil.rmtree(extmnt, ignore_errors=True) - raise - - try: - if len(cmd) != 0: - cmdline = ' '.join(cmd) - else: - cmdline = "/bin/bash" - envcmd = fs_related.find_binary_inchroot("env", extmnt) - if envcmd: - cmdline = "%s HOME=/root %s" % (envcmd, cmdline) - chroot.chroot(extmnt, None, cmdline) - except: - raise errors.CreatorError("Failed to chroot to %s." % img) - finally: - chroot.cleanup_after_chroot("img", extloop, None, extmnt) - - @classmethod - def do_unpack(cls, srcimg): - image = os.path.join(tempfile.mkdtemp(dir="/var/tmp", prefix="tmp"), - "target.img") - msger.info("Copying file system ...") - shutil.copyfile(srcimg, image) - return image diff --git a/scripts/lib/mic/plugins/imager/raw_plugin.py b/scripts/lib/mic/plugins/imager/raw_plugin.py deleted file mode 100644 index f9625b87e8..0000000000 --- a/scripts/lib/mic/plugins/imager/raw_plugin.py +++ /dev/null @@ -1,275 +0,0 @@ -#!/usr/bin/python -tt -# -# Copyright (c) 2011 Intel, 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; 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 General Public License -# for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program; if not, write to the Free Software Foundation, Inc., 59 -# Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -import os -import shutil -import re -import tempfile - -from mic import chroot, msger -from mic.utils import misc, fs_related, errors, runner, cmdln -from mic.conf import configmgr -from mic.plugin import pluginmgr -from mic.utils.partitionedfs import PartitionedMount - -import mic.imager.raw as raw - -from mic.pluginbase import ImagerPlugin -class RawPlugin(ImagerPlugin): - name = 'raw' - - @classmethod - @cmdln.option("--compress-disk-image", dest="compress_image", type='choice', - choices=("gz", "bz2"), default=None, - help="Same with --compress-image") - @cmdln.option("--compress-image", dest="compress_image", type='choice', - choices=("gz", "bz2"), default = None, - help="Compress all raw images before package") - @cmdln.option("--generate-bmap", action="store_true", default = None, - help="also generate the block map file") - @cmdln.option("--fstab-entry", dest="fstab_entry", type='choice', - choices=("name", "uuid"), default="uuid", - help="Set fstab entry, 'name' means using device names, " - "'uuid' means using filesystem uuid") - def do_create(self, subcmd, opts, *args): - """${cmd_name}: create raw image - - Usage: - ${name} ${cmd_name} [OPTS] - - ${cmd_option_list} - """ - - if len(args) != 1: - raise errors.Usage("Extra arguments given") - - creatoropts = configmgr.create - ksconf = args[0] - - if creatoropts['runtime'] == "bootstrap": - configmgr._ksconf = ksconf - rt_util.bootstrap_mic() - - recording_pkgs = [] - if len(creatoropts['record_pkgs']) > 0: - recording_pkgs = creatoropts['record_pkgs'] - - if creatoropts['release'] is not None: - if 'name' not in recording_pkgs: - recording_pkgs.append('name') - if 'vcs' not in recording_pkgs: - recording_pkgs.append('vcs') - - configmgr._ksconf = ksconf - - # Called After setting the configmgr._ksconf as the creatoropts['name'] is reset there. - if creatoropts['release'] is not None: - creatoropts['outdir'] = "%s/%s/images/%s/" % (creatoropts['outdir'], creatoropts['release'], creatoropts['name']) - - # try to find the pkgmgr - pkgmgr = None - backends = pluginmgr.get_plugins('backend') - if 'auto' == creatoropts['pkgmgr']: - for key in configmgr.prefer_backends: - if key in backends: - pkgmgr = backends[key] - break - else: - for key in backends.keys(): - if key == creatoropts['pkgmgr']: - pkgmgr = backends[key] - break - - if not pkgmgr: - raise errors.CreatorError("Can't find backend: %s, " - "available choices: %s" % - (creatoropts['pkgmgr'], - ','.join(backends.keys()))) - - creator = raw.RawImageCreator(creatoropts, pkgmgr, opts.compress_image, - opts.generate_bmap, opts.fstab_entry) - - if len(recording_pkgs) > 0: - creator._recording_pkgs = recording_pkgs - - images = ["%s-%s.raw" % (creator.name, disk_name) - for disk_name in creator.get_disk_names()] - self.check_image_exists(creator.destdir, - creator.pack_to, - images, - creatoropts['release']) - - try: - creator.check_depend_tools() - creator.mount(None, creatoropts["cachedir"]) - creator.install() - creator.configure(creatoropts["repomd"]) - creator.copy_kernel() - creator.unmount() - creator.generate_bmap() - creator.package(creatoropts["outdir"]) - if creatoropts['release'] is not None: - creator.release_output(ksconf, creatoropts['outdir'], creatoropts['release']) - creator.print_outimage_info() - - except errors.CreatorError: - raise - finally: - creator.cleanup() - - msger.info("Finished.") - return 0 - - @classmethod - def do_chroot(cls, target, cmd=[]): - img = target - imgsize = misc.get_file_size(img) * 1024L * 1024L - partedcmd = fs_related.find_binary_path("parted") - disk = fs_related.SparseLoopbackDisk(img, imgsize) - imgmnt = misc.mkdtemp() - imgloop = PartitionedMount(imgmnt, skipformat = True) - imgloop.add_disk('/dev/sdb', disk) - img_fstype = "ext3" - - msger.info("Partition Table:") - partnum = [] - for line in runner.outs([partedcmd, "-s", img, "print"]).splitlines(): - # no use strip to keep line output here - if "Number" in line: - msger.raw(line) - if line.strip() and line.strip()[0].isdigit(): - partnum.append(line.strip()[0]) - msger.raw(line) - - rootpart = None - if len(partnum) > 1: - rootpart = msger.choice("please choose root partition", partnum) - - # Check the partitions from raw disk. - # if choose root part, the mark it as mounted - if rootpart: - root_mounted = True - else: - root_mounted = False - partition_mounts = 0 - for line in runner.outs([partedcmd,"-s",img,"unit","B","print"]).splitlines(): - line = line.strip() - - # Lines that start with number are the partitions, - # because parted can be translated we can't refer to any text lines. - if not line or not line[0].isdigit(): - continue - - # Some vars have extra , as list seperator. - line = line.replace(",","") - - # Example of parted output lines that are handled: - # Number Start End Size Type File system Flags - # 1 512B 3400000511B 3400000000B primary - # 2 3400531968B 3656384511B 255852544B primary linux-swap(v1) - # 3 3656384512B 3720347647B 63963136B primary fat16 boot, lba - - partition_info = re.split("\s+",line) - - size = partition_info[3].split("B")[0] - - if len(partition_info) < 6 or partition_info[5] in ["boot"]: - # No filesystem can be found from partition line. Assuming - # btrfs, because that is the only MeeGo fs that parted does - # not recognize properly. - # TODO: Can we make better assumption? - fstype = "btrfs" - elif partition_info[5] in ["ext2","ext3","ext4","btrfs"]: - fstype = partition_info[5] - elif partition_info[5] in ["fat16","fat32"]: - fstype = "vfat" - elif "swap" in partition_info[5]: - fstype = "swap" - else: - raise errors.CreatorError("Could not recognize partition fs type '%s'." % partition_info[5]) - - if rootpart and rootpart == line[0]: - mountpoint = '/' - elif not root_mounted and fstype in ["ext2","ext3","ext4","btrfs"]: - # TODO: Check that this is actually the valid root partition from /etc/fstab - mountpoint = "/" - root_mounted = True - elif fstype == "swap": - mountpoint = "swap" - else: - # TODO: Assing better mount points for the rest of the partitions. - partition_mounts += 1 - mountpoint = "/media/partition_%d" % partition_mounts - - if "boot" in partition_info: - boot = True - else: - boot = False - - msger.verbose("Size: %s Bytes, fstype: %s, mountpoint: %s, boot: %s" % (size, fstype, mountpoint, boot)) - # TODO: add_partition should take bytes as size parameter. - imgloop.add_partition((int)(size)/1024/1024, "/dev/sdb", mountpoint, fstype = fstype, boot = boot) - - try: - imgloop.mount() - - except errors.MountError: - imgloop.cleanup() - raise - - try: - if len(cmd) != 0: - cmdline = ' '.join(cmd) - else: - cmdline = "/bin/bash" - envcmd = fs_related.find_binary_inchroot("env", imgmnt) - if envcmd: - cmdline = "%s HOME=/root %s" % (envcmd, cmdline) - chroot.chroot(imgmnt, None, cmdline) - except: - raise errors.CreatorError("Failed to chroot to %s." %img) - finally: - chroot.cleanup_after_chroot("img", imgloop, None, imgmnt) - - @classmethod - def do_unpack(cls, srcimg): - srcimgsize = (misc.get_file_size(srcimg)) * 1024L * 1024L - srcmnt = misc.mkdtemp("srcmnt") - disk = fs_related.SparseLoopbackDisk(srcimg, srcimgsize) - srcloop = PartitionedMount(srcmnt, skipformat = True) - - srcloop.add_disk('/dev/sdb', disk) - srcloop.add_partition(srcimgsize/1024/1024, "/dev/sdb", "/", "ext3", boot=False) - try: - srcloop.mount() - - except errors.MountError: - srcloop.cleanup() - raise - - image = os.path.join(tempfile.mkdtemp(dir = "/var/tmp", prefix = "tmp"), "target.img") - args = ['dd', "if=%s" % srcloop.partitions[0]['device'], "of=%s" % image] - - msger.info("`dd` image ...") - rc = runner.show(args) - srcloop.cleanup() - shutil.rmtree(os.path.dirname(srcmnt), ignore_errors = True) - - if rc != 0: - raise errors.CreatorError("Failed to dd") - else: - return image diff --git a/scripts/lib/mic/plugins/source/bootimg-efi.py b/scripts/lib/mic/plugins/source/bootimg-efi.py index aecda6b0f1..95e1c059b9 100644 --- a/scripts/lib/mic/plugins/source/bootimg-efi.py +++ b/scripts/lib/mic/plugins/source/bootimg-efi.py @@ -29,7 +29,7 @@ import shutil import re import tempfile -from mic import kickstart, chroot, msger +from mic import kickstart, msger from mic.utils import misc, fs_related, errors, runner, cmdln from mic.conf import configmgr from mic.plugin import pluginmgr diff --git a/scripts/lib/mic/plugins/source/bootimg-pcbios.py b/scripts/lib/mic/plugins/source/bootimg-pcbios.py index 6488ae9729..9959645606 100644 --- a/scripts/lib/mic/plugins/source/bootimg-pcbios.py +++ b/scripts/lib/mic/plugins/source/bootimg-pcbios.py @@ -29,7 +29,7 @@ import shutil import re import tempfile -from mic import kickstart, chroot, msger +from mic import kickstart, msger from mic.utils import misc, fs_related, errors, runner, cmdln from mic.conf import configmgr from mic.plugin import pluginmgr diff --git a/scripts/lib/mic/plugins/source/rootfs.py b/scripts/lib/mic/plugins/source/rootfs.py index a4d4547318..8cb576d5b9 100644 --- a/scripts/lib/mic/plugins/source/rootfs.py +++ b/scripts/lib/mic/plugins/source/rootfs.py @@ -30,7 +30,7 @@ import shutil import re import tempfile -from mic import kickstart, chroot, msger +from mic import kickstart, msger from mic.utils import misc, fs_related, errors, runner, cmdln from mic.conf import configmgr from mic.plugin import pluginmgr -- cgit 1.2.3-korg