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.__ensure_builddir()
fs.makedirs(self._instroot)
fs.makedirs(self._outdir)
self._mount_instroot(base_on)
for d in ("/dev/pts",
"/etc",
"/boot",
"/var/log",
"/sys",
"/proc",
"/usr/bin"):
fs.makedirs(self._instroot + d)
if self.target_arch and self.target_arch.startswith("arm"):
self.qemu_emulator = misc.setup_qemu_emulator(self._instroot,
self.target_arch)
self.get_cachedir(cachedir)
# bind mount system directories into _instroot
for (f, dest) in [("/sys", None),
("/proc", None),
("/proc/sys/fs/binfmt_misc", None),
("/dev/pts", None)]:
self.__bindmounts.append(fs.BindChrootMount(f, self._instroot, dest))
self._do_bindmounts()
self.__create_minimal_dev()
if os.path.exists(self._instroot + "/etc/mtab"):
os.unlink(self._instroot + "/etc/mtab")
os.symlink("../proc/mounts", self._instroot + "/etc/mtab")
self.__write_fstab()
# get size of available space in 'instroot' fs
self._root_fs_avail = misc.get_filesystem_avail(self._instroot)
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()
# prevent popup dialog in Ubuntu(s)
misc.hide_loopdev_presentation()
fs.makedirs(self._instroot)
fs.makedirs(self._outdir)
self._mount_instroot(base_on)
for d in ("/dev/pts", "/etc", "/boot", "/var/log", "/sys", "/proc",
"/usr/bin"):
fs.makedirs(self._instroot + d)
if self.target_arch and self.target_arch.startswith("arm"):
self.qemu_emulator = misc.setup_qemu_emulator(
self._instroot, self.target_arch)
self.get_cachedir(cachedir)
# bind mount system directories into _instroot
for (f, dest) in [("/sys", None), ("/proc", None),
("/proc/sys/fs/binfmt_misc", None),
("/dev/pts", None)]:
self.__bindmounts.append(
fs.BindChrootMount(f, self._instroot, dest))
self._do_bindmounts()
self.__create_minimal_dev()
if os.path.exists(self._instroot + "/etc/mtab"):
os.unlink(self._instroot + "/etc/mtab")
os.symlink("../proc/mounts", self._instroot + "/etc/mtab")
self.__write_fstab()
# get size of available space in 'instroot' fs
self._root_fs_avail = misc.get_filesystem_avail(self._instroot)
cached_count = 0
download_total_size = sum(map(lambda x: int(x.packagesize), dlpkgs))
msger.info("\nChecking packages cache and packages integrity ...")
for po in dlpkgs:
local = po.localPkg()
if not os.path.exists(local):
continue
if not self.verifyPkg(local, po, False):
msger.warning("Package %s is damaged: %s" \
% (os.path.basename(local), local))
else:
download_total_size -= int(po.packagesize)
cached_count += 1
cache_avail_size = misc.get_filesystem_avail(self.cachedir)
if cache_avail_size < download_total_size:
raise CreatorError("No enough space used for downloading.")
# record the total size of installed pkgs
pkgs_total_size = 0L
for x in dlpkgs:
if hasattr(x, 'installedsize'):
pkgs_total_size += int(x.installedsize)
else:
pkgs_total_size += int(x.size)
# check needed size before actually download and install
if checksize and pkgs_total_size > checksize:
raise CreatorError("No enough space used for installing, "
"please resize partition size in ks file")
def runInstall(self, checksize = 0):
os.environ["HOME"] = "/"
os.environ["LD_PRELOAD"] = ""
self.buildTransaction()
todo = zypp.GetResolvablesToInsDel(self.Z.pool())
installed_pkgs = todo._toInstall
dlpkgs = []
for pitem in installed_pkgs:
if not zypp.isKindPattern(pitem) and \
not self.inDeselectPackages(pitem):
item = zypp.asKindPackage(pitem)
dlpkgs.append(item)
if not self.install_debuginfo or str(item.arch()) == "noarch":
continue
dipkg = self._zyppQueryPackage("%s-debuginfo" % item.name())
if dipkg:
ditem = zypp.asKindPackage(dipkg)
dlpkgs.append(ditem)
else:
msger.warning("No debuginfo rpm found for: %s" \
% item.name())
# record all pkg and the content
localpkgs = self.localpkgs.keys()
for pkg in dlpkgs:
license = ''
if pkg.name() in localpkgs:
hdr = rpmmisc.readRpmHeader(self.ts, self.localpkgs[pkg.name()])
pkg_long_name = misc.RPM_FMT % {
'name': hdr['name'],
'arch': hdr['arch'],
'version': hdr['version'],
'release': hdr['release']
}
license = hdr['license']
else:
pkg_long_name = misc.RPM_FMT % {
'name': pkg.name(),
'arch': pkg.arch(),
'version': pkg.edition().version(),
'release': pkg.edition().release()
}
license = pkg.license()
if license in self.__pkgs_license.keys():
self.__pkgs_license[license].append(pkg_long_name)
else:
self.__pkgs_license[license] = [pkg_long_name]
total_count = len(dlpkgs)
cached_count = 0
download_total_size = sum(map(lambda x: int(x.downloadSize()), dlpkgs))
localpkgs = self.localpkgs.keys()
msger.info("Checking packages cached ...")
for po in dlpkgs:
# Check if it is cached locally
if po.name() in localpkgs:
cached_count += 1
else:
local = self.getLocalPkgPath(po)
name = str(po.repoInfo().name())
try:
repo = filter(lambda r: r.name == name, self.repos)[0]
except IndexError:
repo = None
nocache = repo.nocache if repo else False
if os.path.exists(local):
if nocache or self.checkPkg(local) !=0:
os.unlink(local)
else:
download_total_size -= int(po.downloadSize())
cached_count += 1
cache_avail_size = misc.get_filesystem_avail(self.cachedir)
if cache_avail_size < download_total_size:
raise CreatorError("No enough space used for downloading.")
# record the total size of installed pkgs
install_total_size = sum(map(lambda x: int(x.installSize()), dlpkgs))
# check needed size before actually download and install
# FIXME: for multiple partitions for loop type, check fails
# skip the check temporarily
#if checksize and install_total_size > checksize:
# raise CreatorError("No enough space used for installing, "
# "please resize partition size in ks file")
download_count = total_count - cached_count
msger.info("Packages: %d Total, %d Cached, %d Missed" \
% (total_count, cached_count, download_count))
try:
if download_count > 0:
msger.info("Downloading packages ...")
self.downloadPkgs(dlpkgs, download_count)
self.installPkgs(dlpkgs)
except (RepoError, RpmError):
raise
except Exception, e:
raise CreatorError("Package installation failed: %s" % (e,))
def runInstall(self, checksize=0):
#FIXME: WHY? os.environ["HOME"] = "/"
os.environ["LD_PRELOAD"] = ""
try:
(res, resmsg) = self.buildTransaction()
except yum.Errors.RepoError as e:
raise CreatorError("Unable to download from repo : %s" % (e, ))
if res != 2:
raise CreatorError("Failed to build transaction : %s" \
% str.join("\n", resmsg))
dlpkgs = [
x.po for x in [
txmbr for txmbr in self.tsInfo.getMembers()
if txmbr.ts_state in ("i", "u")
]
]
# record all pkg and the content
for pkg in dlpkgs:
pkg_long_name = misc.RPM_FMT % {
'name': pkg.name,
'arch': pkg.arch,
'ver_rel': pkg.printVer(),
}
self.__pkgs_content[pkg_long_name] = pkg.files
license = pkg.license
if license in list(self.__pkgs_license.keys()):
self.__pkgs_license[license].append(pkg_long_name)
else:
self.__pkgs_license[license] = [pkg_long_name]
total_count = len(dlpkgs)
cached_count = 0
download_total_size = sum([int(x.packagesize) for x in dlpkgs])
msger.info("\nChecking packages cache and packages integrity ...")
for po in dlpkgs:
local = po.localPkg()
if not os.path.exists(local):
continue
if not self.verifyPkg(local, po, False):
msger.warning("Package %s is damaged: %s" \
% (os.path.basename(local), local))
else:
download_total_size -= int(po.packagesize)
cached_count += 1
cache_avail_size = misc.get_filesystem_avail(self.cachedir)
if cache_avail_size < download_total_size:
raise CreatorError("No enough space used for downloading.")
# record the total size of installed pkgs
pkgs_total_size = 0
for x in dlpkgs:
if hasattr(x, 'installedsize'):
pkgs_total_size += int(x.installedsize)
else:
pkgs_total_size += int(x.size)
# check needed size before actually download and install
if checksize and pkgs_total_size > checksize:
raise CreatorError("No enough space used for installing, "
"please resize partition size in ks file")
msger.info("%d packages to be installed, "
"%d packages gotten from cache, "
"%d packages to be downloaded" \
% (total_count, cached_count, total_count - cached_count))
try:
repos = self.repos.listEnabled()
for repo in repos:
repo.setCallback(
rpmmisc.TextProgress(total_count - cached_count))
self.downloadPkgs(dlpkgs)
# FIXME: sigcheck?
self.initActionTs()
self.populateTs(keepold=0)
deps = self.ts.check()
if len(deps) != 0:
# This isn't fatal, Ubuntu has this issue but it is ok.
msger.debug(deps)
msger.warning("Dependency check failed!")
rc = self.ts.order()
if rc != 0:
raise CreatorError("ordering packages for installation failed")
# FIXME: callback should be refactored a little in yum
cb = rpmmisc.RPMInstallCallback(self.ts)
cb.tsInfo = self.tsInfo
cb.filelog = False
msger.warning('\nCaution, do NOT interrupt the installation, '
'else mic cannot finish the cleanup.')
installlogfile = "%s/__catched_stderr.buf" % (self.instroot)
msger.enable_logstderr(installlogfile)
self.runTransaction(cb)
self._cleanupRpmdbLocks(self.conf.installroot)
except rpmUtils.RpmUtilsError as e:
raise CreatorError("mic does NOT support delta rpm: %s" % e)
except yum.Errors.RepoError as e:
raise CreatorError("Unable to download from repo : %s" % e)
except yum.Errors.YumBaseError as e:
raise CreatorError("Unable to install: %s" % e)
finally:
msger.disable_logstderr()
def runInstall(self, checksize = 0):
os.environ["HOME"] = "/"
self.buildTransaction()
todo = zypp.GetResolvablesToInsDel(self.Z.pool())
installed_pkgs = todo._toInstall
dlpkgs = []
for item in installed_pkgs:
if not zypp.isKindPattern(item) and \
not self.inDeselectPackages(item):
dlpkgs.append(item)
# record all pkg and the content
localpkgs = self.localpkgs.keys()
for pkg in dlpkgs:
license = ''
if pkg.name() in localpkgs:
hdr = rpmmisc.readRpmHeader(self.ts, self.localpkgs[pkg.name()])
pkg_long_name = misc.RPM_FMT % {
'name': hdr['name'],
'arch': hdr['arch'],
'ver_rel': '%s-%s' % (hdr['version'],
hdr['release']),
}
license = hdr['license']
else:
pkg_long_name = misc.RPM_FMT % {
'name': pkg.name(),
'arch': pkg.arch(),
'ver_rel': pkg.edition(),
}
package = zypp.asKindPackage(pkg)
license = package.license()
self.__pkgs_content[pkg_long_name] = {} #TBD: to get file list
if license in self.__pkgs_license.keys():
self.__pkgs_license[license].append(pkg_long_name)
else:
self.__pkgs_license[license] = [pkg_long_name]
total_count = len(dlpkgs)
cached_count = 0
download_total_size = sum(map(lambda x: int(x.downloadSize()), dlpkgs))
localpkgs = self.localpkgs.keys()
msger.info("Checking packages cache and packages integrity ...")
for po in dlpkgs:
# Check if it is cached locally
if po.name() in localpkgs:
cached_count += 1
else:
local = self.getLocalPkgPath(po)
if os.path.exists(local):
if self.checkPkg(local) != 0:
os.unlink(local)
else:
download_total_size -= int(po.downloadSize())
cached_count += 1
cache_avail_size = misc.get_filesystem_avail(self.cachedir)
if cache_avail_size < download_total_size:
raise CreatorError("No enough space used for downloading.")
# record the total size of installed pkgs
install_total_size = sum(map(lambda x: int(x.installSize()), dlpkgs))
# check needed size before actually download and install
# FIXME: for multiple partitions for loop type, check fails
# skip the check temporarily
#if checksize and install_total_size > checksize:
# raise CreatorError("No enough space used for installing, "
# "please resize partition size in ks file")
download_count = total_count - cached_count
msger.info("%d packages to be installed, "
"%d packages gotten from cache, "
"%d packages to be downloaded" \
% (total_count, cached_count, download_count))
try:
if download_count > 0:
msger.info("Downloading packages ...")
self.downloadPkgs(dlpkgs, download_count)
self.installPkgs(dlpkgs)
except (RepoError, RpmError):
raise
except Exception, e:
raise CreatorError("Package installation failed: %s" % (e,))
def runInstall(self, checksize = 0):
#FIXME: WHY? os.environ["HOME"] = "/"
os.environ["LD_PRELOAD"] = ""
self.buildTransaction()
todo = zypp.GetResolvablesToInsDel(self.Z.pool())
installed_pkgs = todo._toInstall
dlpkgs = []
for xitem in installed_pkgs:
if not zypp.isKindPattern(xitem):
item = self._castKind(xitem)
if not self.inDeselectPackages(item):
dlpkgs.append(item)
msger.debug("%s is going to be installed" % item.name())
# record all pkg and the content
localpkgs = list(self.localpkgs.keys())
for package in dlpkgs:
license = ''
if package.name() in localpkgs:
hdr = rpmmisc.readRpmHeader(self.ts, self.localpkgs[package.name()])
pkg_long_name = misc.RPM_FMT % {
'name': hdr['name'],
'arch': hdr['arch'],
'ver_rel': '%s-%s' % (hdr['version'],
hdr['release']),
}
license = hdr['license']
else:
pkg_long_name = misc.RPM_FMT % {
'name': package.name(),
'arch': package.arch(),
'ver_rel': package.edition(),
}
license = package.license()
self.__pkgs_content[pkg_long_name] = {} #TBD: to get file list
self.__pkgs_urls[pkg_long_name] = self.get_url(package)
if license in list(self.__pkgs_license.keys()):
self.__pkgs_license[license].append(pkg_long_name)
else:
self.__pkgs_license[license] = [pkg_long_name]
total_count = len(dlpkgs)
cached_count = 0
download_total_size = sum([int(x.downloadSize()) for x in dlpkgs])
localpkgs = list(self.localpkgs.keys())
msger.info("Checking packages cache and packages integrity ...")
for po in dlpkgs:
# Check if it is cached locally
if po.name() in localpkgs:
cached_count += 1
else:
local = self.getLocalPkgPath(po)
if os.path.exists(local):
if self.checkPkg(local, po.checksum()) != 0:
os.unlink(local)
else:
download_total_size -= int(po.downloadSize())
cached_count += 1
cache_avail_size = misc.get_filesystem_avail(self.cachedir)
if cache_avail_size < download_total_size:
raise CreatorError("No enough space used for downloading.")
# record the total size of installed pkgs
install_total_size = sum([int(x.installSize()) for x in dlpkgs])
# check needed size before actually download and install
# FIXME: for multiple partitions for loop type, check fails
# skip the check temporarily
#if checksize and install_total_size > checksize:
# raise CreatorError("No enough space used for installing, "
# "please resize partition size in ks file")
download_count = total_count - cached_count
msger.info("%d packages to be installed, "
"%d packages gotten from cache, "
"%d packages to be downloaded" \
% (total_count, cached_count, download_count))
try:
if download_count > 0:
msger.info("Downloading packages ...")
self.downloadPkgs(dlpkgs, download_count)
self.installPkgs(dlpkgs)
except (RepoError, RpmError):
raise
except Exception as e:
raise CreatorError("Package installation failed: %s" % (e,))
cached_count = 0
download_total_size = sum(map(lambda x: int(x.packagesize), dlpkgs))
msger.info("\nChecking packages cache and packages integrity ...")
for po in dlpkgs:
local = po.localPkg()
if not os.path.exists(local):
continue
if not self.verifyPkg(local, po, False):
msger.warning("Package %s is damaged: %s" \
% (os.path.basename(local), local))
else:
download_total_size -= int(po.packagesize)
cached_count +=1
cache_avail_size = misc.get_filesystem_avail(self.cachedir)
if cache_avail_size < download_total_size:
raise CreatorError("No enough space used for downloading.")
# record the total size of installed pkgs
pkgs_total_size = 0L
for x in dlpkgs:
if hasattr(x, 'installedsize'):
pkgs_total_size += int(x.installedsize)
else:
pkgs_total_size += int(x.size)
# check needed size before actually download and install
if checksize and pkgs_total_size > checksize:
raise CreatorError("No enough space used for installing, "
"please resize partition size in ks file")
def runInstall(self, checksize = 0):
os.environ["HOME"] = "/"
os.environ["LD_PRELOAD"] = ""
self.buildTransaction()
todo = zypp.GetResolvablesToInsDel(self.Z.pool())
installed_pkgs = todo._toInstall
dlpkgs = []
for pitem in installed_pkgs:
if not zypp.isKindPattern(pitem) and \
not self.inDeselectPackages(pitem):
item = zypp.asKindPackage(pitem)
dlpkgs.append(item)
if item.name() in self.check_pkgs:
self.check_pkgs.remove(item.name())
if not self.install_debuginfo or str(item.arch()) == "noarch":
continue
dipkg = self._zyppQueryPackage("%s-debuginfo" % item.name())
if dipkg:
ditem = zypp.asKindPackage(dipkg)
dlpkgs.append(ditem)
else:
msger.warning("No debuginfo rpm found for: %s" \
% item.name())
if self.check_pkgs:
raise CreatorError('Packages absent in image: %s' % ','.join(self.check_pkgs))
# record all pkg and the content
localpkgs = self.localpkgs.keys()
for pkg in dlpkgs:
license = ''
if pkg.name() in localpkgs:
hdr = rpmmisc.readRpmHeader(self.ts, self.localpkgs[pkg.name()])
pkg_long_name = misc.RPM_FMT % {
'name': hdr['name'],
'arch': hdr['arch'],
'version': hdr['version'],
'release': hdr['release']
}
license = hdr['license']
else:
pkg_long_name = misc.RPM_FMT % {
'name': pkg.name(),
'arch': pkg.arch(),
'version': pkg.edition().version(),
'release': pkg.edition().release()
}
license = pkg.license()
if license in self.__pkgs_license.keys():
self.__pkgs_license[license].append(pkg_long_name)
else:
self.__pkgs_license[license] = [pkg_long_name]
total_count = len(dlpkgs)
cached_count = 0
download_total_size = sum(map(lambda x: int(x.downloadSize()), dlpkgs))
localpkgs = self.localpkgs.keys()
msger.info("Checking packages cached ...")
for po in dlpkgs:
# Check if it is cached locally
if po.name() in localpkgs:
cached_count += 1
else:
local = self.getLocalPkgPath(po)
name = str(po.repoInfo().name())
try:
repo = filter(lambda r: r.name == name, self.repos)[0]
except IndexError:
repo = None
nocache = repo.nocache if repo else False
if os.path.exists(local):
if nocache or self.checkPkg(local) !=0:
os.unlink(local)
else:
download_total_size -= int(po.downloadSize())
cached_count += 1
cache_avail_size = misc.get_filesystem_avail(self.cachedir)
if cache_avail_size < download_total_size:
raise CreatorError("No enough space used for downloading.")
# record the total size of installed pkgs
install_total_size = sum(map(lambda x: int(x.installSize()), dlpkgs))
# check needed size before actually download and install
# FIXME: for multiple partitions for loop type, check fails
# skip the check temporarily
#if checksize and install_total_size > checksize:
# raise CreatorError("No enough space used for installing, "
# "please resize partition size in ks file")
download_count = total_count - cached_count
msger.info("Packages: %d Total, %d Cached, %d Missed" \
% (total_count, cached_count, download_count))
try:
if download_count > 0:
msger.info("Downloading packages ...")
self.downloadPkgs(dlpkgs, download_count)
except CreatorError, e:
raise CreatorError("Package download failed: %s" %(e,))
def runInstall(self, checksize=0):
os.environ["HOME"] = "/"
self.buildTransaction()
todo = zypp.GetResolvablesToInsDel(self.Z.pool())
installed_pkgs = todo._toInstall
dlpkgs = []
for item in installed_pkgs:
if not zypp.isKindPattern(item) and \
not self.inDeselectPackages(item):
dlpkgs.append(item)
# record all pkg and the content
localpkgs = self.localpkgs.keys()
for pkg in dlpkgs:
license = ''
if pkg.name() in localpkgs:
hdr = rpmmisc.readRpmHeader(self.ts,
self.localpkgs[pkg.name()])
pkg_long_name = misc.RPM_FMT % {
'name': hdr['name'],
'arch': hdr['arch'],
'ver_rel': '%s-%s' % (hdr['version'], hdr['release']),
}
license = hdr['license']
else:
pkg_long_name = misc.RPM_FMT % {
'name': pkg.name(),
'arch': pkg.arch(),
'ver_rel': pkg.edition(),
}
package = zypp.asKindPackage(pkg)
license = package.license()
self.__pkgs_content[pkg_long_name] = {} #TBD: to get file list
if license in self.__pkgs_license.keys():
self.__pkgs_license[license].append(pkg_long_name)
else:
self.__pkgs_license[license] = [pkg_long_name]
total_count = len(dlpkgs)
cached_count = 0
download_total_size = sum(map(lambda x: int(x.downloadSize()), dlpkgs))
localpkgs = self.localpkgs.keys()
msger.info("Checking packages cache and packages integrity ...")
for po in dlpkgs:
# Check if it is cached locally
if po.name() in localpkgs:
cached_count += 1
else:
local = self.getLocalPkgPath(po)
if os.path.exists(local):
if self.checkPkg(local) != 0:
os.unlink(local)
else:
download_total_size -= int(po.downloadSize())
cached_count += 1
cache_avail_size = misc.get_filesystem_avail(self.cachedir)
if cache_avail_size < download_total_size:
raise CreatorError("No enough space used for downloading.")
# record the total size of installed pkgs
install_total_size = sum(map(lambda x: int(x.installSize()), dlpkgs))
# check needed size before actually download and install
if checksize and install_total_size > checksize:
raise CreatorError("No enough space used for installing, "
"please resize partition size in ks file")
download_count = total_count - cached_count
msger.info("%d packages to be installed, "
"%d packages gotten from cache, "
"%d packages to be downloaded" \
% (total_count, cached_count, download_count))
try:
if download_count > 0:
msger.info("Downloading packages ...")
self.downloadPkgs(dlpkgs, download_count)
self.installPkgs(dlpkgs)
except RepoError, e:
raise CreatorError("Unable to download from repo : %s" % (e, ))
