QubesOS/qubes-installer-qubes-os
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
a3970b15fd
qubes-installer-qubes-os/anaconda/pyanaconda/packaging/yumpayload.py

1648 lines
62 KiB
Python
Raw Normal View History

anaconda: import unmodified 18.37.11 version from fc18
2013-01-23 17:28:19 +00:00
# yumpayload.py
# Yum/rpm software payload management.
#
# Copyright (C) 2012 Red Hat, Inc.
#
# This copyrighted material is made available to anyone wishing to use,
# modify, copy, or redistribute it subject to the terms and conditions of
# the GNU General Public License v.2, or (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY expressed or implied, including the implied warranties 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., 51 Franklin Street, Fifth Floor, Boston, MA
# 02110-1301, USA. Any Red Hat trademarks that are incorporated in the
# source code or documentation are not subject to the GNU General Public
# License and may only be used or replicated with the express permission of
# Red Hat, Inc.
#
# Red Hat Author(s): David Lehman <dlehman@redhat.com>
# Chris Lumens <clumens@redhat.com>
#
"""
TODO
- document all methods
- YumPayload
- preupgrade
- write test cases
- more logging in key methods
- handling of proxy needs cleanup
- passed to anaconda as --proxy, --proxyUsername, and
--proxyPassword
- drop the use of a file for proxy and ftp auth info
- specified via KS as a URL
"""
from ConfigParser import MissingSectionHeaderError
import os
import shutil
import sys
import time
import tempfile
from . import *
import logging
log = logging.getLogger("packaging")
try:
import rpm
import rpmUtils
except ImportError:
log.error("import of rpm failed")
rpm = None
rpmUtils = None
try:
import yum
# This is a bit of a hack to short circuit yum's internal logging
# handler setup. We already set one up so we don't need it to run.
# yum may give us an API to fiddle this at a later time.
yum.logginglevels._added_handlers = True
except ImportError:
log.error("import of yum failed")
yum = None
from pyanaconda.constants import *
from pyanaconda.flags import flags
from pyanaconda import iutil
from pyanaconda.iutil import ProxyString, ProxyStringError
from pyanaconda import isys
from pyanaconda.network import hasActiveNetDev
from pyanaconda.storage.size import Size
from pyanaconda.image import opticalInstallMedia
from pyanaconda.image import mountImage
from pyanaconda.image import findFirstIsoImage
import gettext
_ = lambda x: gettext.ldgettext("anaconda", x)
from pyanaconda.errors import *
from pyanaconda.packaging import NoSuchGroup, NoSuchPackage
import pyanaconda.progress as progress
from pyanaconda.localization import expand_langs
import itertools
from pykickstart.constants import KS_MISSING_IGNORE
default_repos = [productName.lower(), "rawhide"]
from threading import RLock
_yum_lock = RLock()
_yum_cache_dir = "/tmp/yum.cache"
class YumPayload(PackagePayload):
""" A YumPayload installs packages onto the target system using yum.
User-defined (aka: addon) repos exist both in ksdata and in yum. They
are the only repos in ksdata.repo. The repos we find in the yum config
only exist in yum. Lastly, the base repo exists in yum and in
ksdata.method.
"""
def __init__(self, data):
if rpm is None or yum is None:
raise PayloadError("unsupported payload type")
PackagePayload.__init__(self, data)
self.install_device = None
self._root_dir = "/tmp/yum.root"
self._repos_dir = "/etc/yum.repos.d,/etc/anaconda.repos.d,/tmp/updates/anaconda.repos.d,/tmp/product/anaconda.repos.d"
self._yum = None
self._setup = False
self._requiredPackages = []
self._requiredGroups = []
self.reset()
def reset(self, root=None):
""" Reset this instance to its initial (unconfigured) state. """
# cdrom: install_device.teardown (INSTALL_TREE)
# hd: umount INSTALL_TREE, install_device.teardown (ISO_DIR)
# nfs: umount INSTALL_TREE
# nfsiso: umount INSTALL_TREE, umount ISO_DIR
if os.path.ismount(INSTALL_TREE) and not flags.testing:
if self.install_device and \
get_mount_device(INSTALL_TREE) == self.install_device.path:
self.install_device.teardown(recursive=True)
else:
isys.umount(INSTALL_TREE, removeDir=False)
if os.path.ismount(ISO_DIR) and not flags.testing:
if self.install_device and \
get_mount_device(ISO_DIR) == self.install_device.path:
self.install_device.teardown(recursive=True)
# The below code will fail when nfsiso is the stage2 source
# But if we don't do this we may not be able to switch from
# one nfsiso repo to another nfsiso repo. We need to have a
# way to detect the stage2 state and work around it.
# Commenting out the below is a hack for F18. FIXME
#else:
# # NFS
# isys.umount(ISO_DIR, removeDir=False)
self.install_device = None
# This value comes from a default install of the x86_64 Fedora 18. It
# is meant as a best first guess only. Once package metadata is
# available we can use that as a better value.
self._space_required = Size(spec="3000 MB")
self._groups = None
self._packages = []
self._resetYum(root=root)
def setup(self, storage):
super(YumPayload, self).setup(storage)
self._writeYumConfig()
self._setup = True
self.updateBaseRepo()
# When setup is called, it's already in a separate thread. That thread
# will try to select groups right after this returns, so make sure we
# have group info ready.
self.gatherRepoMetadata()
def _resetYum(self, root=None, keep_cache=False):
""" Delete and recreate the payload's YumBase instance. """
import shutil
if root is None:
root = self._root_dir
with _yum_lock:
if self._yum:
if not keep_cache:
for repo in self._yum.repos.listEnabled():
if repo.name == BASE_REPO_NAME and \
os.path.isdir(repo.cachedir):
shutil.rmtree(repo.cachedir)
del self._yum
self._yum = yum.YumBase()
self._yum.use_txmbr_in_callback = True
# Set some configuration parameters that don't get set through a config
# file. yum will know what to do with these.
# Enable all types of yum plugins. We're somewhat careful about what
# plugins we put in the environment.
self._yum.preconf.plugin_types = yum.plugins.ALL_TYPES
self._yum.preconf.enabled_plugins = ["blacklist", "whiteout", "fastestmirror",
"langpacks"]
self._yum.preconf.fn = "/tmp/anaconda-yum.conf"
self._yum.preconf.root = root
# set this now to the best default we've got ; we'll update it if/when
# we get a base repo set up
self._yum.preconf.releasever = self._getReleaseVersion(None)
# Set the yum verbosity to 6, and update yum's internal logger
# objects to the debug level. This is a bit of a hack requiring
# internal knowledge of yum, that will hopefully go away in the
# future with API improvements.
self._yum.preconf.debuglevel = 6
self._yum.preconf.errorlevel = 6
self._yum.logger.setLevel(logging.DEBUG)
self._yum.verbose_logger.setLevel(logging.DEBUG)
self.txID = None
def _writeYumConfig(self):
""" Write out anaconda's main yum configuration file. """
buf = """
[main]
cachedir=%s
keepcache=0
logfile=/tmp/yum.log
metadata_expire=never
pluginpath=/usr/lib/yum-plugins,/tmp/updates/yum-plugins
pluginconfpath=/etc/yum/pluginconf.d,/tmp/updates/pluginconf.d
plugins=1
reposdir=%s
""" % (_yum_cache_dir, self._repos_dir)
if flags.noverifyssl:
buf += "sslverify=0\n"
if self.data.packages.multiLib:
buf += "multilib_policy=all\n"
if self.data.method.proxy:
try:
proxy = ProxyString(self.data.method.proxy)
buf += "proxy=%s\n" % (proxy.noauth_url,)
if proxy.username:
buf += "proxy_username=%s\n" % (proxy.username,)
if proxy.password:
buf += "proxy_password=%s\n" % (proxy.password,)
except ProxyStringError as e:
log.error("Failed to parse proxy for _writeYumConfig %s: %s" \
% (self.data.method.proxy, e))
open("/tmp/anaconda-yum.conf", "w").write(buf)
# YUMFIXME: yum should allow a cache dir outside of the installroot
def _yumCacheDirHack(self):
# This is what it takes to get yum to use a cache dir outside the
# install root. We do this so we don't have to re-gather repo meta-
# data after we change the install root to ROOT_PATH, which can only
# happen after we've enabled the new storage configuration.
with _yum_lock:
if not self._yum.conf.cachedir.startswith(self._yum.conf.installroot):
return
root = self._yum.conf.installroot
self._yum.conf.cachedir = self._yum.conf.cachedir[len(root):]
def _writeInstallConfig(self):
""" Write out the yum config that will be used to install packages.
Write out repo config files for all enabled repos, then
create a new YumBase instance with the new filesystem tree as its
install root.
This needs to be called from inside a yum_lock
"""
self._repos_dir = "/tmp/yum.repos.d"
if not os.path.isdir(self._repos_dir):
os.mkdir(self._repos_dir)
for repo in self._yum.repos.listEnabled():
cfg_path = "%s/%s.repo" % (self._repos_dir, repo.id)
ks_repo = self.getRepo(repo.id)
with open(cfg_path, "w") as f:
f.write("[%s]\n" % repo.id)
f.write("name=Install - %s\n" % repo.id)
f.write("enabled=1\n")
if repo.mirrorlist:
f.write("mirrorlist=%s" % repo.mirrorlist)
elif repo.baseurl:
f.write("baseurl=%s\n" % repo.baseurl[0])
else:
log.error("repo %s has no baseurl or mirrorlist" % repo.id)
f.close()
os.unlink(cfg_path)
continue
# kickstart repo modifiers
if ks_repo:
if ks_repo.noverifyssl:
f.write("sslverify=0\n")
if ks_repo.proxy:
try:
proxy = ProxyString(ks_repo.proxy)
f.write("proxy=%s\n" % (proxy.noauth_url,))
if proxy.username:
f.write("proxy_username=%s\n" % (proxy.username,))
if proxy.password:
f.write("proxy_password=%s\n" % (proxy.password,))
except ProxyStringError as e:
log.error("Failed to parse proxy for _writeInstallConfig %s: %s" \
% (self.data.method.proxy, e))
if ks_repo.cost:
f.write("cost=%d\n" % ks_repo.cost)
if ks_repo.includepkgs:
f.write("includepkgs=%s\n"
% ",".join(ks_repo.includepkgs))
if ks_repo.excludepkgs:
f.write("exclude=%s\n"
% ",".join(ks_repo.excludepkgs))
if ks_repo.ignoregroups:
f.write("enablegroups=0\n")
releasever = self._yum.conf.yumvar['releasever']
self._writeYumConfig()
self._resetYum(root=ROOT_PATH, keep_cache=True)
log.debug("setting releasever to previous value of %s" % releasever)
self._yum.preconf.releasever = releasever
self._yumCacheDirHack()
self.gatherRepoMetadata()
# trigger setup of self._yum.config
log.debug("installation yum config repos: %s"
% ",".join([r.id for r in self._yum.repos.listEnabled()]))
# YUMFIXME: there should be a way to reset package sacks without all this
# knowledge of the yum internals or, better yet, some convenience
# functions for multi-threaded applications
def release(self):
from yum.packageSack import MetaSack
with _yum_lock:
log.debug("deleting package sacks")
if hasattr(self._yum, "_pkgSack"):
self._yum._pkgSack = None
self._yum.repos.pkgSack = MetaSack()
for repo in self._yum.repos.repos.values():
repo._sack = None
def deleteYumTS(self):
with _yum_lock:
log.debug("deleting yum transaction info")
self._yum.closeRpmDB()
del self._yum.tsInfo
del self._yum.ts
def preStorage(self):
self.release()
with _yum_lock:
self._yum.close()
###
### METHODS FOR WORKING WITH REPOSITORIES
###
@property
def repos(self):
if not self._setup:
return []
_repos = []
with _yum_lock:
_repos = self._yum.repos.repos.keys()
return _repos
@property
def addOns(self):
return [r.name for r in self.data.repo.dataList()]
@property
def baseRepo(self):
repo_names = [BASE_REPO_NAME] + default_repos
base_repo_name = None
with _yum_lock:
for repo_name in repo_names:
if repo_name in self.repos and \
self._yum.repos.getRepo(repo_name).enabled:
base_repo_name = repo_name
break
return base_repo_name
def updateBaseRepo(self, fallback=True, root=None, checkmount=True):
""" Update the base repo based on self.data.method.
- Tear down any previous base repo devices, symlinks, &c.
- Reset the YumBase instance.
- Try to convert the new method to a base repo.
- If that fails, we'll use whatever repos yum finds in the config.
- Set up addon repos.
- Filter out repos that don't make sense to have around.
- Get metadata for all enabled repos, disabling those for which the
retrieval fails.
"""
log.info("updating base repo")
# start with a fresh YumBase instance
self.reset(root=root)
# see if we can get a usable base repo from self.data.method
try:
self._configureBaseRepo(self.storage, checkmount=checkmount)
except PayloadError as e:
if not fallback:
with _yum_lock:
for repo in self._yum.repos.repos.values():
if repo.enabled:
self.disableRepo(repo.id)
raise
# this preserves the method details while disabling it
self.data.method.method = None
self.install_device = None
finally:
self._yumCacheDirHack()
with _yum_lock:
if BASE_REPO_NAME not in self._yum.repos.repos.keys():
log.info("using default repos from local yum configuration")
if self._yum.conf.yumvar['releasever'] == "rawhide" and \
"rawhide" in self.repos:
self.enableRepo("rawhide")
# set up addon repos
# FIXME: driverdisk support
for repo in self.data.repo.dataList():
try:
self.configureAddOnRepo(repo)
except NoNetworkError as e:
log.error("repo %s needs an active network connection"
% repo.name)
self.removeRepo(repo.name)
except PayloadError as e:
log.error("repo %s setup failed: %s" % (repo.name, e))
self.removeRepo(repo.name)
# now disable and/or remove any repos that don't make sense
with _yum_lock:
for repo in self._yum.repos.repos.values():
# Rules for which repos to enable/disable/remove
#
# - always remove
# - source, debuginfo
# - disable if isFinal
# - rawhide, development
# - disable all other built-in repos if rawhide is enabled
# - remove any repo when not isFinal and repo not enabled
# - if a base repo is defined, disable any repo not defined by
# the user that is not the base repo
#
# FIXME: updates needs special handling
if repo.id in self.addOns:
continue
if "-source" in repo.id or "-debuginfo" in repo.id:
self._removeYumRepo(repo.id)
elif isFinal and ("rawhide" in repo.id or "development" in repo.id):
# XXX the "development" part seems a bit heavy handed
self._removeYumRepo(repo.id)
elif self._yum.conf.yumvar['releasever'] == "rawhide" and \
"rawhide" in self.repos and \
self._yum.repos.getRepo("rawhide").enabled and \
repo.id != "rawhide":
self.disableRepo(repo.id)
elif self.data.method.method and \
repo.id != BASE_REPO_NAME and \
repo.id not in [r.name for r in self.data.repo.dataList()]:
# if a method/repo was given, disable all default repos
self.disableRepo(repo.id)
def gatherRepoMetadata(self):
# now go through and get metadata for all enabled repos
log.info("gathering repo metadata")
for repo_id in self.repos:
with _yum_lock:
repo = self._yum.repos.getRepo(repo_id)
if repo.enabled:
try:
self._getRepoMetadata(repo)
except PayloadError as e:
log.error("failed to grab repo metadata for %s: %s"
% (repo_id, e))
self.disableRepo(repo_id)
log.info("metadata retrieval complete")
@property
def ISOImage(self):
if not self.data.method.method == "harddrive":
return None
# This could either be mounted to INSTALL_TREE or on
# DRACUT_ISODIR if dracut did the mount.
dev = get_mount_device(INSTALL_TREE)
if dev:
return dev[len(ISO_DIR)+1:]
dev = get_mount_device(DRACUT_ISODIR)
if dev:
return dev[len(DRACUT_ISODIR)+1:]
return None
def _setUpMedia(self, device):
method = self.data.method
if method.method == "harddrive":
self._setupDevice(device, mountpoint=ISO_DIR)
# check for ISO images in the newly mounted dir
path = ISO_DIR
if method.dir:
path = os.path.normpath("%s/%s" % (path, method.dir))
# XXX it would be nice to streamline this when we're just setting
# things back up after storage activation instead of having to
# pretend we don't already know which ISO image we're going to
# use
image = findFirstIsoImage(path)
if not image:
device.teardown(recursive=True)
raise PayloadSetupError("failed to find valid iso image")
if path.endswith(".iso"):
path = os.path.dirname(path)
# this could already be set up the first time through
if not os.path.ismount(INSTALL_TREE):
# mount the ISO on a loop
image = os.path.normpath("%s/%s" % (path, image))
mountImage(image, INSTALL_TREE)
if not method.dir.endswith(".iso"):
method.dir = os.path.normpath("%s/%s" % (method.dir,
os.path.basename(image)))
while method.dir.startswith("/"):
# riduculous
method.dir = method.dir[1:]
# Check to see if the device is already mounted, in which case
# we don't need to mount it again
elif method.method == "cdrom" and get_mount_paths(device.path):
return
else:
device.format.setup(mountpoint=INSTALL_TREE)
def _configureBaseRepo(self, storage, checkmount=True):
""" Configure the base repo.
If self.data.method.method is set, failure to configure a base repo
should generate a PayloadError exception.
If self.data.method.method is unset, no exception should be raised
and no repo should be configured.
If checkmount is true, check the dracut mount to see if we have
usable media mounted.
"""
log.info("configuring base repo")
# set up the main repo specified by method=, repo=, or ks method
# XXX FIXME: does this need to handle whatever was set up by dracut?
# XXX FIXME: most of this probably belongs up in Payload
method = self.data.method
sslverify = True
url = None
mirrorlist = None
# See if we already have stuff mounted due to dracut
isodev = get_mount_device(DRACUT_ISODIR)
device = get_mount_device(DRACUT_REPODIR)
if method.method == "harddrive":
if method.biospart:
log.warning("biospart support is not implemented")
devspec = method.biospart
else:
devspec = method.partition
needmount = True
# See if we used this method for stage2, thus dracut left it
if isodev and method.partition and method.partition in isodev \
and DRACUT_ISODIR in device:
# Everything should be setup
url = "file://" + DRACUT_REPODIR
needmount = False
# We don't setup an install_device here
# because we can't tear it down
isodevice = storage.devicetree.resolveDevice(devspec)
if needmount:
self._setUpMedia(isodevice)
url = "file://" + INSTALL_TREE
self.install_device = isodevice
elif method.method == "nfs":
# See if dracut dealt with nfsiso
if isodev:
options, host, path = iutil.parseNfsUrl('nfs:%s' % isodev)
# See if the dir holding the iso is what we want
# and also if we have an iso mounted to /run/install/repo
if path and path in isodev and DRACUT_ISODIR in device:
# Everything should be setup
url = "file://" + DRACUT_REPODIR
else:
# see if the nfs dir is mounted
needmount = True
if device:
options, host, path = iutil.parseNfsUrl('nfs:%s' % device)
if path and path in device:
needmount = False
path = DRACUT_REPODIR
if needmount:
# Mount the NFS share on INSTALL_TREE. If it ends up
# being nfsiso we will move the mountpoint to ISO_DIR.
if method.dir.endswith(".iso"):
nfsdir = os.path.dirname(method.dir)
else:
nfsdir = method.dir
self._setupNFS(INSTALL_TREE, method.server, nfsdir,
method.opts)
path = INSTALL_TREE
# check for ISO images in the newly mounted dir
if method.dir.endswith(".iso"):
# if the given URL includes a specific ISO image file, use it
image_file = os.path.basename(method.dir)
path = os.path.normpath("%s/%s" % (path, image_file))
image = findFirstIsoImage(path)
# it appears there are ISO images in the dir, so assume they want to
# install from one of them
if image:
# move the mount to ISO_DIR
# work around inability to move shared filesystems
iutil.execWithRedirect("mount",
["--make-rprivate", "/"],
stderr="/dev/tty5", stdout="/dev/tty5")
iutil.execWithRedirect("mount",
["--move", INSTALL_TREE, ISO_DIR],
stderr="/dev/tty5", stdout="/dev/tty5")
# Mounts are kept track of in isys it seems
# Remove the count for the source
if isys.mountCount.has_key(INSTALL_TREE):
if isys.mountCount[INSTALL_TREE] > 1:
isys.mountCount[INSTALL_TREE] -= 1
else:
del(isys.mountCount[INSTALL_TREE])
# Add a count for the new location
if not isys.mountCount.has_key(ISO_DIR):
isys.mountCount[ISO_DIR] = 0
isys.mountCount[ISO_DIR] += 1
# mount the ISO on a loop
image = os.path.normpath("%s/%s" % (ISO_DIR, image))
mountImage(image, INSTALL_TREE)
url = "file://" + INSTALL_TREE
else:
# Fall back to the mount path instead of a mounted iso
url = "file://" + path
elif method.method == "url":
url = method.url
mirrorlist = method.mirrorlist
sslverify = not (method.noverifyssl or flags.noverifyssl)
elif method.method == "cdrom" or (checkmount and not method.method):
# Did dracut leave the DVD or NFS mounted for us?
device = get_mount_device(DRACUT_REPODIR)
# Only look at the dracut mount if we don't already have a cdrom
if device and not self.install_device:
self.install_device = storage.devicetree.getDeviceByPath(device)
url = "file://" + DRACUT_REPODIR
if not method.method:
# See if this is a nfs mount
if ':' in device:
# prepend nfs: to the url as that's what the parser
# wants. Note we don't get options from this, but
# that's OK for the UI at least.
options, host, path = iutil.parseNfsUrl("nfs:%s" %
device)
method.method = "nfs"
method.server = host
method.dir = path
else:
method.method = "cdrom"
else:
# cdrom or no method specified -- check for media
if not self.install_device:
self.install_device = opticalInstallMedia(storage.devicetree)
if self.install_device:
if not method.method:
method.method = "cdrom"
self._setUpMedia(self.install_device)
url = "file://" + INSTALL_TREE
elif method.method == "cdrom":
raise PayloadSetupError("no usable optical media found")
if method.method:
with _yum_lock:
try:
self._yum.preconf.releasever = self._getReleaseVersion(url)
except MissingSectionHeaderError as e:
log.error("couldn't set releasever from base repo (%s): %s"
% (method.method, e))
self._removeYumRepo(BASE_REPO_NAME)
raise PayloadSetupError("base repo is unusable")
self._yumCacheDirHack()
try:
self._addYumRepo(BASE_REPO_NAME, url, mirrorlist=mirrorlist,
proxyurl=method.proxy, sslverify=sslverify)
except MetadataError as e:
log.error("base repo (%s/%s) not valid -- removing it"
% (method.method, url))
self._removeYumRepo(BASE_REPO_NAME)
raise
def configureAddOnRepo(self, repo):
""" Configure a single ksdata repo. """
url = repo.baseurl
if url and url.startswith("nfs:"):
(opts, server, path) = iutil.parseNfsUrl(url)
mountpoint = "%s/%s.nfs" % (MOUNT_DIR, repo.name)
self._setupNFS(mountpoint, server, path, opts)
url = "file://" + mountpoint
if self._repoNeedsNetwork(repo) and not hasActiveNetDev():
raise NoNetworkError
proxy = repo.proxy or self.data.method.proxy
sslverify = not (flags.noverifyssl or repo.noverifyssl)
# this repo is already in ksdata, so we only add it to yum here
self._addYumRepo(repo.name, url, repo.mirrorlist, cost=repo.cost,
exclude=repo.excludepkgs, includepkgs=repo.includepkgs,
proxyurl=proxy, sslverify=sslverify)
# TODO: enable addons via treeinfo
def _getRepoMetadata(self, yumrepo):
""" Retrieve repo metadata if we don't already have it. """
from yum.Errors import RepoError, RepoMDError
# And try to grab its metadata. We do this here so it can be done
# on a per-repo basis, so we can then get some finer grained error
# handling and recovery.
log.debug("getting repo metadata for %s" % yumrepo.id)
with _yum_lock:
try:
yumrepo.getPrimaryXML()
except RepoError as e:
raise MetadataError(e.value)
# Not getting group info is bad, but doesn't seem like a fatal error.
# At the worst, it just means the groups won't be displayed in the UI
# which isn't too bad, because you may be doing a kickstart install and
# picking packages instead.
log.debug("getting group info for %s" % yumrepo.id)
try:
yumrepo.getGroups()
except RepoMDError:
log.error("failed to get groups for repo %s" % yumrepo.id)
def _addYumRepo(self, name, baseurl, mirrorlist=None, proxyurl=None, **kwargs):
""" Add a yum repo to the YumBase instance. """
from yum.Errors import RepoError
# First, delete any pre-existing repo with the same name.
with _yum_lock:
if name in self._yum.repos.repos:
self._yum.repos.delete(name)
if proxyurl:
try:
proxy = ProxyString(proxyurl)
kwargs["proxy"] = proxy.noauth_url
if proxy.username:
kwargs["proxy_username"] = proxy.username
if proxy.password:
kwargs["proxy_password"] = proxy.password
except ProxyStringError as e:
log.error("Failed to parse proxy for _addYumRepo %s: %s" \
% (proxyurl, e))
log.debug("adding yum repo %s with baseurl %s and mirrorlist %s"
% (name, baseurl, mirrorlist))
with _yum_lock:
# Then add it to yum's internal structures.
obj = self._yum.add_enable_repo(name,
baseurl=[baseurl],
mirrorlist=mirrorlist,
**kwargs)
# this will trigger retrieval of repomd.xml, which is small and yet
# gives us some assurance that the repo config is sane
# YUMFIXME: yum's instant policy doesn't work as advertised
obj.mdpolicy = "meh"
try:
obj.repoXML
except RepoError as e:
raise MetadataError(e.value)
# Adding a new repo means the cached packages and groups lists
# are out of date. Clear them out now so the next reference to
# either will cause it to be regenerated.
self._groups = None
self._packages = []
def addRepo(self, newrepo):
""" Add a ksdata repo. """
log.debug("adding new repo %s" % newrepo.name)
self._addYumRepo(newrepo.name, newrepo.baseurl, newrepo.mirrorlist, newrepo.proxy) # FIXME: handle MetadataError
super(YumPayload, self).addRepo(newrepo)
def _removeYumRepo(self, repo_id):
if repo_id in self.repos:
with _yum_lock:
self._yum.repos.delete(repo_id)
self._groups = None
self._packages = []
def removeRepo(self, repo_id):
""" Remove a repo as specified by id. """
log.debug("removing repo %s" % repo_id)
# if this is an NFS repo, we'll want to unmount the NFS mount after
# removing the repo
mountpoint = None
with _yum_lock:
yum_repo = self._yum.repos.getRepo(repo_id)
ks_repo = self.getRepo(repo_id)
if yum_repo and ks_repo and ks_repo.baseurl.startswith("nfs:"):
mountpoint = yum_repo.baseurl[0][7:] # strip leading "file://"
self._removeYumRepo(repo_id)
super(YumPayload, self).removeRepo(repo_id)
if mountpoint and os.path.ismount(mountpoint):
try:
isys.umount(mountpoint, removeDir=False)
except SystemError as e:
log.error("failed to unmount nfs repo %s: %s" % (mountpoint, e))
def enableRepo(self, repo_id):
""" Enable a repo as specified by id. """
log.debug("enabling repo %s" % repo_id)
if repo_id in self.repos:
with _yum_lock:
self._yum.repos.enableRepo(repo_id)
def disableRepo(self, repo_id):
""" Disable a repo as specified by id. """
log.debug("disabling repo %s" % repo_id)
if repo_id in self.repos:
with _yum_lock:
self._yum.repos.disableRepo(repo_id)
self._groups = None
self._packages = []
###
### METHODS FOR WORKING WITH ENVIRONMENTS
###
@property
def environments(self):
""" List of environment ids. """
from yum.Errors import RepoError
from yum.Errors import GroupsError
environments = []
yum_groups = self._yumGroups
if yum_groups:
with _yum_lock:
environments = [i.environmentid for i in yum_groups.get_environments()]
return environments
def environmentSelected(self, environmentid):
groups = self._yumGroups
if not groups:
return False
with _yum_lock:
if not groups.has_environment(environmentid):
raise NoSuchGroup(environmentid)
environment = groups.return_environment(environmentid)
for group in environment.groups:
if not self.groupSelected(group):
return False
return True
def environmentHasOption(self, environmentid, grpid):
groups = self._yumGroups
if not groups:
return False
with _yum_lock:
if not groups.has_environment(environmentid):
raise NoSuchGroup(environmentid)
environment = groups.return_environment(environmentid)
if grpid in environment.options:
return True
return False
def environmentDescription(self, environmentid):
""" Return name/description tuple for the environment specified by id. """
groups = self._yumGroups
if not groups:
return (environmentid, environmentid)
with _yum_lock:
if not groups.has_environment(environmentid):
raise NoSuchGroup(environmentid)
environment = groups.return_environment(environmentid)
return (environment.ui_name, environment.ui_description)
def selectEnvironment(self, environmentid):
groups = self._yumGroups
if not groups:
return
with _yum_lock:
if not groups.has_environment(environmentid):
raise NoSuchGroup(environmentid)
environment = groups.return_environment(environmentid)
for group in environment.groups:
self.selectGroup(group)
def deselectEnvironment(self, environmentid):
groups = self._yumGroups
if not groups:
return
with _yum_lock:
if not groups.has_environment(environmentid):
raise NoSuchGroup(environmentid)
environment = groups.return_environment(environmentid)
for group in environment.groups:
self.deselectGroup(group)
for group in environment.options:
self.deselectGroup(group)
def environmentGroups(self, environmentid):
groups = self._yumGroups
if not groups:
return []
with _yum_lock:
if not groups.has_environment(environmentid):
raise NoSuchGroup(environmentid)
environment = groups.return_environment(environmentid)
return environment.groups + environment.options
###
### METHODS FOR WORKING WITH GROUPS
###
@property
def _yumGroups(self):
""" yum.comps.Comps instance. """
from yum.Errors import RepoError, GroupsError
with _yum_lock:
if not self._groups:
if not self.needsNetwork or hasActiveNetDev():
try:
self._groups = self._yum.comps
except (RepoError, GroupsError) as e:
log.error("failed to get group info: %s" % e)
return self._groups
@property
def groups(self):
""" List of group ids. """
from yum.Errors import RepoError
from yum.Errors import GroupsError
groups = []
yum_groups = self._yumGroups
if yum_groups:
with _yum_lock:
groups = [g.groupid for g in yum_groups.get_groups()]
return groups
def languageGroups(self, lang):
groups = []
yum_groups = self._yumGroups
if yum_groups:
with _yum_lock:
langs = expand_langs(lang)
groups = map(lambda x: [g.groupid for g in
yum_groups.get_groups() if g.langonly == x],
langs)
# the map gives us a list of results, this set call reduces
# it down to a unique set, then list() makes it back into a list.
return list(set(itertools.chain(*groups)))
def groupDescription(self, groupid):
""" Return name/description tuple for the group specified by id. """
groups = self._yumGroups
if not groups:
return (groupid, groupid)
with _yum_lock:
if not groups.has_group(groupid):
raise NoSuchGroup(groupid)
group = groups.return_group(groupid)
return (group.ui_name, group.ui_description)
def _isGroupVisible(self, groupid):
groups = self._yumGroups
if not groups:
return False
with _yum_lock:
if not groups.has_group(groupid):
return False
group = groups.return_group(groupid)
return group.user_visible
def _groupHasInstallableMembers(self, groupid):
groups = self._yumGroups
if not groups:
return False
with _yum_lock:
if not groups.has_group(groupid):
return False
group = groups.return_group(groupid)
pkgs = group.mandatory_packages.keys() + group.default_packages.keys()
if pkgs:
return True
return False
def _selectYumGroup(self, groupid, default=True, optional=False):
# select the group in comps
pkg_types = ['mandatory']
if default:
pkg_types.append("default")
if optional:
pkg_types.append("optional")
log.debug("select group %s" % groupid)
with _yum_lock:
try:
self._yum.selectGroup(groupid, group_package_types=pkg_types)
except yum.Errors.GroupsError:
raise NoSuchGroup(groupid)
def _deselectYumGroup(self, groupid):
# deselect the group in comps
log.debug("deselect group %s" % groupid)
with _yum_lock:
try:
self._yum.deselectGroup(groupid, force=True)
except yum.Errors.GroupsError:
raise NoSuchGroup(groupid)
###
### METHODS FOR WORKING WITH PACKAGES
###
@property
def packages(self):
from yum.Errors import RepoError
with _yum_lock:
if not self._packages:
if self.needsNetwork and not hasActiveNetDev():
raise NoNetworkError
try:
self._packages = self._yum.pkgSack.returnPackages()
except RepoError as e:
log.error("failed to get package list: %s" % e)
return self._packages
def _selectYumPackage(self, pkgid):
"""Mark a package for installation.
pkgid - The name of a package to be installed. This could include
a version or architecture component.
"""
log.debug("select package %s" % pkgid)
with _yum_lock:
try:
mbrs = self._yum.install(pattern=pkgid)
except yum.Errors.InstallError:
raise NoSuchPackage(pkgid)
def _deselectYumPackage(self, pkgid):
"""Mark a package to be excluded from installation.
pkgid - The name of a package to be excluded. This could include
a version or architecture component.
"""
log.debug("deselect package %s" % pkgid)
with _yum_lock:
self._yum.tsInfo.deselect(pkgid)
###
### METHODS FOR QUERYING STATE
###
@property
def spaceRequired(self):
""" The total disk space (Size) required for the current selection. """
return self._space_required
def calculateSpaceNeeds(self):
# XXX this will only be useful if you've run checkSoftwareSelection
total = 0
with _yum_lock:
for txmbr in self._yum.tsInfo.getMembers():
total += getattr(txmbr.po, "installedsize", 0)
total += total * 0.35 # add 35% to account for the fact that the above
# method is laughably inaccurate
self._space_required = Size(bytes=total)
return self._space_required
###
### METHODS FOR INSTALLING THE PAYLOAD
###
def _removeTxSaveFile(self):
# remove the transaction save file
with _yum_lock:
if self._yum._ts_save_file:
try:
os.unlink(self._yum._ts_save_file)
except (OSError, IOError):
pass
else:
self._yum._ts_save_file = None
def _handleMissing(self, exn):
if self.data.packages.handleMissing == KS_MISSING_IGNORE:
return
if errorHandler.cb(exn, str(exn)) == ERROR_RAISE:
# The progress bar polls kind of slowly, thus installation could
# still continue for a bit before the quit message is processed.
# Doing a sys.exit also ensures the running thread quits before
# it can do anything else.
progress.send_quit(1)
sys.exit(1)
def _applyYumSelections(self):
""" Apply the selections in ksdata to yum.
This follows the same ordering/pattern as kickstart.py.
"""
self._selectYumGroup("core")
if self.data.packages.default and self.environments:
self.selectEnvironment(self.environments[0])
for package in self.data.packages.packageList:
try:
self._selectYumPackage(package)
except NoSuchPackage as e:
self._handleMissing(e)
for group in self.data.packages.groupList:
default = False
optional = False
if group.include == GROUP_DEFAULT:
default = True
elif group.include == GROUP_ALL:
default = True
optional = True
try:
self._selectYumGroup(group.name, default=default, optional=optional)
except NoSuchGroup as e:
self._handleMissing(e)
for package in self.data.packages.excludedList:
try:
self._deselectYumPackage(package)
except NoSuchPackage as e:
self._handleMissing(e)
for group in self.data.packages.excludedGroupList:
try:
self._deselectYumGroup(group.name)
except NoSuchGroup as e:
self._handleMissing(e)
self.selectKernelPackage()
self.selectRequiredPackages()
def checkSoftwareSelection(self):
log.info("checking software selection")
self.txID = time.time()
if self.skipBroken:
log.info("running software check with skip_broken = True")
with _yum_lock:
self._yum.conf.skip_broken = True
self.release()
self.deleteYumTS()
self._applyYumSelections()
with _yum_lock:
# doPostSelection
# select kernel packages
# select packages needed for storage, bootloader
# check dependencies
log.info("checking dependencies")
(code, msgs) = self._yum.buildTransaction(unfinished_transactions_check=False)
self._removeTxSaveFile()
if code == 0:
# empty transaction?
log.debug("empty transaction")
elif code == 2:
# success
log.debug("success")
elif self.data.packages.handleMissing == KS_MISSING_IGNORE:
log.debug("ignoring missing due to ks config")
elif self.data.upgrade.upgrade:
log.debug("ignoring unresolved deps on upgrade")
else:
for msg in msgs:
log.warning(msg)
raise DependencyError(msgs)
self.calculateSpaceNeeds()
with _yum_lock:
log.info("%d packages selected totalling %s"
% (len(self._yum.tsInfo.getMembers()), self.spaceRequired))
def selectKernelPackage(self):
kernels = self.kernelPackages
selected = None
# XXX This is optimistic. I'm curious if yum will DTRT if I just say
# "select this kernel" without jumping through hoops to figure out
# which arch it should use.
for kernel in kernels:
try:
# XXX might need explicit arch specification
self._selectYumPackage(kernel)
except NoSuchPackage as e:
log.info("no %s package" % kernel)
continue
else:
log.info("selected %s" % kernel)
selected = kernel
# select module packages for this kernel
# select the devel package if gcc will be installed
with _yum_lock:
if self._yum.tsInfo.matchNaevr(name="gcc"):
log.info("selecting %s-devel" % kernel)
# XXX might need explicit arch specification
self._selectYumPackage("%s-devel" % kernel)
break
if not selected:
log.error("failed to select a kernel from %s" % kernels)
def selectRequiredPackages(self):
if self._requiredPackages:
map(self._selectYumPackage, self._requiredPackages)
if self._requiredGroups:
map(self._selectYumGroup, self._requiredGroups)
def preInstall(self, packages=None, groups=None):
""" Perform pre-installation tasks. """
super(YumPayload, self).preInstall()
progress.send_message(_("Starting package installation process"))
self._requiredPackages = packages
self._requiredGroups = groups
if self.install_device:
self._setUpMedia(self.install_device)
with _yum_lock:
self._writeInstallConfig()
# We have this block twice. For kickstart installs, this is the only
# place dependencies will be checked. If a dependency error is hit
# here, there's nothing the user can do about it since you cannot go
# back to the first hub.
try:
self.checkSoftwareSelection()
except DependencyError as e:
if errorHandler.cb(e) == ERROR_RAISE:
progress.send_quit(1)
sys.exit(1)
# doPreInstall
# create mountpoints for protected device mountpoints (?)
# write static configs (storage, modprobe.d/anaconda.conf, network, keyboard)
# on upgrade, just make sure /etc/mtab is a symlink to /proc/self/mounts
if not self.data.upgrade.upgrade:
# this adds nofsync, which speeds things up but carries a risk of
# rpmdb data loss if a crash occurs. that's why we only do it on
# initial install and not for upgrades.
rpm.addMacro("__dbi_htconfig",
"hash nofsync %{__dbi_other} %{__dbi_perms}")
if self.data.packages.excludeDocs:
rpm.addMacro("_excludedocs", "1")
if flags.selinux:
for d in ["/tmp/updates",
"/etc/selinux/targeted/contexts/files",
"/etc/security/selinux/src/policy",
"/etc/security/selinux"]:
f = d + "/file_contexts"
if os.access(f, os.R_OK):
rpm.addMacro("__file_context_path", f)
break
else:
rpm.addMacro("__file_context_path", "%{nil}")
def _transactionErrors(self, errors):
spaceNeeded = {}
retval = ""
# RPM can give us a bunch of potential errors, but we really only
# care about a handful.
for (descr, (ty, mount, need)) in errors:
log.error(descr)
if ty == rpm.RPMPROB_DISKSPACE:
spaceNeeded[mount] = need
# Now that we've found the ones we are interested in, create an
# error string to match.
if spaceNeeded:
retval += _("You need more space on the following "
"file systems:\n")
for (mount, need) in spaceNeeded.items():
retval += "%s on %s\n" % (Size(need), mount)
return retval
def install(self):
""" Install the payload. """
from yum.Errors import PackageSackError, RepoError, YumBaseError, YumRPMTransError
log.info("preparing transaction")
log.debug("initialize transaction set")
with _yum_lock:
self._yum.initActionTs()
if rpmUtils and rpmUtils.arch.isMultiLibArch():
self._yum.ts.ts.setColor(3)
log.debug("populate transaction set")
try:
# uses dsCallback.transactionPopulation
self._yum.populateTs(keepold=0)
except RepoError as e:
log.error("error populating transaction: %s" % e)
exn = PayloadInstallError(str(e))
if errorHandler.cb(exn) == ERROR_RAISE:
raise exn
log.debug("check transaction set")
self._yum.ts.check()
log.debug("order transaction set")
self._yum.ts.order()
self._yum.ts.clean()
# Write scriptlet output to a file to be logged later
script_log = tempfile.NamedTemporaryFile(delete=False)
self._yum.ts.ts.scriptFd = script_log.fileno()
rpm.setLogFile(script_log)
# create the install callback
rpmcb = RPMCallback(self._yum, script_log,
upgrade=self.data.upgrade.upgrade)
if flags.testing:
self._yum.ts.setFlags(rpm.RPMTRANS_FLAG_TEST)
log.info("running transaction")
progress.send_step()
try:
self._yum.runTransaction(cb=rpmcb)
except PackageSackError as e:
log.error("error [1] running transaction: %s" % e)
exn = PayloadInstallError(str(e))
if errorHandler.cb(exn) == ERROR_RAISE:
raise exn
except YumRPMTransError as e:
log.error("error [2] running transaction: %s" % e)
exn = PayloadInstallError(self._transactionErrors(e.errors))
if errorHandler.cb(exn) == ERROR_RAISE:
progress.send_quit(1)
sys.exit(1)
except YumBaseError as e:
log.error("error [3] running transaction: %s" % e)
for error in e.errors:
log.error("%s" % error[0])
exn = PayloadInstallError(str(e))
if errorHandler.cb(exn) == ERROR_RAISE:
raise exn
else:
log.info("transaction complete")
progress.send_step()
finally:
self._yum.ts.close()
iutil.resetRpmDb()
script_log.close()
# log the contents of the scriptlet logfile
log.info("==== start rpm scriptlet logs ====")
with open(script_log.name) as f:
for l in f:
log.info(l)
log.info("==== end rpm scriptlet logs ====")
os.unlink(script_log.name)
def writeMultiLibConfig(self):
if not self.data.packages.multiLib:
return
# write out the yum config with the new multilib_policy value
# FIXME: switch to using yum-config-manager once it stops expanding
# all yumvars and writing out the expanded pairs to the conf
yb = yum.YumBase()
yum_conf_path = "/etc/yum.conf"
yb.preconf.fn = ROOT_PATH + yum_conf_path
yb.conf.multilib_policy = "all"
# this will appear in yum.conf, which is silly
yb.conf.config_file_path = yum_conf_path
# hack around yum having expanded $basearch in the cachedir value
cachedir = yb.conf.cachedir.replace("/%s/" % yb.arch.basearch,
"/$basearch/")
yb.conf.cachedir = cachedir
yum_conf = ROOT_PATH + yum_conf_path
if os.path.exists(yum_conf):
try:
os.rename(yum_conf, yum_conf + ".anacbak")
except OSError as e:
log.error("failed to back up yum.conf: %s" % e)
try:
yb.conf.write(open(yum_conf, "w"))
except Exception as e:
log.error("failed to write out yum.conf: %s" % e)
def postInstall(self):
""" Perform post-installation tasks. """
with _yum_lock:
self._yum.close()
# clean up repo tmpdirs
self._yum.cleanPackages()
self._yum.cleanHeaders()
# remove cache dirs of install-specific repos
for repo in self._yum.repos.listEnabled():
if repo.name == BASE_REPO_NAME or repo.id.startswith("anaconda-"):
shutil.rmtree(repo.cachedir)
# clean the yum cache on upgrade
if self.data.upgrade.upgrade:
self._yum.cleanMetadata()
# TODO: on preupgrade, remove the preupgrade dir
self._removeTxSaveFile()
self.writeMultiLibConfig()
super(YumPayload, self).postInstall()
class RPMCallback(object):
def __init__(self, yb, log, upgrade=False):
self._yum = yb # yum.YumBase
self.install_log = log # logfile for yum script logs
self.upgrade = upgrade # boolean
self.package_file = None # file instance (package file management)
self.total_actions = 0
self.completed_actions = None # will be set to 0 when starting tx
self.base_arch = iutil.getArch()
def _get_txmbr(self, key):
""" Return a (name, TransactionMember) tuple from cb key. """
if hasattr(key, "po"):
# New-style callback, key is a TransactionMember
txmbr = key
name = key.name
else:
# cleanup/remove error
name = key
txmbr = None
return (name, txmbr)
def callback(self, event, amount, total, key, userdata):
""" Yum install callback. """
if event == rpm.RPMCALLBACK_TRANS_START:
if amount == 6:
progress.send_message(_("Preparing transaction from installation source"))
self.total_actions = total
self.completed_actions = 0
elif event == rpm.RPMCALLBACK_TRANS_PROGRESS:
# amount / total complete
pass
elif event == rpm.RPMCALLBACK_TRANS_STOP:
# we are done
pass
elif event == rpm.RPMCALLBACK_INST_OPEN_FILE:
# update status that we're installing/upgrading %h
# return an open fd to the file
txmbr = self._get_txmbr(key)[1]
# If self.completed_actions is still None, that means this package
# is being opened to retrieve a %pretrans script. Don't log that
# we're installing the package unless we've been called with a
# TRANS_START event.
if self.completed_actions is not None:
if self.upgrade:
mode = _("Upgrading")
else:
mode = _("Installing")
self.completed_actions += 1
msg_format = "%s %s (%d/%d)"
progress_package = txmbr.name
if txmbr.arch not in ["noarch", self.base_arch]:
progress_package = "%s.%s" % (txmbr.name, txmbr.arch)
progress_msg = msg_format % (mode, progress_package,
self.completed_actions,
self.total_actions)
log_msg = msg_format % (mode, txmbr.po,
self.completed_actions,
self.total_actions)
log.info(log_msg)
self.install_log.write(log_msg+"\n")
self.install_log.flush()
progress.send_message(progress_msg)
self.package_file = None
repo = self._yum.repos.getRepo(txmbr.po.repoid)
while self.package_file is None:
try:
# checkfunc gets passed to yum's use of URLGrabber which
# then calls it with the file being fetched. verifyPkg
# makes sure the checksum matches the one in the metadata.
#
# From the URLGrab documents:
# checkfunc=(function, ('arg1', 2), {'kwarg': 3})
# results in a callback like:
# function(obj, 'arg1', 2, kwarg=3)
# obj.filename = '/tmp/stuff'
# obj.url = 'http://foo.com/stuff'
checkfunc = (self._yum.verifyPkg, (txmbr.po, 1), {})
package_path = repo.getPackage(txmbr.po, checkfunc=checkfunc)
except URLGrabError as e:
log.error("URLGrabError: %s" % (e,))
exn = PayloadInstallError("failed to get package")
if errorHandler.cb(exn, package=txmbr.po) == ERROR_RAISE:
raise exn
except (yum.Errors.NoMoreMirrorsRepoError, IOError):
if os.path.exists(txmbr.po.localPkg()):
os.unlink(txmbr.po.localPkg())
log.debug("retrying download of %s" % txmbr.po)
continue
exn = PayloadInstallError("failed to open package")
if errorHandler.cb(exn, package=txmbr.po) == ERROR_RAISE:
raise exn
except yum.Errors.RepoError:
continue
self.package_file = open(package_path)
return self.package_file.fileno()
elif event == rpm.RPMCALLBACK_INST_CLOSE_FILE:
# close and remove the last opened file
# update count of installed/upgraded packages
package_path = self.package_file.name
self.package_file.close()
self.package_file = None
if package_path.startswith(_yum_cache_dir):
try:
os.unlink(package_path)
except OSError as e:
log.debug("unable to remove file %s" % e.strerror)
# rpm doesn't tell us when it's started post-trans stuff which can
# take a very long time. So when it closes the last package, just
# display the message.
if self.completed_actions == self.total_actions:
progress.send_message(_("Performing post-install setup tasks"))
elif event == rpm.RPMCALLBACK_UNINST_START:
# update status that we're cleaning up %key
#progress.set_text(_("Cleaning up %s" % key))
pass
elif event in (rpm.RPMCALLBACK_CPIO_ERROR,
rpm.RPMCALLBACK_UNPACK_ERROR,
rpm.RPMCALLBACK_SCRIPT_ERROR):
name = self._get_txmbr(key)[0]
# Script errors store whether or not they're fatal in "total". So,
# we should only error out for fatal script errors or the cpio and
# unpack problems.
if event != rpm.RPMCALLBACK_SCRIPT_ERROR or total:
exn = PayloadInstallError("cpio, unpack, or fatal script error")
if errorHandler.cb(exn, package=name) == ERROR_RAISE:
raise exn
Reference in New Issue Copy Permalink