summaryrefslogtreecommitdiff
path: root/scripts/lib
diff options
context:
space:
mode:
authorTom Zanussi <tom.zanussi@linux.intel.com>2014-08-04 19:43:15 -0500
committerRichard Purdie <richard.purdie@linuxfoundation.org>2014-08-11 10:52:16 +0100
commit6bd95c24b44fa80ac9d5950bf2d925f18f671290 (patch)
tree570e71ce44c6af0cde53419f6f467365606bc5fb /scripts/lib
parentb818e5a1ed047940fda533da73fc50a099e1aa3f (diff)
downloadopenembedded-core-6bd95c24b44fa80ac9d5950bf2d925f18f671290.tar.gz
openembedded-core-6bd95c24b44fa80ac9d5950bf2d925f18f671290.tar.bz2
openembedded-core-6bd95c24b44fa80ac9d5950bf2d925f18f671290.zip
wic: Clean up BaseImageCreator
wic doesn't use a lot of BaseImageCreator, so remove it. Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Diffstat (limited to 'scripts/lib')
-rw-r--r--scripts/lib/mic/imager/baseimager.py1030
-rw-r--r--scripts/lib/mic/imager/direct.py4
2 files changed, 9 insertions, 1025 deletions
diff --git a/scripts/lib/mic/imager/baseimager.py b/scripts/lib/mic/imager/baseimager.py
index b7212493b4..55f2deaf2c 100644
--- a/scripts/lib/mic/imager/baseimager.py
+++ b/scripts/lib/mic/imager/baseimager.py
@@ -18,37 +18,31 @@
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.errors import CreatorError
from mic.utils import misc, runner, fs_related as fs
class BaseImageCreator(object):
- """Installs a system to a chroot directory.
+ """Base class for image creation.
- ImageCreator is the simplest creator class available; it will install and
- configure a system image according to the supplied kickstart file.
+ BaseImageCreator is the simplest creator class available; it will
+ create 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):
+ def __init__(self, createopts = None):
"""Initialize an ImageCreator instance.
ks -- a pykickstart.KickstartParser instance; this instance will be
@@ -59,36 +53,19 @@ class BaseImageCreator(object):
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",
+ optmap = {"outdir" : "destdir",
}
# update setting from createopts
@@ -101,41 +78,11 @@ class BaseImageCreator(object):
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"]
+ self._dep_checks = ["ls", "bash", "cp", "echo"]
# 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
@@ -144,31 +91,9 @@ class BaseImageCreator(object):
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)
#
@@ -190,23 +115,6 @@ class BaseImageCreator(object):
"""
- 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
@@ -239,408 +147,6 @@ class BaseImageCreator(object):
"""
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
#
@@ -658,64 +164,6 @@ class BaseImageCreator(object):
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
@@ -789,338 +237,6 @@ class BaseImageCreator(object):
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"
@@ -1129,135 +245,3 @@ class BaseImageCreator(object):
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)
diff --git a/scripts/lib/mic/imager/direct.py b/scripts/lib/mic/imager/direct.py
index 7e2b63a37c..93f0cd9e6c 100644
--- a/scripts/lib/mic/imager/direct.py
+++ b/scripts/lib/mic/imager/direct.py
@@ -54,14 +54,14 @@ class DirectImageCreator(BaseImageCreator):
def __init__(self, oe_builddir, image_output_dir, rootfs_dir, bootimg_dir,
kernel_dir, native_sysroot, hdddir, staging_data_dir,
- creatoropts=None, pkgmgr=None, compress_image=None,
+ creatoropts=None, compress_image=None,
generate_bmap=None, fstab_entry="uuid"):
"""
Initialize a DirectImageCreator instance.
This method takes the same arguments as ImageCreator.__init__()
"""
- BaseImageCreator.__init__(self, creatoropts, pkgmgr)
+ BaseImageCreator.__init__(self, creatoropts)
self.__instimage = None
self.__imgdir = None