From 2a99e198c40b22fd2f3bf3988902b8d02817ea82 Mon Sep 17 00:00:00 2001
From: Colin Walters <walters@verbum.org>
Date: Wed, 30 Apr 2014 19:26:37 -0400
Subject: [PATCH 10/20] Add RPMOSTreePayload
This is a new backend that uses ostree to install. However, it's
named RPMOSTree because a future iteration will use rpm-ostree which
will support a hybrid of tree + RPM packages.
Resolves: rhbz#1113535
Port of rpmostreepayload patches from master
commit 131cbcec9c113dd5f66d14d440297d50b2900e01
---
data/post-scripts/80-setfilecons.ks | 3 +
po/POTFILES.in | 1 +
pyanaconda/__init__.py | 5 +-
pyanaconda/bootloader.py | 44 +++---
pyanaconda/install.py | 16 ++
pyanaconda/packaging/__init__.py | 6 +
pyanaconda/packaging/rpmostreepayload.py | 246 +++++++++++++++++++++++++++++++
7 files changed, 302 insertions(+), 19 deletions(-)
create mode 100644 pyanaconda/packaging/rpmostreepayload.py
diff --git a/data/post-scripts/80-setfilecons.ks b/data/post-scripts/80-setfilecons.ks
index 93ac962..f0d0414 100644
--- a/data/post-scripts/80-setfilecons.ks
+++ b/data/post-scripts/80-setfilecons.ks
@@ -4,6 +4,9 @@ restorecon -ir /etc/sysconfig/network-scripts /var/lib /etc/lvm \
/dev /etc/iscsi /var/lib/iscsi /root /var/lock /var/log \
/etc/modprobe.d /etc/sysconfig /var/cache/yum
+# Also relabel the OSTree variants of the normal mounts (if they exist)
+restorecon -ir /var/roothome /var/home /var/opt /var/srv /var/media /var/mnt
+
restorecon -i /etc/rpm/macros /etc/dasd.conf /etc/zfcp.conf /lib64 /usr/lib64 \
/etc/blkid.tab* /etc/mtab /etc/fstab /etc/resolv.conf \
/etc/modprobe.conf* /var/log/*tmp /etc/crypttab \
diff --git a/po/POTFILES.in b/po/POTFILES.in
index 4b341fc..8df1636 100644
--- a/po/POTFILES.in
+++ b/po/POTFILES.in
@@ -25,6 +25,7 @@ pyanaconda/packaging/__init__.py
pyanaconda/packaging/livepayload.py
pyanaconda/packaging/tarpayload.py
pyanaconda/packaging/yumpayload.py
+pyanaconda/packaging/rpmostreepayload.py
# Interfaces
pyanaconda/ui/common.py
diff --git a/pyanaconda/__init__.py b/pyanaconda/__init__.py
index fad7a90..34d46e0 100644
--- a/pyanaconda/__init__.py
+++ b/pyanaconda/__init__.py
@@ -124,7 +124,10 @@ class Anaconda(object):
if not klass:
from flags import flags
- if flags.livecdInstall:
+ if self.ksdata.ostreesetup.seen:
+ from pyanaconda.packaging.rpmostreepayload import RPMOSTreePayload
+ klass = RPMOSTreePayload
+ elif flags.livecdInstall:
from pyanaconda.packaging.livepayload import LiveImagePayload
klass = LiveImagePayload
elif self.ksdata.method.method == "liveimg":
diff --git a/pyanaconda/bootloader.py b/pyanaconda/bootloader.py
index 860bde3..b6d5941 100644
--- a/pyanaconda/bootloader.py
+++ b/pyanaconda/bootloader.py
@@ -37,6 +37,7 @@ from pyanaconda.flags import flags
from blivet.errors import StorageError
from blivet.fcoe import fcoe
import pyanaconda.network
+from pyanaconda.packaging.rpmostreepayload import RPMOSTreePayload
from pyanaconda.nm import nm_device_hwaddress
from blivet import platform
from pyanaconda.i18n import _, N_
@@ -2355,6 +2356,23 @@ def writeSysconfigKernel(storage, version):
f.write("HYPERVISOR_ARGS=logging=vga,serial,memory\n")
f.close()
+def writeBootLoaderFinal(storage, payload, instClass, ksdata):
+ """ Do the final write of the bootloader. """
+
+ from pyanaconda.errors import errorHandler, ERROR_RAISE
+
+ # set up dracut/fips boot args
+ # XXX FIXME: do this from elsewhere?
+ storage.bootloader.set_boot_args(storage=storage,
+ payload=payload,
+ keyboard=ksdata.keyboard)
+ try:
+ storage.bootloader.write()
+ except BootLoaderError as e:
+ log.error("bootloader.write failed: %s" % e)
+ if errorHandler.cb(e) == ERROR_RAISE:
+ raise
+
def writeBootLoader(storage, payload, instClass, ksdata):
""" Write bootloader configuration to disk.
@@ -2362,14 +2380,19 @@ def writeBootLoader(storage, payload, instClass, ksdata):
image. We only have to add images for the non-default kernels and
adjust the default to reflect whatever the default variant is.
"""
- from pyanaconda.errors import errorHandler, ERROR_RAISE
-
if not storage.bootloader.skip_bootloader:
stage1_device = storage.bootloader.stage1_device
log.info("bootloader stage1 target device is %s" % stage1_device.name)
stage2_device = storage.bootloader.stage2_device
log.info("bootloader stage2 target device is %s" % stage2_device.name)
+ if isinstance(payload, RPMOSTreePayload):
+ if storage.bootloader.skip_bootloader:
+ log.info("skipping bootloader install per user request")
+ return
+ writeBootLoaderFinal(storage, payload, instClass, ksdata)
+ return
+
# get a list of installed kernel packages
kernel_versions = payload.kernelVersionList
if not kernel_versions:
@@ -2414,19 +2437,4 @@ def writeBootLoader(storage, payload, instClass, ksdata):
label=label, short=short)
storage.bootloader.add_image(image)
- # set up dracut/fips boot args
- # XXX FIXME: do this from elsewhere?
- #storage.bootloader.set_boot_args(keyboard=anaconda.keyboard,
- # storage=anaconda.storage,
- # language=anaconda.instLanguage,
- # network=anaconda.network)
- storage.bootloader.set_boot_args(storage=storage,
- payload=payload,
- keyboard=ksdata.keyboard)
-
- try:
- storage.bootloader.write()
- except BootLoaderError as e:
- if errorHandler.cb(e) == ERROR_RAISE:
- raise
-
+ writeBootLoaderFinal(storage, payload, instClass, ksdata)
diff --git a/pyanaconda/install.py b/pyanaconda/install.py
index 68551cc..d771f5b 100644
--- a/pyanaconda/install.py
+++ b/pyanaconda/install.py
@@ -107,6 +107,17 @@ def doConfiguration(storage, payload, ksdata, instClass):
progressQ.send_complete()
+def moveBootMntToPhysical(storage):
+ """Move the /boot mount to /mnt/sysimage/boot."""
+ if iutil.getSysroot() == iutil.getTargetPhysicalRoot():
+ return
+ bootmnt = storage.mountpoints.get('/boot')
+ if bootmnt is None:
+ return
+ bootmnt.format.teardown()
+ bootmnt.teardown()
+ bootmnt.format.setup(bootmnt.format.options, chroot=iutil.getTargetPhysicalRoot())
+
def doInstall(storage, payload, ksdata, instClass):
"""Perform an installation. This method takes the ksdata as prepared by
the UI (the first hub, in graphical mode) and applies it to the disk.
@@ -189,6 +200,8 @@ def doInstall(storage, payload, ksdata, instClass):
rootmnt.setup()
rootmnt.format.setup(rootmnt.format.options, chroot=iutil.getTargetPhysicalRoot())
+ payload.prepareMountTargets(storage)
+
# Everything else goes in the target root, including /boot
# since the bootloader code will expect to find /boot
# inside the chroot.
@@ -202,6 +215,9 @@ def doInstall(storage, payload, ksdata, instClass):
writeBootLoader(storage, payload, instClass, ksdata)
with progress_report(_("Performing post-installation setup tasks")):
+ # Now, let's reset the state here so that the payload has
+ # /boot in the system root.
+ moveBootMntToPhysical(storage)
payload.postInstall()
progressQ.send_complete()
diff --git a/pyanaconda/packaging/__init__.py b/pyanaconda/packaging/__init__.py
index 9b97149..4a5e793 100644
--- a/pyanaconda/packaging/__init__.py
+++ b/pyanaconda/packaging/__init__.py
@@ -128,6 +128,12 @@ class Payload(object):
""" Reset the instance, not including ksdata. """
pass
+ def prepareMountTargets(self, storage):
+ """Run when physical storage is mounted, but other mount points may
+ not exist. Used by the RPMOSTreePayload subclass.
+ """
+ pass
+
###
### METHODS FOR WORKING WITH REPOSITORIES
###
diff --git a/pyanaconda/packaging/rpmostreepayload.py b/pyanaconda/packaging/rpmostreepayload.py
new file mode 100644
index 0000000..1b24a0f
--- /dev/null
+++ b/pyanaconda/packaging/rpmostreepayload.py
@@ -0,0 +1,246 @@
+# ostreepayload.py
+# Deploy OSTree trees to target
+#
+# Copyright (C) 2012,2014 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): Colin Walters <walters@redhat.com>
+#
+
+import os
+import shutil
+
+from pyanaconda import iutil
+from pyanaconda.i18n import _
+from pyanaconda.progress import progressQ
+from gi.repository import GLib
+from gi.repository import Gio
+
+from blivet.size import Size
+
+import logging
+log = logging.getLogger("anaconda")
+
+from pyanaconda.packaging import ArchivePayload, PayloadInstallError
+import pyanaconda.errors as errors
+
+class RPMOSTreePayload(ArchivePayload):
+ """ A RPMOSTreePayload deploys a tree (possibly with layered packages) onto the target system. """
+ def __init__(self, data):
+ super(RPMOSTreePayload, self).__init__(data)
+
+ def setup(self, storage):
+ super(RPMOSTreePayload, self).setup(storage)
+
+ @property
+ def handlesBootloaderConfiguration(self):
+ return True
+
+ @property
+ def kernelVersionList(self):
+ # OSTree handles bootloader configuration
+ return []
+
+ @property
+ def spaceRequired(self):
+ # We don't have this data with OSTree at the moment
+ return Size(spec="500 MB")
+
+ def _safeExecWithRedirect(self, cmd, argv, **kwargs):
+ """Like iutil.execWithRedirect, but treat errors as fatal"""
+ rc = iutil.execWithRedirect(cmd, argv, **kwargs)
+ if rc != 0:
+ exn = PayloadInstallError("%s %s exited with code %d" % (cmd, argv, rc))
+ if errors.errorHandler.cb(exn) == errors.ERROR_RAISE:
+ raise exn
+
+ def _pullProgressCb(self, asyncProgress):
+ status = asyncProgress.get_status()
+ outstanding_fetches = asyncProgress.get_uint('outstanding-fetches')
+ if status:
+ progressQ.send_message(status)
+ elif outstanding_fetches > 0:
+ bytes_transferred = asyncProgress.get_uint64('bytes-transferred')
+ fetched = asyncProgress.get_uint('fetched')
+ requested = asyncProgress.get_uint('requested')
+ formatted_bytes = GLib.format_size_full(bytes_transferred, 0)
+
+ if requested == 0:
+ percent = 0.0
+ else:
+ percent = (fetched*1.0 / requested) * 100
+
+ progressQ.send_message("Receiving objects: %d%% (%d/%d) %s" % (percent, fetched, requested, formatted_bytes))
+ else:
+ progressQ.send_message("Writing objects")
+
+ def install(self):
+ cancellable = None
+ from gi.repository import OSTree
+ ostreesetup = self.data.ostreesetup
+ log.info("executing ostreesetup=%r" % ostreesetup)
+
+ # Initialize the filesystem - this will create the repo as well
+ self._safeExecWithRedirect("ostree",
+ ["admin", "--sysroot=" + iutil.getTargetPhysicalRoot(),
+ "init-fs", iutil.getTargetPhysicalRoot()])
+
+ repo_arg = "--repo=" + iutil.getTargetPhysicalRoot() + '/ostree/repo'
+
+ # Set up the chosen remote
+ remote_args = [repo_arg, "remote", "add"]
+ if ((hasattr(ostreesetup, 'noGpg') and ostreesetup.noGpg) or
+ (hasattr(ostreesetup, 'nogpg') and ostreesetup.nogpg)):
+ remote_args.append("--set=gpg-verify=false")
+ remote_args.extend([ostreesetup.remote,
+ ostreesetup.url])
+ self._safeExecWithRedirect("ostree", remote_args)
+
+ sysroot_path = Gio.File.new_for_path(iutil.getTargetPhysicalRoot())
+ sysroot = OSTree.Sysroot.new(sysroot_path)
+ sysroot.load(cancellable)
+
+ repo = sysroot.get_repo(None)[1]
+ repo.set_disable_fsync(True)
+ progressQ.send_message(_("Starting pull of %s from %s") % \
+ (ostreesetup.ref, ostreesetup.remote))
+
+ progress = OSTree.AsyncProgress.new()
+ progress.connect('changed', self._pullProgressCb)
+ repo.pull(ostreesetup.remote, [ostreesetup.ref], 0, progress, cancellable)
+
+ progressQ.send_message(_("Preparing deployment of %s") % (ostreesetup.ref, ))
+
+ self._safeExecWithRedirect("ostree",
+ ["admin", "--sysroot=" + iutil.getTargetPhysicalRoot(),
+ "os-init", ostreesetup.osname])
+
+ admin_deploy_args = ["admin", "--sysroot=" + iutil.getTargetPhysicalRoot(),
+ "deploy", "--os=" + ostreesetup.osname]
+
+ admin_deploy_args.append(ostreesetup.remote + ':' + ostreesetup.ref)
+
+ log.info("ostree admin deploy starting")
+ progressQ.send_message(_("Deployment starting: %s") % (ostreesetup.ref, ))
+ self._safeExecWithRedirect("ostree", admin_deploy_args)
+ log.info("ostree admin deploy complete")
+ progressQ.send_message(_("Deployment complete: %s") % (ostreesetup.ref, ))
+
+ # Reload now that we've deployed, find the path to the new deployment
+ sysroot.load(None)
+ deployments = sysroot.get_deployments()
+ assert len(deployments) > 0
+ deployment = deployments[0]
+ deployment_path = sysroot.get_deployment_directory(deployment)
+ iutil.setSysroot(deployment_path.get_path())
+
+ varroot = iutil.getTargetPhysicalRoot() + '/ostree/deploy/' + ostreesetup.osname + '/var'
+
+ # This is a bit of a hack; we precreate the targets of
+ # possible mounts of legacy paths like /home and /opt so the
+ # installer/%post scripts can find them. In particular,
+ # Anaconda itself writes to /root/anaconda-ks.cfg. What we
+ # really should do is export this data in some way the
+ # installer can read reliably. Right now it's just encoded in
+ # systemd-tmpfiles.
+ for (dname, mode) in [('root', 0700), ('home', 0755),
+ ('opt', 0755), ('srv', 0755),
+ ('media', 0755), ('mnt', 0755)]:
+ linksrc = iutil.getSysroot() + '/' + dname
+ if os.path.islink(linksrc) and not os.path.isdir(linksrc):
+ linkdata = os.readlink(linksrc)
+ if linkdata.startswith('var/'):
+ linkdest = varroot + '/' + linkdata[4:]
+ log.info("Creating %s" % linkdest)
+ os.mkdir(linkdest, mode)
+
+ # Copy specific bootloader data files from the deployment
+ # checkout to the target root. See
+ # https://bugzilla.gnome.org/show_bug.cgi?id=726757 This
+ # happens once, at installation time.
+ # extlinux ships its modules directly in the RPM in /boot.
+ # For GRUB2, Anaconda installs device.map there. We may need
+ # to add other bootloaders here though (if they can't easily
+ # be fixed to *copy* data into /boot at install time, instead
+ # of shipping it in the RPM).
+ physboot = iutil.getTargetPhysicalRoot() + '/boot'
+ sysboot = iutil.getSysroot() + '/boot'
+ for fname in ['extlinux', 'grub2']:
+ srcpath = os.path.join(sysboot, fname)
+ if os.path.isdir(srcpath):
+ log.info("Copying bootloader data: " + fname)
+ shutil.copytree(srcpath, os.path.join(physboot, fname))
+
+ def prepareMountTargets(self, storage):
+ ostreesetup = self.data.ostreesetup
+
+ varroot = iutil.getTargetPhysicalRoot() + '/ostree/deploy/' + ostreesetup.osname + '/var'
+
+ # Set up bind mounts as if we've booted the target system, so
+ # that %post script work inside the target.
+ binds = [(iutil.getTargetPhysicalRoot(),
+ iutil.getSysroot() + '/sysroot'),
+ (varroot,
+ iutil.getSysroot() + '/var'),
+ (iutil.getSysroot() + '/usr', None)]
+
+ for (src, dest) in binds:
+ self._safeExecWithRedirect("mount",
+ ["--bind", src, dest if dest else src])
+ if dest is None:
+ self._safeExecWithRedirect("mount",
+ ["--bind", "-o", "ro", src, src])
+
+ def postInstall(self):
+ super(RPMOSTreePayload, self).postInstall()
+
+ physboot = iutil.getTargetPhysicalRoot() + '/boot'
+
+ # If we're using extlinux, rename extlinux.conf to
+ # syslinux.cfg, since that's what OSTree knows about.
+ # syslinux upstream supports both, but I'd say that upstream
+ # using syslinux.cfg is somewhat preferred.
+ physboot_extlinux = physboot + '/extlinux'
+ if os.path.isdir(physboot_extlinux):
+ physboot_syslinux = physboot + '/syslinux'
+ physboot_loader = physboot + '/loader'
+ assert os.path.isdir(physboot_loader)
+ orig_extlinux_conf = physboot_extlinux + '/extlinux.conf'
+ target_syslinux_cfg = physboot_loader + '/syslinux.cfg'
+ log.info("Moving %s -> %s" % (orig_extlinux_conf, target_syslinux_cfg))
+ os.rename(orig_extlinux_conf, target_syslinux_cfg)
+ # A compatibility bit for OSTree
+ os.mkdir(physboot_syslinux)
+ os.symlink('../loader/syslinux.cfg', physboot_syslinux + '/syslinux.cfg')
+ # And *also* tell syslinux that the config is really in /boot/loader
+ os.symlink('loader/syslinux.cfg', physboot + '/syslinux.cfg')
+
+ # OSTree owns the bootloader configuration, so here we give it
+ # the argument list we computed from storage, architecture and
+ # such.
+ set_kargs_args = ["admin", "--sysroot=" + iutil.getTargetPhysicalRoot(),
+ "instutil", "set-kargs"]
+ set_kargs_args.extend(self.storage.bootloader.boot_args)
+ set_kargs_args.append("root=" + self.storage.rootDevice.fstabSpec)
+ self._safeExecWithRedirect("ostree", set_kargs_args)
+
+ # This command iterates over all files we might have created
+ # and ensures they're labeled. It's like running
+ # chroot(iutil.getTargetPhysicalRoot()) + fixfiles, except
+ # with a better name and semantics.
+ self._safeExecWithRedirect("ostree",
+ ["admin", "--sysroot=" + iutil.getTargetPhysicalRoot(),
+ "instutil", "selinux-ensure-labeled", iutil.getTargetPhysicalRoot(), ""])
--
1.9.3