#!/usr/bin/python -tt
#
# Copyright (c) 2007 Red Hat Inc.
# 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, sys
import stat
import tempfile
import shutil
import subprocess
import re
import tarfile
import glob
from mic import kickstart
from mic import msger
from mic.utils.errors import CreatorError, Abort
from mic.utils import misc, runner, fs_related as fs
class BaseImageCreator(object):
"""Installs a system to a chroot directory.
ImageCreator is the simplest creator class available; it will install and
configure a system image according to the supplied kickstart file.
e.g.
import mic.imgcreate as imgcreate
ks = imgcreate.read_kickstart("foo.ks")
imgcreate.ImageCreator(ks, "foo").create()
"""
def __del__(self):
self.cleanup()
def __init__(self, createopts = None, pkgmgr = None):
"""Initialize an ImageCreator instance.
ks -- a pykickstart.KickstartParser instance; this instance will be
used to drive the install by e.g. providing the list of packages
to be installed, the system configuration and %post scripts
name -- a name for the image; used for e.g. image filenames or
filesystem labels
"""
self.pkgmgr = pkgmgr
self.__builddir = None
self.__bindmounts = []
self.ks = None
self.name = "target"
self.tmpdir = "/var/tmp/wic"
self.cachedir = "/var/tmp/wic/cache"
self.workdir = "/var/tmp/wic/build"
self.destdir = "."
self.installerfw_prefix = "INSTALLERFW_"
self.target_arch = "noarch"
self._local_pkgs_path = None
self.pack_to = None
self.repourl = {}
# If the kernel is save to the destdir when copy_kernel cmd is called.
self._need_copy_kernel = False
# setup tmpfs tmpdir when enabletmpfs is True
self.enabletmpfs = False
if createopts:
# Mapping table for variables that have different names.
optmap = {"pkgmgr" : "pkgmgr_name",
"outdir" : "destdir",
"arch" : "target_arch",
"local_pkgs_path" : "_local_pkgs_path",
"copy_kernel" : "_need_copy_kernel",
}
# update setting from createopts
for key in createopts.keys():
if key in optmap:
option = optmap[key]
else:
option = key
setattr(self, option, createopts[key])
self.destdir = os.path.abspath(os.path.expanduser(self.destdir))
if 'release' in createopts and createopts['release']:
self.name = createopts['release'] + '_' + self.name
if self.pack_to:
if '@NAME@' in self.pack_to:
self.pack_to = self.pack_to.replace('@NAME@', self.name)
(tar, ext) = os.path.splitext(self.pack_to)
if ext in (".gz", ".bz2") and tar.endswith(".tar"):
ext = ".tar" + ext
if ext not in misc.pack_formats:
self.pack_to += ".tar"
self._dep_checks = ["ls", "bash", "cp", "echo", "modprobe"]
# Output image file names
self.outimage = []
# A flag to generate checksum
self._genchecksum = False
self._alt_initrd_name = None
self._recording_pkgs = []
# available size in root fs, init to 0
self._root_fs_avail = 0
# Name of the disk image file that is created.
self._img_name = None
self.image_format = None
# Save qemu emulator file name in order to clean up it finally
self.qemu_emulator = None
# No ks provided when called by convertor, so skip the dependency check
if self.ks:
# If we have btrfs partition we need to check necessary tools
for part in self.ks.handler.partition.partitions:
if part.fstype and part.fstype == "btrfs":
self._dep_checks.append("mkfs.btrfs")
break
if self.target_arch and self.target_arch.startswith("arm"):
for dep in self._dep_checks:
if dep == "extlinux":
self._dep_checks.remove(dep)
if not os.path.exists("/usr/bin/qemu-arm") or \
not misc.is_statically_linked("/usr/bin/qemu-arm"):
self._dep_checks.append("qemu-arm-static")
if os.path.exists("/proc/sys/vm/vdso_enabled"):
vdso_fh = open("/proc/sys/vm/vdso_enabled","r")
vdso_value = vdso_fh.read().strip()
vdso_fh.close()
if (int)(vdso_value) == 1:
msger.warning("vdso is enabled on your host, which might "
"cause problems with arm emulations.\n"
"\tYou can disable vdso with following command before "
"starting image build:\n"
"\techo 0 | sudo tee /proc/sys/vm/vdso_enabled")
# make sure the specified tmpdir and cachedir exist
if not os.path.exists(self.tmpdir):
os.makedirs(self.tmpdir)
if not os.path.exists(self.cachedir):
os.makedirs(self.cachedir)
#
# Properties
#
def __get_instroot(self):
if self.__builddir is None:
raise CreatorError("_instroot is not valid before calling mount()")
return self.__builddir + "/install_root"
_instroot = property(__get_instroot)
"""The location of the install root directory.
This is the directory into which the system is installed. Subclasses may
mount a filesystem image here or copy files to/from here.
Note, this directory does not exist before ImageCreator.mount() is called.
Note also, this is a read-only attribute.
"""
def __get_outdir(self):
if self.__builddir is None:
raise CreatorError("_outdir is not valid before calling mount()")
return self.__builddir + "/out"
_outdir = property(__get_outdir)
"""The staging location for the final image.
This is where subclasses should stage any files that are part of the final
image. ImageCreator.package() will copy any files found here into the
requested destination directory.
Note, this directory does not exist before ImageCreator.mount() is called.
Note also, this is a read-only attribute.
"""
#
# Hooks for subclasses
#
def _mount_instroot(self, base_on = None):
"""Mount or prepare the install root directory.
This is the hook where subclasses may prepare the install root by e.g.
mounting creating and loopback mounting a filesystem image to
_instroot.
There is no default implementation.
base_on -- this is the value passed to mount() and can be interpreted
as the subclass wishes; it might e.g. be the location of
a previously created ISO containing a system image.
"""
pass
def _unmount_instroot(self):
"""Undo anything performed in _mount_instroot().
This is the hook where subclasses must undo anything which was done
in _mount_instroot(). For example, if a filesystem image was mounted
onto _instroot, it should be unmounted here.
There is no default implementation.
"""
pass
def _create_bootconfig(self):
"""Configure the image so that it's bootable.
This is the hook where subclasses may prepare the image for booting by
e.g. creating an initramfs and bootloader configuration.
This hook is called while the install root is still mounted, after the
packages have been installed and the kickstart configuration has been
applied, but before the %post scripts have been executed.
There is no default implementation.
"""
pass
def _stage_final_image(self):
"""Stage the final system image in _outdir.
This is the hook where subclasses should place the image in _outdir
so that package() can copy it to the requested destination directory.
By default, this moves the install root into _outdir.
"""
shutil.move(self._instroot, self._outdir + "/" + self.name)
def get_installed_packages(self):
return self._pkgs_content.keys()
def _save_recording_pkgs(self, destdir):
"""Save the list or content of installed packages to file.
"""
pkgs = self._pkgs_content.keys()
pkgs.sort() # inplace op
if not os.path.exists(destdir):
os.makedirs(destdir)
content = None
if 'vcs' in self._recording_pkgs:
vcslst = ["%s %s" % (k, v) for (k, v) in self._pkgs_vcsinfo.items()]
content = '\n'.join(sorted(vcslst))
elif 'name' in self._recording_pkgs:
content = '\n'.join(pkgs)
if content:
namefile = os.path.join(destdir, self.name + '.packages')
f = open(namefile, "w")
f.write(content)
f.close()
self.outimage.append(namefile);
# if 'content', save more details
if 'content' in self._recording_pkgs:
contfile = os.path.join(destdir, self.name + '.files')
f = open(contfile, "w")
for pkg in pkgs:
content = pkg + '\n'
pkgcont = self._pkgs_content[pkg]
content += ' '
content += '\n '.join(pkgcont)
content += '\n'
content += '\n'
f.write(content)
f.close()
self.outimage.append(contfile)
if 'license' in self._recording_pkgs:
licensefile = os.path.join(destdir, self.name + '.license')
f = open(licensefile, "w")
f.write('Summary:\n')
for license in reversed(sorted(self._pkgs_license, key=\
lambda license: len(self._pkgs_license[license]))):
f.write(" - %s: %s\n" \
% (license, len(self._pkgs_license[license])))
f.write('\nDetails:\n')
for license in reversed(sorted(self._pkgs_license, key=\
lambda license: len(self._pkgs_license[license]))):
f.write(" - %s:\n" % (license))
for pkg in sorted(self._pkgs_license[license]):
f.write(" - %s\n" % (pkg))
f.write('\n')
f.close()
self.outimage.append(licensefile)
def _get_required_packages(self):
"""Return a list of required packages.
This is the hook where subclasses may specify a set of packages which
it requires to be installed.
This returns an empty list by default.
Note, subclasses should usually chain up to the base class
implementation of this hook.
"""
return []
def _get_excluded_packages(self):
"""Return a list of excluded packages.
This is the hook where subclasses may specify a set of packages which
it requires _not_ to be installed.
This returns an empty list by default.
Note, subclasses should usually chain up to the base class
implementation of this hook.
"""
return []
def _get_local_packages(self):
"""Return a list of rpm path to be local installed.
This is the hook where subclasses may specify a set of rpms which
it requires to be installed locally.
This returns an empty list by default.
Note, subclasses should usually chain up to the base class
implementation of this hook.
"""
if self._local_pkgs_path:
if os.path.isdir(self._local_pkgs_path):
return glob.glob(
os.path.join(self._local_pkgs_path, '*.rpm'))
elif os.path.splitext(self._local_pkgs_path)[-1] == '.rpm':
return [self._local_pkgs_path]
return []
def _get_fstab(self):
"""Return the desired contents of /etc/fstab.
This is the hook where subclasses may specify the contents of
/etc/fstab by returning a string containing the desired contents.
A sensible default implementation is provided.
"""
s = "/dev/root / %s %s 0 0\n" \
% (self._fstype,
"defaults,noatime" if not self._fsopts else self._fsopts)
s += self._get_fstab_special()
return s
def _get_fstab_special(self):
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 _set_part_env(self, pnum, prop, value):
""" This is a helper function which generates an environment variable
for a property "prop" with value "value" of a partition number "pnum".
The naming convention is:
* Variables start with INSTALLERFW_PART
* Then goes the partition number, the order is the same as
specified in the KS file
* Then goes the property name
"""
if value == None:
value = ""
else:
value = str(value)
name = self.installerfw_prefix + ("PART%d_" % pnum) + prop
return { name : value }
def _get_post_scripts_env(self, in_chroot):
"""Return an environment dict for %post scripts.
This is the hook where subclasses may specify some environment
variables for %post scripts by return a dict containing the desired
environment.
in_chroot -- whether this %post script is to be executed chroot()ed
into _instroot.
"""
env = {}
pnum = 0
for p in kickstart.get_partitions(self.ks):
env.update(self._set_part_env(pnum, "SIZE", p.size))
env.update(self._set_part_env(pnum, "MOUNTPOINT", p.mountpoint))
env.update(self._set_part_env(pnum, "FSTYPE", p.fstype))
env.update(self._set_part_env(pnum, "LABEL", p.label))
env.update(self._set_part_env(pnum, "FSOPTS", p.fsopts))
env.update(self._set_part_env(pnum, "BOOTFLAG", p.active))
env.update(self._set_part_env(pnum, "ALIGN", p.align))
env.update(self._set_part_env(pnum, "TYPE_ID", p.part_type))
env.update(self._set_part_env(pnum, "DEVNODE",
"/dev/%s%d" % (p.disk, pnum + 1)))
pnum += 1
# Count of paritions
env[self.installerfw_prefix + "PART_COUNT"] = str(pnum)
# Partition table format
ptable_format = self.ks.handler.bootloader.ptable
env[self.installerfw_prefix + "PTABLE_FORMAT"] = ptable_format
# The kerned boot parameters
kernel_opts = self.ks.handler.bootloader.appendLine
env[self.installerfw_prefix + "KERNEL_OPTS"] = kernel_opts
# Name of the distribution
env[self.installerfw_prefix + "DISTRO_NAME"] = self.distro_name
# Name of the image creation tool
env[self.installerfw_prefix + "INSTALLER_NAME"] = "wic"
# The real current location of the mounted file-systems
if in_chroot:
mount_prefix = "/"
else:
mount_prefix = self._instroot
env[self.installerfw_prefix + "MOUNT_PREFIX"] = mount_prefix
# These are historical variables which lack the common name prefix
if not in_chroot:
env["INSTALL_ROOT"] = self._instroot
env["IMG_NAME"] = self._name
return env
def __get_imgname(self):
return self.name
_name = property(__get_imgname)
"""The name of the image file.
"""
def _get_kernel_versions(self):
"""Return a dict detailing the available kernel types/versions.
This is the hook where subclasses may override what kernel types and
versions should be available for e.g. creating the booloader
configuration.
A dict should be returned mapping the available kernel types to a list
of the available versions for those kernels.
The default implementation uses rpm to iterate over everything
providing 'kernel', finds /boot/vmlinuz-* and returns the version
obtained from the vmlinuz filename. (This can differ from the kernel
RPM's n-v-r in the case of e.g. xen)
"""
def get_kernel_versions(instroot):
ret = {}
versions = set()
files = glob.glob(instroot + "/boot/vmlinuz-*")
for file in files:
version = os.path.basename(file)[8:]
if version is None:
continue
versions.add(version)
ret["kernel"] = list(versions)
return ret
def get_version(header):
version = None
for f in header['filenames']:
if f.startswith('/boot/vmlinuz-'):
version = f[14:]
return version
if self.ks is None:
return get_kernel_versions(self._instroot)
ts = rpm.TransactionSet(self._instroot)
ret = {}
for header in ts.dbMatch('provides', 'kernel'):
version = get_version(header)
if version is None:
continue
name = header['name']
if not name in ret:
ret[name] = [version]
elif not version in ret[name]:
ret[name].append(version)
return ret
#
# Helpers for subclasses
#
def _do_bindmounts(self):
"""Mount various system directories onto _instroot.
This method is called by mount(), but may also be used by subclasses
in order to re-mount the bindmounts after modifying the underlying
filesystem.
"""
for b in self.__bindmounts:
b.mount()
def _undo_bindmounts(self):
"""Unmount the bind-mounted system directories from _instroot.
This method is usually only called by unmount(), but may also be used
by subclasses in order to gain access to the filesystem obscured by
the bindmounts - e.g. in order to create device nodes on the image
filesystem.
"""
self.__bindmounts.reverse()
for b in self.__bindmounts:
b.unmount()
def _chroot(self):
"""Chroot into the install root.
This method may be used by subclasses when executing programs inside
the install root e.g.
subprocess.call(["/bin/ls"], preexec_fn = self.chroot)
"""
os.chroot(self._instroot)
os.chdir("/")
def _mkdtemp(self, prefix = "tmp-"):
"""Create a temporary directory.
This method may be used by subclasses to create a temporary directory
for use in building the final image - e.g. a subclass might create
a temporary directory in order to bundle a set of files into a package.
The subclass may delete this directory if it wishes, but it will be
automatically deleted by cleanup().
The absolute path to the temporary directory is returned.
Note, this method should only be called after mount() has been called.
prefix -- a prefix which should be used when creating the directory;
defaults to "tmp-".
"""
self.__ensure_builddir()
return tempfile.mkdtemp(dir = self.__builddir, prefix = prefix)
def _mkstemp(self, prefix = "tmp-"):
"""Create a temporary file.
This method may be used by subclasses to create a temporary file
for use in building the final image - e.g. a subclass might need
a temporary location to unpack a compressed file.
The subclass may delete this file if it wishes, but it will be
automatically deleted by cleanup().
A tuple containing a file descriptor (returned from os.open() and the
absolute path to the temporary directory is returned.
Note, this method should only be called after mount() has been called.
prefix -- a prefix which should be used when creating the file;
defaults to "tmp-".
"""
self.__ensure_builddir()
return tempfile.mkstemp(dir = self.__builddir, prefix = prefix)
def _mktemp(self, prefix = "tmp-"):
"""Create a temporary file.
This method simply calls _mkstemp() and closes the returned file
descriptor.
The absolute path to the temporary file is returned.
Note, this method should only be called after mount() has been called.
prefix -- a prefix which should be used when creating the file;
defaults to "tmp-".
"""
(f, path) = self._mkstemp(prefix)
os.close(f)
return path
#
# Actual implementation
#
def __ensure_builddir(self):
if not self.__builddir is None:
return
try:
self.workdir = os.path.join(self.tmpdir, "build")
if not os.path.exists(self.workdir):
os.makedirs(self.workdir)
self.__builddir = tempfile.mkdtemp(dir = self.workdir,
prefix = "imgcreate-")
except OSError, (err, msg):
raise CreatorError("Failed create build directory in %s: %s" %
(self.tmpdir, msg))
def get_cachedir(self, cachedir = None):
if self.cachedir:
return self.cachedir
self.__ensure_builddir()
if cachedir:
self.cachedir = cachedir
else:
self.cachedir = self.__builddir + "/wic-cache"
fs.makedirs(self.cachedir)
return self.cachedir
def __sanity_check(self):
"""Ensure that the config we've been given is sane."""
if not (kickstart.get_packages(self.ks) or
kickstart.get_groups(self.ks)):
raise CreatorError("No packages or groups specified")
kickstart.convert_method_to_repo(self.ks)
if not kickstart.get_repos(self.ks):
raise CreatorError("No repositories specified")
def __write_fstab(self):
fstab_contents = self._get_fstab()
if fstab_contents:
fstab = open(self._instroot + "/etc/fstab", "w")
fstab.write(fstab_contents)
fstab.close()
def __create_minimal_dev(self):
"""Create a minimal /dev so that we don't corrupt the host /dev"""
origumask = os.umask(0000)
devices = (('null', 1, 3, 0666),
('urandom',1, 9, 0666),
('random', 1, 8, 0666),
('full', 1, 7, 0666),
('ptmx', 5, 2, 0666),
('tty', 5, 0, 0666),
('zero', 1, 5, 0666))
links = (("/proc/self/fd", "/dev/fd"),
("/proc/self/fd/0", "/dev/stdin"),
("/proc/self/fd/1", "/dev/stdout"),
("/proc/self/fd/2", "/dev/stderr"))
for (node, major, minor, perm) in devices:
if not os.path.exists(self._instroot + "/dev/" + node):
os.mknod(self._instroot + "/dev/" + node,
perm | stat.S_IFCHR,
os.makedev(major,minor))
for (src, dest) in links:
if not os.path.exists(self._instroot + dest):
os.symlink(src, self._instroot + dest)
os.umask(origumask)
def __setup_tmpdir(self):
if not self.enabletmpfs:
return
runner.show('mount -t tmpfs -o size=4G tmpfs %s' % self.workdir)
def __clean_tmpdir(self):
if not self.enabletmpfs:
return
runner.show('umount -l %s' % self.workdir)
def mount(self, base_on = None, cachedir = None):
"""Setup the target filesystem in preparation for an install.
This function sets up the filesystem which the ImageCreator will
install into and configure. The ImageCreator class merely creates an
install root directory, bind mounts some system directories (e.g. /dev)
and writes out /etc/fstab. Other subclasses may also e.g. create a
sparse file, format it and loopback mount it to the install root.
base_on -- a previous install on which to base this install; defaults
to None, causing a new image to be created
cachedir -- a directory in which to store the Yum cache; defaults to
None, causing a new cache to be created; by setting this
to another directory, the same cache can be reused across
multiple installs.
"""
self.__setup_tmpdir()
self.__ensure_builddir()
self._mount_instroot(base_on)
def unmount(self):
"""Unmounts the target filesystem.
The ImageCreator class detaches the system from the install root, but
other subclasses may also detach the loopback mounted filesystem image
from the install root.
"""
self._unmount_instroot()
def cleanup(self):
"""Unmounts the target filesystem and deletes temporary files.
This method calls unmount() and then deletes any temporary files and
directories that were created on the host system while building the
image.
Note, make sure to call this method once finished with the creator
instance in order to ensure no stale files are left on the host e.g.:
creator = ImageCreator(ks, name)
try:
creator.create()
finally:
creator.cleanup()
"""
if not self.__builddir:
return
self.unmount()
shutil.rmtree(self.__builddir, ignore_errors = True)
self.__builddir = None
self.__clean_tmpdir()
def __is_excluded_pkg(self, pkg):
if pkg in self._excluded_pkgs:
self._excluded_pkgs.remove(pkg)
return True
for xpkg in self._excluded_pkgs:
if xpkg.endswith('*'):
if pkg.startswith(xpkg[:-1]):
return True
elif xpkg.startswith('*'):
if pkg.endswith(xpkg[1:]):
return True
return None
def __select_packages(self, pkg_manager):
skipped_pkgs = []
for pkg in self._required_pkgs:
e = pkg_manager.selectPackage(pkg)
if e:
if kickstart.ignore_missing(self.ks):
skipped_pkgs.append(pkg)
elif self.__is_excluded_pkg(pkg):
skipped_pkgs.append(pkg)
else:
raise CreatorError("Failed to find package '%s' : %s" %
(pkg, e))
for pkg in skipped_pkgs:
msger.warning("Skipping missing package '%s'" % (pkg,))
def __select_groups(self, pkg_manager):
skipped_groups = []
for group in self._required_groups:
e = pkg_manager.selectGroup(group.name, group.include)
if e:
if kickstart.ignore_missing(self.ks):
skipped_groups.append(group)
else:
raise CreatorError("Failed to find group '%s' : %s" %
(group.name, e))
for group in skipped_groups:
msger.warning("Skipping missing group '%s'" % (group.name,))
def __deselect_packages(self, pkg_manager):
for pkg in self._excluded_pkgs:
pkg_manager.deselectPackage(pkg)
def __localinst_packages(self, pkg_manager):
for rpm_path in self._get_local_packages():
pkg_manager.installLocal(rpm_path)
def __preinstall_packages(self, pkg_manager):
if not self.ks:
return
self._preinstall_pkgs = kickstart.get_pre_packages(self.ks)
for pkg in self._preinstall_pkgs:
pkg_manager.preInstall(pkg)
def __attachment_packages(self, pkg_manager):
if not self.ks:
return
self._attachment = []
for item in kickstart.get_attachment(self.ks):
if item.startswith('/'):
fpaths = os.path.join(self._instroot, item.lstrip('/'))
for fpath in glob.glob(fpaths):
self._attachment.append(fpath)
continue
filelist = pkg_manager.getFilelist(item)
if filelist:
# found rpm in rootfs
for pfile in pkg_manager.getFilelist(item):
fpath = os.path.join(self._instroot, pfile.lstrip('/'))
self._attachment.append(fpath)
continue
# try to retrieve rpm file
(url, proxies) = pkg_manager.package_url(item)
if not url:
msger.warning("Can't get url from repo for %s" % item)
continue
fpath = os.path.join(self.cachedir, os.path.basename(url))
if not os.path.exists(fpath):
# download pkgs
try:
fpath = grabber.myurlgrab(url, fpath, proxies, None)
except CreatorError:
raise
tmpdir = self._mkdtemp()
misc.extract_rpm(fpath, tmpdir)
for (root, dirs, files) in os.walk(tmpdir):
for fname in files:
fpath = os.path.join(root, fname)
self._attachment.append(fpath)
def install(self, repo_urls=None):
"""Install packages into the install root.
This function installs the packages listed in the supplied kickstart
into the install root. By default, the packages are installed from the
repository URLs specified in the kickstart.
repo_urls -- a dict which maps a repository name to a repository URL;
if supplied, this causes any repository URLs specified in
the kickstart to be overridden.
"""
# initialize pkg list to install
if self.ks:
self.__sanity_check()
self._required_pkgs = \
kickstart.get_packages(self.ks, self._get_required_packages())
self._excluded_pkgs = \
kickstart.get_excluded(self.ks, self._get_excluded_packages())
self._required_groups = kickstart.get_groups(self.ks)
else:
self._required_pkgs = None
self._excluded_pkgs = None
self._required_groups = None
pkg_manager = self.get_pkg_manager()
pkg_manager.setup()
if hasattr(self, 'install_pkgs') and self.install_pkgs:
if 'debuginfo' in self.install_pkgs:
pkg_manager.install_debuginfo = True
for repo in kickstart.get_repos(self.ks, repo_urls):
(name, baseurl, mirrorlist, inc, exc,
proxy, proxy_username, proxy_password, debuginfo,
source, gpgkey, disable, ssl_verify, nocache,
cost, priority) = repo
yr = pkg_manager.addRepository(name, baseurl, mirrorlist, proxy,
proxy_username, proxy_password, inc, exc, ssl_verify,
nocache, cost, priority)
if kickstart.exclude_docs(self.ks):
rpm.addMacro("_excludedocs", "1")
rpm.addMacro("_dbpath", "/var/lib/rpm")
rpm.addMacro("__file_context_path", "%{nil}")
if kickstart.inst_langs(self.ks) != None:
rpm.addMacro("_install_langs", kickstart.inst_langs(self.ks))
try:
self.__preinstall_packages(pkg_manager)
self.__select_packages(pkg_manager)
self.__select_groups(pkg_manager)
self.__deselect_packages(pkg_manager)
self.__localinst_packages(pkg_manager)
BOOT_SAFEGUARD = 256L * 1024 * 1024 # 256M
checksize = self._root_fs_avail
if checksize:
checksize -= BOOT_SAFEGUARD
if self.target_arch:
pkg_manager._add_prob_flags(rpm.RPMPROB_FILTER_IGNOREARCH)
pkg_manager.runInstall(checksize)
except CreatorError, e:
raise
except KeyboardInterrupt:
raise
else:
self._pkgs_content = pkg_manager.getAllContent()
self._pkgs_license = pkg_manager.getPkgsLicense()
self._pkgs_vcsinfo = pkg_manager.getVcsInfo()
self.__attachment_packages(pkg_manager)
finally:
pkg_manager.close()
# hook post install
self.postinstall()
# do some clean up to avoid lvm info leakage. this sucks.
for subdir in ("cache", "backup", "archive"):
lvmdir = self._instroot + "/etc/lvm/" + subdir
try:
for f in os.listdir(lvmdir):
os.unlink(lvmdir + "/" + f)
except:
pass
def postinstall(self):
self.copy_attachment()
def __run_post_scripts(self):
msger.info("Running scripts ...")
if os.path.exists(self._instroot + "/tmp"):
shutil.rmtree(self._instroot + "/tmp")
os.mkdir (self._instroot + "/tmp", 0755)
for s in kickstart.get_post_scripts(self.ks):
(fd, path) = tempfile.mkstemp(prefix = "ks-script-",
dir = self._instroot + "/tmp")
s.script = s.script.replace("\r", "")
os.write(fd, s.script)
os.close(fd)
os.chmod(path, 0700)
env = self._get_post_scripts_env(s.inChroot)
if not s.inChroot:
preexec = None
script = path
else:
preexec = self._chroot
script = "/tmp/" + os.path.basename(path)
try:
try:
subprocess.call([s.interp, script],
preexec_fn = preexec,
env = env,
stdout = sys.stdout,
stderr = sys.stderr)
except OSError, (err, msg):
raise CreatorError("Failed to execute %%post script "
"with '%s' : %s" % (s.interp, msg))
finally:
os.unlink(path)
def __save_repo_keys(self, repodata):
if not repodata:
return None
gpgkeydir = "/etc/pki/rpm-gpg"
fs.makedirs(self._instroot + gpgkeydir)
for repo in repodata:
if repo["repokey"]:
repokey = gpgkeydir + "/RPM-GPG-KEY-%s" % repo["name"]
shutil.copy(repo["repokey"], self._instroot + repokey)
def configure(self, repodata = None):
"""Configure the system image according to the kickstart.
This method applies the (e.g. keyboard or network) configuration
specified in the kickstart and executes the kickstart %post scripts.
If necessary, it also prepares the image to be bootable by e.g.
creating an initrd and bootloader configuration.
"""
ksh = self.ks.handler
msger.info('Applying configurations ...')
try:
kickstart.LanguageConfig(self._instroot).apply(ksh.lang)
kickstart.KeyboardConfig(self._instroot).apply(ksh.keyboard)
kickstart.TimezoneConfig(self._instroot).apply(ksh.timezone)
#kickstart.AuthConfig(self._instroot).apply(ksh.authconfig)
kickstart.FirewallConfig(self._instroot).apply(ksh.firewall)
kickstart.RootPasswordConfig(self._instroot).apply(ksh.rootpw)
kickstart.UserConfig(self._instroot).apply(ksh.user)
kickstart.ServicesConfig(self._instroot).apply(ksh.services)
kickstart.XConfig(self._instroot).apply(ksh.xconfig)
kickstart.NetworkConfig(self._instroot).apply(ksh.network)
kickstart.RPMMacroConfig(self._instroot).apply(self.ks)
kickstart.DesktopConfig(self._instroot).apply(ksh.desktop)
self.__save_repo_keys(repodata)
kickstart.MoblinRepoConfig(self._instroot).apply(ksh.repo, repodata, self.repourl)
except:
msger.warning("Failed to apply configuration to image")
raise
self._create_bootconfig()
self.__run_post_scripts()
def launch_shell(self, launch):
"""Launch a shell in the install root.
This method is launches a bash shell chroot()ed in the install root;
this can be useful for debugging.
"""
if launch:
msger.info("Launching shell. Exit to continue.")
subprocess.call(["/bin/bash"], preexec_fn = self._chroot)
def do_genchecksum(self, image_name):
if not self._genchecksum:
return
md5sum = misc.get_md5sum(image_name)
with open(image_name + ".md5sum", "w") as f:
f.write("%s %s" % (md5sum, os.path.basename(image_name)))
self.outimage.append(image_name+".md5sum")
def package(self, destdir = "."):
"""Prepares the created image for final delivery.
In its simplest form, this method merely copies the install root to the
supplied destination directory; other subclasses may choose to package
the image by e.g. creating a bootable ISO containing the image and
bootloader configuration.
destdir -- the directory into which the final image should be moved;
this defaults to the current directory.
"""
self._stage_final_image()
if not os.path.exists(destdir):
fs.makedirs(destdir)
if self._recording_pkgs:
self._save_recording_pkgs(destdir)
# For image formats with two or multiple image files, it will be
# better to put them under a directory
if self.image_format in ("raw", "vmdk", "vdi", "nand", "mrstnand"):
destdir = os.path.join(destdir, "%s-%s" \
% (self.name, self.image_format))
msger.debug("creating destination dir: %s" % destdir)
fs.makedirs(destdir)
# Ensure all data is flushed to _outdir
runner.quiet('sync')
misc.check_space_pre_cp(self._outdir, destdir)
for f in os.listdir(self._outdir):
shutil.move(os.path.join(self._outdir, f),
os.path.join(destdir, f))
self.outimage.append(os.path.join(destdir, f))
self.do_genchecksum(os.path.join(destdir, f))
def print_outimage_info(self):
msg = "The new image can be found here:\n"
self.outimage.sort()
for file in self.outimage:
msg += ' %s\n' % os.path.abspath(file)
msger.info(msg)
def check_depend_tools(self):
for tool in self._dep_checks:
fs.find_binary_path(tool)
def package_output(self, image_format, destdir = ".", package="none"):
if not package or package == "none":
return
destdir = os.path.abspath(os.path.expanduser(destdir))
(pkg, comp) = os.path.splitext(package)
if comp:
comp=comp.lstrip(".")
if pkg == "tar":
if comp:
dst = "%s/%s-%s.tar.%s" %\
(destdir, self.name, image_format, comp)
else:
dst = "%s/%s-%s.tar" %\
(destdir, self.name, image_format)
msger.info("creating %s" % dst)
tar = tarfile.open(dst, "w:" + comp)
for file in self.outimage:
msger.info("adding %s to %s" % (file, dst))
tar.add(file,
arcname=os.path.join("%s-%s" \
% (self.name, image_format),
os.path.basename(file)))
if os.path.isdir(file):
shutil.rmtree(file, ignore_errors = True)
else:
os.remove(file)
tar.close()
'''All the file in outimage has been packaged into tar.* file'''
self.outimage = [dst]
def release_output(self, config, destdir, release):
""" Create release directory and files
"""
def _rpath(fn):
""" release path """
return os.path.join(destdir, fn)
outimages = self.outimage
# new ks
new_kspath = _rpath(self.name+'.ks')
with open(config) as fr:
with open(new_kspath, "w") as wf:
# When building a release we want to make sure the .ks
# file generates the same build even when --release not used.
wf.write(fr.read().replace("@BUILD_ID@", release))
outimages.append(new_kspath)
# save log file, logfile is only available in creator attrs
if hasattr(self, 'logfile') and not self.logfile:
log_path = _rpath(self.name + ".log")
# touch the log file, else outimages will filter it out
with open(log_path, 'w') as wf:
wf.write('')
msger.set_logfile(log_path)
outimages.append(_rpath(self.name + ".log"))
# rename iso and usbimg
for f in os.listdir(destdir):
if f.endswith(".iso"):
newf = f[:-4] + '.img'
elif f.endswith(".usbimg"):
newf = f[:-7] + '.img'
else:
continue
os.rename(_rpath(f), _rpath(newf))
outimages.append(_rpath(newf))
# generate MD5SUMS
with open(_rpath("MD5SUMS"), "w") as wf:
for f in os.listdir(destdir):
if f == "MD5SUMS":
continue
if os.path.isdir(os.path.join(destdir, f)):
continue
md5sum = misc.get_md5sum(_rpath(f))
# There needs to be two spaces between the sum and
# filepath to match the syntax with md5sum.
# This way also md5sum -c MD5SUMS can be used by users
wf.write("%s *%s\n" % (md5sum, f))
outimages.append("%s/MD5SUMS" % destdir)
# Filter out the nonexist file
for fp in outimages[:]:
if not os.path.exists("%s" % fp):
outimages.remove(fp)
def copy_kernel(self):
""" Copy kernel files to the outimage directory.
NOTE: This needs to be called before unmounting the instroot.
"""
if not self._need_copy_kernel:
return
if not os.path.exists(self.destdir):
os.makedirs(self.destdir)
for kernel in glob.glob("%s/boot/vmlinuz-*" % self._instroot):
kernelfilename = "%s/%s-%s" % (self.destdir,
self.name,
os.path.basename(kernel))
msger.info('copy kernel file %s as %s' % (os.path.basename(kernel),
kernelfilename))
shutil.copy(kernel, kernelfilename)
self.outimage.append(kernelfilename)
def copy_attachment(self):
""" Subclass implement it to handle attachment files
NOTE: This needs to be called before unmounting the instroot.
"""
pass
def get_pkg_manager(self):
return self.pkgmgr(target_arch = self.target_arch,
instroot = self._instroot,
cachedir = self.cachedir)