overlay lib: draft new source OVL design... tbd

Author: pirat89

repos/system_upgrade/common/libraries/overlaygen.py

@@ -10,16 +10,65 @@
 
 OVERLAY_DO_NOT_MOUNT = ('tmpfs', 'devpts', 'sysfs', 'proc', 'cramfs', 'sysv', 'vfat')
 
+# NOTE(pstodulk): what about using more closer values and than just multiply
+# the final result by magical constant?... this number is most likely going to
+# be lowered and affected by XFS vs EXT4 FSs that needs different spaces each
+# of them.
+_MAGICAL_CONSTANT_OVL_SIZE = 128
+"""
+Average size of created disk space images.
+
+The size can be lower or higher - usually lower. The value is higher as we want
+to rather prevent future actions in advance instead of resolving later issues
+with the missing space.
+"""
+
+_MAGICAL_CONSTANT_MIN_CONSUMED_SPACE = 2500
+"""
+Average space consumed on downloads and target userspace container installation.
+
+On minimal systems it's approx 1.7GiB. Using higher value little bit to cover
+most expected cases. The value can be enlarged in future, but currently seems
+to me as a good compromise.
+"""
+
 
 MountPoints = namedtuple('MountPoints', ['fs_file', 'fs_vfstype'])
 
 
+def get_recommended_leapp_free_space(userspace_path=''):
+    """
+    Return recommended free space on partition hosting target userspace container in MB
+
+    If the path to the container is set, the returned value is updated to
+    reflect already consumed space.
+
+    TODO(pstodulk): this is so far the best trade off between stay safe and do
+    do not consume too much space
+    """
+    return _MAGICAL_CONSTANT_MIN_CONSUMED_SPACE
+
+def _ensure_enough_diskimage_space(space_needed, directory):
+    # TODO: not changed yet
+    stat = os.statvfs(directory)
+    if (stat.f_frsize * stat.f_bavail) < (space_needed * 1024 * 1024):
+        # TODO(pstodulk): update the msg? People would be still thinking about
+        # LEAPP_OVL_SIZE envar that is obsoleted.
+        message = ('Not enough space available for creating required disk images in {directory}. ' +
+                   'Needed: {space_needed} MiB').format(space_needed=space_needed, directory=directory)
+        api.current_logger().error(message)
+        raise StopActorExecutionError(message)
+
+
 def _get_mountpoints(storage_info):
+    # TODO: not changed yet
     mount_points = set()
     for entry in storage_info.fstab:
         if os.path.isdir(entry.fs_file) and entry.fs_vfstype not in OVERLAY_DO_NOT_MOUNT:
             mount_points.add(MountPoints(entry.fs_file, entry.fs_vfstype))
         elif os.path.isdir(entry.fs_file) and entry.fs_vfstype == 'vfat':
+            # VFAT FS is not supported to be used for any system partition,
+            # so we can safely ignore it
             api.current_logger().warning(
                 'Ignoring vfat {} filesystem mount during upgrade process'.format(entry.fs_file)
             )
@@ -35,6 +84,29 @@ def _mount_dir(mounts_dir, mountpoint):
     return os.path.join(mounts_dir, _mount_name(mountpoint))
 
 
+def _prepare_required_mounts(scratch_dir, mounts_dir, storage_info, scratch_reserve):
+    mount_points = _get_mountpoints(storage_info)
+    # TODO(pstodulk): update the calculation for bind mounted mount_points (skip)
+    space_needed = scratch_reserve + _MAGICAL_CONSTANT_OVL_SIZE * len(mount_points)
+    disk_images_directory = os.path.join(scratch_dir, 'diskimages')
+
+    # Ensure we cleanup old disk images before we check for space constraints.
+    # NOTE(pstodulk): Could we improve the process so we create imgs & calculate
+    # the required disk space just once during each leapp (pre)upgrade run?
+    run(['rm', '-rf', disk_images_directory])
+    _create_diskimages_dir(scratch_dir, disk_images_directory)
+    _ensure_enough_diskimage_space(space_needed, scratch_dir)
+
+    result = {}
+    for mountpoint in mount_points:
+        image = _create_mount_disk_image(disk_images_directory, mountpoint.fs_file)
+        result[mountpoint.fs_file] = mounting.LoopMount(
+            source=image,
+            target=_mount_dir(mounts_dir, mountpoint.fs_file)
+        )
+    return result
+
+
 @contextlib.contextmanager
 def _build_overlay_mount(root_mount, mounts):
     if not root_mount:
@@ -70,6 +142,106 @@ def cleanup_scratch(scratch_dir, mounts_dir):
     api.current_logger().debug('Recursively removed scratch directory %s.', scratch_dir)
 
 
+def _format_disk_image_ext4(diskimage_path):
+    """
+    Format the specified disk image with Ext4 filesystem.
+
+    The formatted file system is optimized for operations we want to do and
+    mainly for the space it needs to take for the initialisation. So use 32MiB
+    journal (that's enough for us as we do not plan to do too many operations
+    inside) for any size of the disk image. Also the lazy
+    initialisation is disabled. The formatting will be slower, but it helps
+    us to estimate better the needed amount of the space for other actions
+    done later.
+    """
+    api.current_logger().debug('Creating ext4 filesystem in disk image at %s', diskimage_path)
+    cmd = [
+        '/sbin/mkfs.ext4',
+        '-J', 'size=32',
+        '-E', 'lazy_itable_init=0,lazy_journal_init=0',
+        '-F', diskimage_path
+    ]
+    try:
+        utils.call_with_oserror_handled(cmd=cmd)
+    except CalledProcessError as e:
+        # FIXME(pstodulk): taken from original, but %s seems to me invalid here
+        api.current_logger().error('Failed to create ext4 filesystem %s', exc_info=True)
+        raise StopActorExecutionError(
+            message=str(e)
+        )
+
+def _format_disk_image_xfs(diskimage_path):
+    """
+    Format the specified disk image with XFS filesystem.
+
+    Set journal just to 32MiB always as we will not need to do too many operation
+    inside, so 32MiB should enough for us.
+    """
+    api.current_logger().debug('Creating XFS filesystem in disk image at %s', diskimage_path)
+    cmd = ['/sbin/mkfs.xfs', '-l', 'size=32m', '-f', diskimage_path]
+    try:
+        utils.call_with_oserror_handled(cmd=cmd)
+    except CalledProcessError as e:
+        # FIXME(pstodulk): taken from original, but %s seems to me invalid here
+        api.current_logger().error('Failed to create XFS filesystem %s', exc_info=True)
+        raise StopActorExecutionError(
+            message=str(e)
+        )
+
+
+def _create_mount_disk_image(disk_images_directory, path, disk_size):
+    """
+    Creates the mount disk image
+
+    The disk image is represented by a sparse file which apparent size
+    corresponds to the free space of a particular partition/volume it
+    represents.
+
+    The created disk image uses is formatted with XFS (default) or Ext4 FS
+    and it's supposed to be used for write directories of an overlayfs built
+    above it.
+    """
+    diskimage_path = os.path.join(disk_images_directory, _mount_name(path))
+    # TODO(pstodulk): update the disk_size
+
+    api.current_logger().debug('Attempting to create disk image with size %d MiB at %s', disk_size, diskimage_path)
+    # TODO(pstodulk): not sure the hint is still valid..
+    utils.call_with_failure_hint(
+        cmd=['/bin/dd', 'if=/dev/zero', 'of={}'.format(diskimage_path), 'bs=1M', 'count=0', 'seek={}'.format(disk_size)],
+        hint='Please ensure that there is enough diskspace in {}.'.format(diskimage_path)
+    )
+
+    if get_env('LEAPP_OVL_IMG_FS_EXT4', '0') == '1':
+        # This is alternative to XFS in case we find some issues, to be able
+        # to switch simply to Ext4, so we will be able to simple investigate
+        # possible issues between overlay <-> XFS if any happens.
+        _format_disk_image_ext4(diskimage_path)
+    else:
+        _format_disk_image_xfs(diskimage_path)
+
+    return diskimage_path
+
+
+def _create_diskimages_dir(scratch_dir, diskimages_dir):
+    """
+    Prepares directories for disk images
+    """
+    api.current_logger().debug('Creating disk images directory.')
+    try:
+        utils.makedirs(diskimages_dir)
+        api.current_logger().debug('Done creating disk images directory.')
+    except OSError:
+        api.current_logger().error('Failed to create disk images directory %s', diskimages_dir, exc_info=True)
+
+        # This is an attempt for giving the user a chance to resolve it on their own
+        raise StopActorExecutionError(
+            message='Failed to prepare environment for package download while creating directories.',
+            details={
+                'hint': 'Please ensure that {scratch_dir} is empty and modifiable.'.format(scratch_dir=scratch_dir)
+            }
+        )
+
+
 def _create_mounts_dir(scratch_dir, mounts_dir):
     """
     Prepares directories for mounts
@@ -102,15 +274,59 @@ def _mount_dnf_cache(overlay_target):
 
 
 @contextlib.contextmanager
-def create_source_overlay(mounts_dir, scratch_dir, xfs_info, storage_info, mount_target=None):
+def create_source_overlay(mounts_dir, scratch_dir, xfs_info, storage_info, mount_target=None, scratch_reserve=0):
     """
     Context manager that prepares the source system overlay and yields the mount.
+
+    The in-place upgrade itself requires to do some changes on the system to be
+    able to perform the in-place upgrade itself - or even to be able to evaluate
+    if the system is possible to upgrade. However, we do not want to (and must not)
+    change the original system until we pass beyond the point of not return.
+
+    For that purposes we have to create a layer above the real host file system,
+    where we can safely perform all operations without affecting the system
+    setup, rpm database, etc. Currently overlay (OVL) technology showed it is
+    capable to handle our requirements good enough - with some limitations.
+
+    This function prepares a disk image and an overlay layer for each
+    mountpoint configured in /etc/fstab, excluding those with FS type noted
+    in the OVERLAY_DO_NOT_MOUNT set. Such prepared OVL images are then composed
+    together to reflect the real host filesystem. In the end everything is cleaned.
+
+    The new solution can be now problematic for system with too many partitions
+    and loop devices. For such systems we keep for now the possibility of the
+    fallback to an old solution, which has however number of issues that are
+    fixed by the new design. To fallback to the old solution, set envar:
+        LEAPP_OVL_FALLBACK=1
+
+    Disk images created for OVL are formatted with XFS by default. In case of
+    problems, it's possible to switch to Ext4 FS using:
+        LEAPP_OVL_IMG_FS_EXT4=1
+
+    :param mounts_dir: Absolute path to the directory under which all mounts should happen.
+    :type mounts_dir: str
+    :param scratch_dir: Absolute path to the directory in which all disk and OVL images are stored.
+    :type scratch_dir: str
+    :param xfs_info: The XFSPresence message.
+    :type xfs_info: leapp.models.XFSPresence
+    :param storage_info: The StorageInfo message.
+    :type storage_info: leapp.models.StorageInfo
+    :param mount_target: Directory to which whole source OVL layer should be bind mounted.
+                         If None (default), mounting.NullMount is created instead
+    :type mount_target: Optional[str]
+    :param scratch_reserve: Number of MB that should be extra reserved in a partition hosting the scratch_dir.
+    :type scratch_reserve: Optional[int]
+    :rtype: mounting.BindMount or mounting.NullMount
     """
     api.current_logger().debug('Creating source overlay in {scratch_dir} with mounts in {mounts_dir}'.format(
         scratch_dir=scratch_dir, mounts_dir=mounts_dir))
     try:
         _create_mounts_dir(scratch_dir, mounts_dir)
-        mounts = _prepare_required_mounts_old(scratch_dir, mounts_dir, _get_mountpoints(storage_info), xfs_info)
+        if get_env('LEAPP_OVL_FALLBACK', '0') != '1':
+            mounts = _prepare_required_mounts(scratch_dir, mounts_dir, storage_info, scratch_reserve)
+        else:
+            # fallback to the deprecated OVL solution
+            mounts = _prepare_required_mounts_old(scratch_dir, mounts_dir, _get_mountpoints(storage_info), xfs_info)
         with mounts.pop('/') as root_mount:
             with mounting.OverlayMount(name='system_overlay', source='/', workdir=root_mount.target) as root_overlay:
                 if mount_target: