[Subtree] Removing import-layers directory

As part of the move to subtrees, need to bring all the import layers
content to the top level.

Change-Id: I4a163d10898cbc6e11c27f776f60e1a470049d8f
Signed-off-by: Dave Cobbley <david.j.cobbley@linux.intel.com>
Signed-off-by: Brad Bishop <bradleyb@fuzziesquirrel.com>

7 files changed, 0 insertions, 1887 deletions

diff --git a/import-layers/yocto-poky/scripts/lib/wic/plugins/imager/direct.py b/import-layers/yocto-poky/scripts/lib/wic/plugins/imager/direct.py
deleted file mode 100644
index 1fa6b917e..000000000
--- a/import-layers/yocto-poky/scripts/lib/wic/plugins/imager/direct.py
+++ /dev/null
@@ -1,607 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-#
-# Copyright (c) 2013, Intel Corporation.
-# All rights reserved.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 2 as
-# published by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty 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.
-#
-# DESCRIPTION
-# This implements the 'direct' imager plugin class for 'wic'
-#
-# AUTHORS
-# Tom Zanussi <tom.zanussi (at] linux.intel.com>
-#
-
-import logging
-import os
-import random
-import shutil
-import tempfile
-import uuid
-
-from time import strftime
-
-from oe.path import copyhardlinktree
-
-from wic import WicError
-from wic.filemap import sparse_copy
-from wic.ksparser import KickStart, KickStartError
-from wic.pluginbase import PluginMgr, ImagerPlugin
-from wic.misc import get_bitbake_var, exec_cmd, exec_native_cmd
-
-logger = logging.getLogger('wic')
-
-class DirectPlugin(ImagerPlugin):
-    """
-    Install a system into a file containing a partitioned disk image.
-
-    An image file is formatted with a partition table, each partition
-    created from a rootfs or other OpenEmbedded build artifact and dd'ed
-    into the virtual disk. The disk image can subsequently be dd'ed onto
-    media and used on actual hardware.
-    """
-    name = 'direct'
-
-    def __init__(self, wks_file, rootfs_dir, bootimg_dir, kernel_dir,
-                 native_sysroot, oe_builddir, options):
-        try:
-            self.ks = KickStart(wks_file)
-        except KickStartError as err:
-            raise WicError(str(err))
-
-        # parse possible 'rootfs=name' items
-        self.rootfs_dir = dict(rdir.split('=') for rdir in rootfs_dir.split(' '))
-        self.replaced_rootfs_paths = {}
-        self.bootimg_dir = bootimg_dir
-        self.kernel_dir = kernel_dir
-        self.native_sysroot = native_sysroot
-        self.oe_builddir = oe_builddir
-
-        self.outdir = options.outdir
-        self.compressor = options.compressor
-        self.bmap = options.bmap
-        self.no_fstab_update = options.no_fstab_update
-
-        self.name = "%s-%s" % (os.path.splitext(os.path.basename(wks_file))[0],
-                               strftime("%Y%m%d%H%M"))
-        self.workdir = tempfile.mkdtemp(dir=self.outdir, prefix='tmp.wic.')
-        self._image = None
-        self.ptable_format = self.ks.bootloader.ptable
-        self.parts = self.ks.partitions
-
-        # as a convenience, set source to the boot partition source
-        # instead of forcing it to be set via bootloader --source
-        for part in self.parts:
-            if not self.ks.bootloader.source and part.mountpoint == "/boot":
-                self.ks.bootloader.source = part.source
-                break
-
-        image_path = self._full_path(self.workdir, self.parts[0].disk, "direct")
-        self._image = PartitionedImage(image_path, self.ptable_format,
-                                       self.parts, self.native_sysroot)
-
-    def do_create(self):
-        """
-        Plugin entry point.
-        """
-        try:
-            self.create()
-            self.assemble()
-            self.finalize()
-            self.print_info()
-        finally:
-            self.cleanup()
-
-    def _write_fstab(self, image_rootfs):
-        """overriden to generate fstab (temporarily) in rootfs. This is called
-        from _create, make sure it doesn't get called from
-        BaseImage.create()
-        """
-        if not image_rootfs:
-            return
-
-        fstab_path = image_rootfs + "/etc/fstab"
-        if not os.path.isfile(fstab_path):
-            return
-
-        with open(fstab_path) as fstab:
-            fstab_lines = fstab.readlines()
-
-        if self._update_fstab(fstab_lines, self.parts):
-            # copy rootfs dir to workdir to update fstab
-            # as rootfs can be used by other tasks and can't be modified
-            new_rootfs = os.path.realpath(os.path.join(self.workdir, "rootfs_copy"))
-            copyhardlinktree(image_rootfs, new_rootfs)
-            fstab_path = os.path.join(new_rootfs, 'etc/fstab')
-
-            os.unlink(fstab_path)
-
-            with open(fstab_path, "w") as fstab:
-                fstab.writelines(fstab_lines)
-
-            return new_rootfs
-
-    def _update_fstab(self, fstab_lines, parts):
-        """Assume partition order same as in wks"""
-        updated = False
-        for part in parts:
-            if not part.realnum or not part.mountpoint \
-               or part.mountpoint == "/":
-                continue
-
-            if part.use_uuid:
-                if part.fsuuid:
-                    # FAT UUID is different from others
-                    if len(part.fsuuid) == 10:
-                        device_name = "UUID=%s-%s" % \
-                                       (part.fsuuid[2:6], part.fsuuid[6:])
-                    else:
-                        device_name = "UUID=%s" % part.fsuuid
-                else:
-                    device_name = "PARTUUID=%s" % part.uuid
-            else:
-                # mmc device partitions are named mmcblk0p1, mmcblk0p2..
-                prefix = 'p' if  part.disk.startswith('mmcblk') else ''
-                device_name = "/dev/%s%s%d" % (part.disk, prefix, part.realnum)
-
-            opts = part.fsopts if part.fsopts else "defaults"
-            line = "\t".join([device_name, part.mountpoint, part.fstype,
-                              opts, "0", "0"]) + "\n"
-
-            fstab_lines.append(line)
-            updated = True
-
-        return updated
-
-    def _full_path(self, path, name, extention):
-        """ Construct full file path to a file we generate. """
-        return os.path.join(path, "%s-%s.%s" % (self.name, name, extention))
-
-    #
-    # Actual implemention
-    #
-    def create(self):
-        """
-        For 'wic', we already have our build artifacts - we just create
-        filesystems from the artifacts directly and combine them into
-        a partitioned image.
-        """
-        if self.no_fstab_update:
-            new_rootfs = None
-        else:
-            new_rootfs = self._write_fstab(self.rootfs_dir.get("ROOTFS_DIR"))
-        if new_rootfs:
-            # rootfs was copied to update fstab
-            self.replaced_rootfs_paths[new_rootfs] = self.rootfs_dir['ROOTFS_DIR']
-            self.rootfs_dir['ROOTFS_DIR'] = new_rootfs
-
-        for part in self.parts:
-            # get rootfs size from bitbake variable if it's not set in .ks file
-            if not part.size:
-                # and if rootfs name is specified for the partition
-                image_name = self.rootfs_dir.get(part.rootfs_dir)
-                if image_name and os.path.sep not in image_name:
-                    # Bitbake variable ROOTFS_SIZE is calculated in
-                    # Image._get_rootfs_size method from meta/lib/oe/image.py
-                    # using IMAGE_ROOTFS_SIZE, IMAGE_ROOTFS_ALIGNMENT,
-                    # IMAGE_OVERHEAD_FACTOR and IMAGE_ROOTFS_EXTRA_SPACE
-                    rsize_bb = get_bitbake_var('ROOTFS_SIZE', image_name)
-                    if rsize_bb:
-                        part.size = int(round(float(rsize_bb)))
-
-        self._image.prepare(self)
-        self._image.layout_partitions()
-        self._image.create()
-
-    def assemble(self):
-        """
-        Assemble partitions into disk image
-        """
-        self._image.assemble()
-
-    def finalize(self):
-        """
-        Finalize the disk image.
-
-        For example, prepare the image to be bootable by e.g.
-        creating and installing a bootloader configuration.
-        """
-        source_plugin = self.ks.bootloader.source
-        disk_name = self.parts[0].disk
-        if source_plugin:
-            plugin = PluginMgr.get_plugins('source')[source_plugin]
-            plugin.do_install_disk(self._image, disk_name, self, self.workdir,
-                                   self.oe_builddir, self.bootimg_dir,
-                                   self.kernel_dir, self.native_sysroot)
-
-        full_path = self._image.path
-        # Generate .bmap
-        if self.bmap:
-            logger.debug("Generating bmap file for %s", disk_name)
-            python = os.path.join(self.native_sysroot, 'usr/bin/python3-native/python3')
-            bmaptool = os.path.join(self.native_sysroot, 'usr/bin/bmaptool')
-            exec_native_cmd("%s %s create %s -o %s.bmap" % \
-                            (python, bmaptool, full_path, full_path), self.native_sysroot)
-        # Compress the image
-        if self.compressor:
-            logger.debug("Compressing disk %s with %s", disk_name, self.compressor)
-            exec_cmd("%s %s" % (self.compressor, full_path))
-
-    def print_info(self):
-        """
-        Print the image(s) and artifacts used, for the user.
-        """
-        msg = "The new image(s) can be found here:\n"
-
-        extension = "direct" + {"gzip": ".gz",
-                                "bzip2": ".bz2",
-                                "xz": ".xz",
-                                None: ""}.get(self.compressor)
-        full_path = self._full_path(self.outdir, self.parts[0].disk, extension)
-        msg += '  %s\n\n' % full_path
-
-        msg += 'The following build artifacts were used to create the image(s):\n'
-        for part in self.parts:
-            if part.rootfs_dir is None:
-                continue
-            if part.mountpoint == '/':
-                suffix = ':'
-            else:
-                suffix = '["%s"]:' % (part.mountpoint or part.label)
-            rootdir = part.rootfs_dir
-            if rootdir in self.replaced_rootfs_paths:
-                rootdir = self.replaced_rootfs_paths[rootdir]
-            msg += '  ROOTFS_DIR%s%s\n' % (suffix.ljust(20), rootdir)
-
-        msg += '  BOOTIMG_DIR:                  %s\n' % self.bootimg_dir
-        msg += '  KERNEL_DIR:                   %s\n' % self.kernel_dir
-        msg += '  NATIVE_SYSROOT:               %s\n' % self.native_sysroot
-
-        logger.info(msg)
-
-    @property
-    def rootdev(self):
-        """
-        Get root device name to use as a 'root' parameter
-        in kernel command line.
-
-        Assume partition order same as in wks
-        """
-        for part in self.parts:
-            if part.mountpoint == "/":
-                if part.uuid:
-                    return "PARTUUID=%s" % part.uuid
-                else:
-                    suffix = 'p' if part.disk.startswith('mmcblk') else ''
-                    return "/dev/%s%s%-d" % (part.disk, suffix, part.realnum)
-
-    def cleanup(self):
-        if self._image:
-            self._image.cleanup()
-
-        # Move results to the output dir
-        if not os.path.exists(self.outdir):
-            os.makedirs(self.outdir)
-
-        for fname in os.listdir(self.workdir):
-            path = os.path.join(self.workdir, fname)
-            if os.path.isfile(path):
-                shutil.move(path, os.path.join(self.outdir, fname))
-
-        # remove work directory
-        shutil.rmtree(self.workdir, ignore_errors=True)
-
-# Overhead of the MBR partitioning scheme (just one sector)
-MBR_OVERHEAD = 1
-
-# Overhead of the GPT partitioning scheme
-GPT_OVERHEAD = 34
-
-# Size of a sector in bytes
-SECTOR_SIZE = 512
-
-class PartitionedImage():
-    """
-    Partitioned image in a file.
-    """
-
-    def __init__(self, path, ptable_format, partitions, native_sysroot=None):
-        self.path = path  # Path to the image file
-        self.numpart = 0  # Number of allocated partitions
-        self.realpart = 0 # Number of partitions in the partition table
-        self.offset = 0   # Offset of next partition (in sectors)
-        self.min_size = 0 # Minimum required disk size to fit
-                          # all partitions (in bytes)
-        self.ptable_format = ptable_format  # Partition table format
-        # Disk system identifier
-        self.identifier = random.SystemRandom().randint(1, 0xffffffff)
-
-        self.partitions = partitions
-        self.partimages = []
-        # Size of a sector used in calculations
-        self.sector_size = SECTOR_SIZE
-        self.native_sysroot = native_sysroot
-
-        # calculate the real partition number, accounting for partitions not
-        # in the partition table and logical partitions
-        realnum = 0
-        for part in self.partitions:
-            if part.no_table:
-                part.realnum = 0
-            else:
-                realnum += 1
-                if self.ptable_format == 'msdos' and realnum > 3 and len(partitions) > 4:
-                    part.realnum = realnum + 1
-                    continue
-                part.realnum = realnum
-
-        # generate parition and filesystem UUIDs
-        for part in self.partitions:
-            if not part.uuid and part.use_uuid:
-                if self.ptable_format == 'gpt':
-                    part.uuid = str(uuid.uuid4())
-                else: # msdos partition table
-                    part.uuid = '%08x-%02d' % (self.identifier, part.realnum)
-            if not part.fsuuid:
-                if part.fstype == 'vfat' or part.fstype == 'msdos':
-                    part.fsuuid = '0x' + str(uuid.uuid4())[:8].upper()
-                else:
-                    part.fsuuid = str(uuid.uuid4())
-
-    def prepare(self, imager):
-        """Prepare an image. Call prepare method of all image partitions."""
-        for part in self.partitions:
-            # need to create the filesystems in order to get their
-            # sizes before we can add them and do the layout.
-            part.prepare(imager, imager.workdir, imager.oe_builddir,
-                         imager.rootfs_dir, imager.bootimg_dir,
-                         imager.kernel_dir, imager.native_sysroot)
-
-            # Converting kB to sectors for parted
-            part.size_sec = part.disk_size * 1024 // self.sector_size
-
-    def layout_partitions(self):
-        """ Layout the partitions, meaning calculate the position of every
-        partition on the disk. The 'ptable_format' parameter defines the
-        partition table format and may be "msdos". """
-
-        logger.debug("Assigning %s partitions to disks", self.ptable_format)
-
-        # The number of primary and logical partitions. Extended partition and
-        # partitions not listed in the table are not included.
-        num_real_partitions = len([p for p in self.partitions if not p.no_table])
-
-        # Go through partitions in the order they are added in .ks file
-        for num in range(len(self.partitions)):
-            part = self.partitions[num]
-
-            if self.ptable_format == 'msdos' and part.part_name:
-                raise WicError("setting custom partition name is not " \
-                               "implemented for msdos partitions")
-
-            if self.ptable_format == 'msdos' and part.part_type:
-                # The --part-type can also be implemented for MBR partitions,
-                # in which case it would map to the 1-byte "partition type"
-                # filed at offset 3 of the partition entry.
-                raise WicError("setting custom partition type is not " \
-                               "implemented for msdos partitions")
-
-            # Get the disk where the partition is located
-            self.numpart += 1
-            if not part.no_table:
-                self.realpart += 1
-
-            if self.numpart == 1:
-                if self.ptable_format == "msdos":
-                    overhead = MBR_OVERHEAD
-                elif self.ptable_format == "gpt":
-                    overhead = GPT_OVERHEAD
-
-                # Skip one sector required for the partitioning scheme overhead
-                self.offset += overhead
-
-            if self.realpart > 3 and num_real_partitions > 4:
-                # Reserve a sector for EBR for every logical partition
-                # before alignment is performed.
-                if self.ptable_format == "msdos":
-                    self.offset += 1
-
-            if part.align:
-                # If not first partition and we do have alignment set we need
-                # to align the partition.
-                # FIXME: This leaves a empty spaces to the disk. To fill the
-                # gaps we could enlargea the previous partition?
-
-                # Calc how much the alignment is off.
-                align_sectors = self.offset % (part.align * 1024 // self.sector_size)
-
-                if align_sectors:
-                    # If partition is not aligned as required, we need
-                    # to move forward to the next alignment point
-                    align_sectors = (part.align * 1024 // self.sector_size) - align_sectors
-
-                    logger.debug("Realignment for %s%s with %s sectors, original"
-                                 " offset %s, target alignment is %sK.",
-                                 part.disk, self.numpart, align_sectors,
-                                 self.offset, part.align)
-
-                    # increase the offset so we actually start the partition on right alignment
-                    self.offset += align_sectors
-
-            part.start = self.offset
-            self.offset += part.size_sec
-
-            part.type = 'primary'
-            if not part.no_table:
-                part.num = self.realpart
-            else:
-                part.num = 0
-
-            if self.ptable_format == "msdos":
-                # only count the partitions that are in partition table
-                if num_real_partitions > 4:
-                    if self.realpart > 3:
-                        part.type = 'logical'
-                        part.num = self.realpart + 1
-
-            logger.debug("Assigned %s to %s%d, sectors range %d-%d size %d "
-                         "sectors (%d bytes).", part.mountpoint, part.disk,
-                         part.num, part.start, self.offset - 1, part.size_sec,
-                         part.size_sec * self.sector_size)
-
-        # Once all the partitions have been layed out, we can calculate the
-        # minumim disk size
-        self.min_size = self.offset
-        if self.ptable_format == "gpt":
-            self.min_size += GPT_OVERHEAD
-
-        self.min_size *= self.sector_size
-
-    def _create_partition(self, device, parttype, fstype, start, size):
-        """ Create a partition on an image described by the 'device' object. """
-
-        # Start is included to the size so we need to substract one from the end.
-        end = start + size - 1
-        logger.debug("Added '%s' partition, sectors %d-%d, size %d sectors",
-                     parttype, start, end, size)
-
-        cmd = "parted -s %s unit s mkpart %s" % (device, parttype)
-        if fstype:
-            cmd += " %s" % fstype
-        cmd += " %d %d" % (start, end)
-
-        return exec_native_cmd(cmd, self.native_sysroot)
-
-    def create(self):
-        logger.debug("Creating sparse file %s", self.path)
-        with open(self.path, 'w') as sparse:
-            os.ftruncate(sparse.fileno(), self.min_size)
-
-        logger.debug("Initializing partition table for %s", self.path)
-        exec_native_cmd("parted -s %s mklabel %s" %
-                        (self.path, self.ptable_format), self.native_sysroot)
-
-        logger.debug("Set disk identifier %x", self.identifier)
-        with open(self.path, 'r+b') as img:
-            img.seek(0x1B8)
-            img.write(self.identifier.to_bytes(4, 'little'))
-
-        logger.debug("Creating partitions")
-
-        for part in self.partitions:
-            if part.num == 0:
-                continue
-
-            if self.ptable_format == "msdos" and part.num == 5:
-                # Create an extended partition (note: extended
-                # partition is described in MBR and contains all
-                # logical partitions). The logical partitions save a
-                # sector for an EBR just before the start of a
-                # partition. The extended partition must start one
-                # sector before the start of the first logical
-                # partition. This way the first EBR is inside of the
-                # extended partition. Since the extended partitions
-                # starts a sector before the first logical partition,
-                # add a sector at the back, so that there is enough
-                # room for all logical partitions.
-                self._create_partition(self.path, "extended",
-                                       None, part.start - 1,
-                                       self.offset - part.start + 1)
-
-            if part.fstype == "swap":
-                parted_fs_type = "linux-swap"
-            elif part.fstype == "vfat":
-                parted_fs_type = "fat32"
-            elif part.fstype == "msdos":
-                parted_fs_type = "fat16"
-                if not part.system_id:
-                    part.system_id = '0x6' # FAT16
-            else:
-                # Type for ext2/ext3/ext4/btrfs
-                parted_fs_type = "ext2"
-
-            # Boot ROM of OMAP boards require vfat boot partition to have an
-            # even number of sectors.
-            if part.mountpoint == "/boot" and part.fstype in ["vfat", "msdos"] \
-               and part.size_sec % 2:
-                logger.debug("Subtracting one sector from '%s' partition to "
-                             "get even number of sectors for the partition",
-                             part.mountpoint)
-                part.size_sec -= 1
-
-            self._create_partition(self.path, part.type,
-                                   parted_fs_type, part.start, part.size_sec)
-
-            if part.part_name:
-                logger.debug("partition %d: set name to %s",
-                             part.num, part.part_name)
-                exec_native_cmd("sgdisk --change-name=%d:%s %s" % \
-                                         (part.num, part.part_name,
-                                          self.path), self.native_sysroot)
-
-            if part.part_type:
-                logger.debug("partition %d: set type UID to %s",
-                             part.num, part.part_type)
-                exec_native_cmd("sgdisk --typecode=%d:%s %s" % \
-                                         (part.num, part.part_type,
-                                          self.path), self.native_sysroot)
-
-            if part.uuid and self.ptable_format == "gpt":
-                logger.debug("partition %d: set UUID to %s",
-                             part.num, part.uuid)
-                exec_native_cmd("sgdisk --partition-guid=%d:%s %s" % \
-                                (part.num, part.uuid, self.path),
-                                self.native_sysroot)
-
-            if part.label and self.ptable_format == "gpt":
-                logger.debug("partition %d: set name to %s",
-                             part.num, part.label)
-                exec_native_cmd("parted -s %s name %d %s" % \
-                                (self.path, part.num, part.label),
-                                self.native_sysroot)
-
-            if part.active:
-                flag_name = "legacy_boot" if self.ptable_format == 'gpt' else "boot"
-                logger.debug("Set '%s' flag for partition '%s' on disk '%s'",
-                             flag_name, part.num, self.path)
-                exec_native_cmd("parted -s %s set %d %s on" % \
-                                (self.path, part.num, flag_name),
-                                self.native_sysroot)
-            if part.system_id:
-                exec_native_cmd("sfdisk --part-type %s %s %s" % \
-                                (self.path, part.num, part.system_id),
-                                self.native_sysroot)
-
-    def cleanup(self):
-        # remove partition images
-        for image in set(self.partimages):
-            os.remove(image)
-
-    def assemble(self):
-        logger.debug("Installing partitions")
-
-        for part in self.partitions:
-            source = part.source_file
-            if source:
-                # install source_file contents into a partition
-                sparse_copy(source, self.path, seek=part.start * self.sector_size)
-
-                logger.debug("Installed %s in partition %d, sectors %d-%d, "
-                             "size %d sectors", source, part.num, part.start,
-                             part.start + part.size_sec - 1, part.size_sec)
-
-                partimage = self.path + '.p%d' % part.num
-                os.rename(source, partimage)
-                self.partimages.append(partimage)
diff --git a/import-layers/yocto-poky/scripts/lib/wic/plugins/source/bootimg-efi.py b/import-layers/yocto-poky/scripts/lib/wic/plugins/source/bootimg-efi.py
deleted file mode 100644
index beb74d7a7..000000000
--- a/import-layers/yocto-poky/scripts/lib/wic/plugins/source/bootimg-efi.py
+++ /dev/null
@@ -1,258 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-#
-# Copyright (c) 2014, Intel Corporation.
-# All rights reserved.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 2 as
-# published by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty 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.
-#
-# DESCRIPTION
-# This implements the 'bootimg-efi' source plugin class for 'wic'
-#
-# AUTHORS
-# Tom Zanussi <tom.zanussi (at] linux.intel.com>
-#
-
-import logging
-import os
-import shutil
-
-from wic import WicError
-from wic.engine import get_custom_config
-from wic.pluginbase import SourcePlugin
-from wic.misc import (exec_cmd, exec_native_cmd,
-                      get_bitbake_var, BOOTDD_EXTRA_SPACE)
-
-logger = logging.getLogger('wic')
-
-class BootimgEFIPlugin(SourcePlugin):
-    """
-    Create EFI boot partition.
-    This plugin supports GRUB 2 and systemd-boot bootloaders.
-    """
-
-    name = 'bootimg-efi'
-
-    @classmethod
-    def do_configure_grubefi(cls, creator, cr_workdir):
-        """
-        Create loader-specific (grub-efi) config
-        """
-        configfile = creator.ks.bootloader.configfile
-        custom_cfg = None
-        if configfile:
-            custom_cfg = get_custom_config(configfile)
-            if custom_cfg:
-                # Use a custom configuration for grub
-                grubefi_conf = custom_cfg
-                logger.debug("Using custom configuration file "
-                             "%s for grub.cfg", configfile)
-            else:
-                raise WicError("configfile is specified but failed to "
-                               "get it from %s." % configfile)
-
-        if not custom_cfg:
-            # Create grub configuration using parameters from wks file
-            bootloader = creator.ks.bootloader
-
-            grubefi_conf = ""
-            grubefi_conf += "serial --unit=0 --speed=115200 --word=8 --parity=no --stop=1\n"
-            grubefi_conf += "default=boot\n"
-            grubefi_conf += "timeout=%s\n" % bootloader.timeout
-            grubefi_conf += "menuentry 'boot'{\n"
-
-            kernel = "/bzImage"
-
-            grubefi_conf += "linux %s root=%s rootwait %s\n" \
-                % (kernel, creator.rootdev, bootloader.append)
-            grubefi_conf += "}\n"
-
-        logger.debug("Writing grubefi config %s/hdd/boot/EFI/BOOT/grub.cfg",
-                     cr_workdir)
-        cfg = open("%s/hdd/boot/EFI/BOOT/grub.cfg" % cr_workdir, "w")
-        cfg.write(grubefi_conf)
-        cfg.close()
-
-    @classmethod
-    def do_configure_systemdboot(cls, hdddir, creator, cr_workdir, source_params):
-        """
-        Create loader-specific systemd-boot/gummiboot config
-        """
-        install_cmd = "install -d %s/loader" % hdddir
-        exec_cmd(install_cmd)
-
-        install_cmd = "install -d %s/loader/entries" % hdddir
-        exec_cmd(install_cmd)
-
-        bootloader = creator.ks.bootloader
-
-        loader_conf = ""
-        loader_conf += "default boot\n"
-        loader_conf += "timeout %d\n" % bootloader.timeout
-
-        initrd = source_params.get('initrd')
-
-        if initrd:
-            # obviously we need to have a common common deploy var
-            bootimg_dir = get_bitbake_var("DEPLOY_DIR_IMAGE")
-            if not bootimg_dir:
-                raise WicError("Couldn't find DEPLOY_DIR_IMAGE, exiting")
-
-            cp_cmd = "cp %s/%s %s" % (bootimg_dir, initrd, hdddir)
-            exec_cmd(cp_cmd, True)
-        else:
-            logger.debug("Ignoring missing initrd")
-
-        logger.debug("Writing systemd-boot config "
-                     "%s/hdd/boot/loader/loader.conf", cr_workdir)
-        cfg = open("%s/hdd/boot/loader/loader.conf" % cr_workdir, "w")
-        cfg.write(loader_conf)
-        cfg.close()
-
-        configfile = creator.ks.bootloader.configfile
-        custom_cfg = None
-        if configfile:
-            custom_cfg = get_custom_config(configfile)
-            if custom_cfg:
-                # Use a custom configuration for systemd-boot
-                boot_conf = custom_cfg
-                logger.debug("Using custom configuration file "
-                             "%s for systemd-boots's boot.conf", configfile)
-            else:
-                raise WicError("configfile is specified but failed to "
-                               "get it from %s.", configfile)
-
-        if not custom_cfg:
-            # Create systemd-boot configuration using parameters from wks file
-            kernel = "/bzImage"
-
-            boot_conf = ""
-            boot_conf += "title boot\n"
-            boot_conf += "linux %s\n" % kernel
-            boot_conf += "options LABEL=Boot root=%s %s\n" % \
-                             (creator.rootdev, bootloader.append)
-
-            if initrd:
-                boot_conf += "initrd /%s\n" % initrd
-
-        logger.debug("Writing systemd-boot config "
-                     "%s/hdd/boot/loader/entries/boot.conf", cr_workdir)
-        cfg = open("%s/hdd/boot/loader/entries/boot.conf" % cr_workdir, "w")
-        cfg.write(boot_conf)
-        cfg.close()
-
-
-    @classmethod
-    def do_configure_partition(cls, part, source_params, creator, cr_workdir,
-                               oe_builddir, bootimg_dir, kernel_dir,
-                               native_sysroot):
-        """
-        Called before do_prepare_partition(), creates loader-specific config
-        """
-        hdddir = "%s/hdd/boot" % cr_workdir
-
-        install_cmd = "install -d %s/EFI/BOOT" % hdddir
-        exec_cmd(install_cmd)
-
-        try:
-            if source_params['loader'] == 'grub-efi':
-                cls.do_configure_grubefi(creator, cr_workdir)
-            elif source_params['loader'] == 'systemd-boot':
-                cls.do_configure_systemdboot(hdddir, creator, cr_workdir, source_params)
-            else:
-                raise WicError("unrecognized bootimg-efi loader: %s" % source_params['loader'])
-        except KeyError:
-            raise WicError("bootimg-efi requires a loader, none specified")
-
-
-    @classmethod
-    def do_prepare_partition(cls, part, source_params, creator, cr_workdir,
-                             oe_builddir, bootimg_dir, kernel_dir,
-                             rootfs_dir, native_sysroot):
-        """
-        Called to do the actual content population for a partition i.e. it
-        'prepares' the partition to be incorporated into the image.
-        In this case, prepare content for an EFI (grub) boot partition.
-        """
-        if not kernel_dir:
-            kernel_dir = get_bitbake_var("DEPLOY_DIR_IMAGE")
-            if not kernel_dir:
-                raise WicError("Couldn't find DEPLOY_DIR_IMAGE, exiting")
-
-        staging_kernel_dir = kernel_dir
-
-        hdddir = "%s/hdd/boot" % cr_workdir
-
-        install_cmd = "install -m 0644 %s/bzImage %s/bzImage" % \
-            (staging_kernel_dir, hdddir)
-        exec_cmd(install_cmd)
-
-
-        try:
-            if source_params['loader'] == 'grub-efi':
-                shutil.copyfile("%s/hdd/boot/EFI/BOOT/grub.cfg" % cr_workdir,
-                                "%s/grub.cfg" % cr_workdir)
-                for mod in [x for x in os.listdir(kernel_dir) if x.startswith("grub-efi-")]:
-                    cp_cmd = "cp %s/%s %s/EFI/BOOT/%s" % (kernel_dir, mod, hdddir, mod[9:])
-                    exec_cmd(cp_cmd, True)
-                shutil.move("%s/grub.cfg" % cr_workdir,
-                            "%s/hdd/boot/EFI/BOOT/grub.cfg" % cr_workdir)
-            elif source_params['loader'] == 'systemd-boot':
-                for mod in [x for x in os.listdir(kernel_dir) if x.startswith("systemd-")]:
-                    cp_cmd = "cp %s/%s %s/EFI/BOOT/%s" % (kernel_dir, mod, hdddir, mod[8:])
-                    exec_cmd(cp_cmd, True)
-            else:
-                raise WicError("unrecognized bootimg-efi loader: %s" %
-                               source_params['loader'])
-        except KeyError:
-            raise WicError("bootimg-efi requires a loader, none specified")
-
-        startup = os.path.join(kernel_dir, "startup.nsh")
-        if os.path.exists(startup):
-            cp_cmd = "cp %s %s/" % (startup, hdddir)
-            exec_cmd(cp_cmd, True)
-
-        du_cmd = "du -bks %s" % hdddir
-        out = exec_cmd(du_cmd)
-        blocks = int(out.split()[0])
-
-        extra_blocks = part.get_extra_block_count(blocks)
-
-        if extra_blocks < BOOTDD_EXTRA_SPACE:
-            extra_blocks = BOOTDD_EXTRA_SPACE
-
-        blocks += extra_blocks
-
-        logger.debug("Added %d extra blocks to %s to get to %d total blocks",
-                     extra_blocks, part.mountpoint, blocks)
-
-        # dosfs image, created by mkdosfs
-        bootimg = "%s/boot.img" % cr_workdir
-
-        dosfs_cmd = "mkdosfs -n efi -i %s -C %s %d" % \
-                    (part.fsuuid, bootimg, blocks)
-        exec_native_cmd(dosfs_cmd, native_sysroot)
-
-        mcopy_cmd = "mcopy -i %s -s %s/* ::/" % (bootimg, hdddir)
-        exec_native_cmd(mcopy_cmd, native_sysroot)
-
-        chmod_cmd = "chmod 644 %s" % bootimg
-        exec_cmd(chmod_cmd)
-
-        du_cmd = "du -Lbks %s" % bootimg
-        out = exec_cmd(du_cmd)
-        bootimg_size = out.split()[0]
-
-        part.size = int(bootimg_size)
-        part.source_file = bootimg
diff --git a/import-layers/yocto-poky/scripts/lib/wic/plugins/source/bootimg-partition.py b/import-layers/yocto-poky/scripts/lib/wic/plugins/source/bootimg-partition.py
deleted file mode 100644
index b239fc0b4..000000000
--- a/import-layers/yocto-poky/scripts/lib/wic/plugins/source/bootimg-partition.py
+++ /dev/null
@@ -1,132 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 2 as
-# published by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty 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.
-#
-# DESCRIPTION
-# This implements the 'bootimg-partition' source plugin class for
-# 'wic'. The plugin creates an image of boot partition, copying over
-# files listed in IMAGE_BOOT_FILES bitbake variable.
-#
-# AUTHORS
-# Maciej Borzecki <maciej.borzecki (at] open-rnd.pl>
-#
-
-import logging
-import os
-import re
-
-from glob import glob
-
-from wic import WicError
-from wic.pluginbase import SourcePlugin
-from wic.misc import exec_cmd, get_bitbake_var
-
-logger = logging.getLogger('wic')
-
-class BootimgPartitionPlugin(SourcePlugin):
-    """
-    Create an image of boot partition, copying over files
-    listed in IMAGE_BOOT_FILES bitbake variable.
-    """
-
-    name = 'bootimg-partition'
-
-    @classmethod
-    def do_prepare_partition(cls, part, source_params, cr, cr_workdir,
-                             oe_builddir, bootimg_dir, kernel_dir,
-                             rootfs_dir, native_sysroot):
-        """
-        Called to do the actual content population for a partition i.e. it
-        'prepares' the partition to be incorporated into the image.
-        In this case, does the following:
-        - sets up a vfat partition
-        - copies all files listed in IMAGE_BOOT_FILES variable
-        """
-        hdddir = "%s/boot.%d" % (cr_workdir, part.lineno)
-        install_cmd = "install -d %s" % hdddir
-        exec_cmd(install_cmd)
-
-        if not kernel_dir:
-            kernel_dir = get_bitbake_var("DEPLOY_DIR_IMAGE")
-            if not kernel_dir:
-                raise WicError("Couldn't find DEPLOY_DIR_IMAGE, exiting")
-
-        logger.debug('Kernel dir: %s', bootimg_dir)
-
-        boot_files = None
-        for (fmt, id) in (("_uuid-%s", part.uuid), ("_label-%s", part.label), (None, None)):
-            if fmt:
-                var = fmt % id
-            else:
-                var = ""
-
-            boot_files = get_bitbake_var("IMAGE_BOOT_FILES" + var)
-            if boot_files is not None:
-                break
-
-        if boot_files is None:
-            raise WicError('No boot files defined, IMAGE_BOOT_FILES unset for entry #%d' % part.lineno)
-
-        logger.debug('Boot files: %s', boot_files)
-
-        # list of tuples (src_name, dst_name)
-        deploy_files = []
-        for src_entry in re.findall(r'[\w;\-\./\*]+', boot_files):
-            if ';' in src_entry:
-                dst_entry = tuple(src_entry.split(';'))
-                if not dst_entry[0] or not dst_entry[1]:
-                    raise WicError('Malformed boot file entry: %s' % src_entry)
-            else:
-                dst_entry = (src_entry, src_entry)
-
-            logger.debug('Destination entry: %r', dst_entry)
-            deploy_files.append(dst_entry)
-
-        for deploy_entry in deploy_files:
-            src, dst = deploy_entry
-            install_task = []
-            if '*' in src:
-                # by default install files under their basename
-                entry_name_fn = os.path.basename
-                if dst != src:
-                    # unless a target name was given, then treat name
-                    # as a directory and append a basename
-                    entry_name_fn = lambda name: \
-                                    os.path.join(dst,
-                                                 os.path.basename(name))
-
-                srcs = glob(os.path.join(kernel_dir, src))
-
-                logger.debug('Globbed sources: %s', ', '.join(srcs))
-                for entry in srcs:
-                    entry_dst_name = entry_name_fn(entry)
-                    install_task.append((entry,
-                                         os.path.join(hdddir,
-                                                      entry_dst_name)))
-            else:
-                install_task = [(os.path.join(kernel_dir, src),
-                                 os.path.join(hdddir, dst))]
-
-            for task in install_task:
-                src_path, dst_path = task
-                logger.debug('Install %s as %s',
-                             os.path.basename(src_path), dst_path)
-                install_cmd = "install -m 0644 -D %s %s" \
-                              % (src_path, dst_path)
-                exec_cmd(install_cmd)
-
-        logger.debug('Prepare boot partition using rootfs in %s', hdddir)
-        part.prepare_rootfs(cr_workdir, oe_builddir, hdddir,
-                            native_sysroot, False)
diff --git a/import-layers/yocto-poky/scripts/lib/wic/plugins/source/bootimg-pcbios.py b/import-layers/yocto-poky/scripts/lib/wic/plugins/source/bootimg-pcbios.py
deleted file mode 100644
index d599112dd..000000000
--- a/import-layers/yocto-poky/scripts/lib/wic/plugins/source/bootimg-pcbios.py
+++ /dev/null
@@ -1,207 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-#
-# Copyright (c) 2014, Intel Corporation.
-# All rights reserved.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 2 as
-# published by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty 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.
-#
-# DESCRIPTION
-# This implements the 'bootimg-pcbios' source plugin class for 'wic'
-#
-# AUTHORS
-# Tom Zanussi <tom.zanussi (at] linux.intel.com>
-#
-
-import logging
-import os
-
-from wic import WicError
-from wic.engine import get_custom_config
-from wic.pluginbase import SourcePlugin
-from wic.misc import (exec_cmd, exec_native_cmd,
-                      get_bitbake_var, BOOTDD_EXTRA_SPACE)
-
-logger = logging.getLogger('wic')
-
-class BootimgPcbiosPlugin(SourcePlugin):
-    """
-    Create MBR boot partition and install syslinux on it.
-    """
-
-    name = 'bootimg-pcbios'
-
-    @classmethod
-    def _get_bootimg_dir(cls, bootimg_dir, dirname):
-        """
-        Check if dirname exists in default bootimg_dir or in STAGING_DIR.
-        """
-        for result in (bootimg_dir, get_bitbake_var("STAGING_DATADIR")):
-            if os.path.exists("%s/%s" % (result, dirname)):
-                return result
-
-        raise WicError("Couldn't find correct bootimg_dir, exiting")
-
-    @classmethod
-    def do_install_disk(cls, disk, disk_name, creator, workdir, oe_builddir,
-                        bootimg_dir, kernel_dir, native_sysroot):
-        """
-        Called after all partitions have been prepared and assembled into a
-        disk image.  In this case, we install the MBR.
-        """
-        bootimg_dir = cls._get_bootimg_dir(bootimg_dir, 'syslinux')
-        mbrfile = "%s/syslinux/" % bootimg_dir
-        if creator.ptable_format == 'msdos':
-            mbrfile += "mbr.bin"
-        elif creator.ptable_format == 'gpt':
-            mbrfile += "gptmbr.bin"
-        else:
-            raise WicError("Unsupported partition table: %s" %
-                           creator.ptable_format)
-
-        if not os.path.exists(mbrfile):
-            raise WicError("Couldn't find %s.  If using the -e option, do you "
-                           "have the right MACHINE set in local.conf?  If not, "
-                           "is the bootimg_dir path correct?" % mbrfile)
-
-        full_path = creator._full_path(workdir, disk_name, "direct")
-        logger.debug("Installing MBR on disk %s as %s with size %s bytes",
-                     disk_name, full_path, disk.min_size)
-
-        dd_cmd = "dd if=%s of=%s conv=notrunc" % (mbrfile, full_path)
-        exec_cmd(dd_cmd, native_sysroot)
-
-    @classmethod
-    def do_configure_partition(cls, part, source_params, creator, cr_workdir,
-                               oe_builddir, bootimg_dir, kernel_dir,
-                               native_sysroot):
-        """
-        Called before do_prepare_partition(), creates syslinux config
-        """
-        hdddir = "%s/hdd/boot" % cr_workdir
-
-        install_cmd = "install -d %s" % hdddir
-        exec_cmd(install_cmd)
-
-        bootloader = creator.ks.bootloader
-
-        custom_cfg = None
-        if bootloader.configfile:
-            custom_cfg = get_custom_config(bootloader.configfile)
-            if custom_cfg:
-                # Use a custom configuration for grub
-                syslinux_conf = custom_cfg
-                logger.debug("Using custom configuration file %s "
-                             "for syslinux.cfg", bootloader.configfile)
-            else:
-                raise WicError("configfile is specified but failed to "
-                               "get it from %s." % bootloader.configfile)
-
-        if not custom_cfg:
-            # Create syslinux configuration using parameters from wks file
-            splash = os.path.join(cr_workdir, "/hdd/boot/splash.jpg")
-            if os.path.exists(splash):
-                splashline = "menu background splash.jpg"
-            else:
-                splashline = ""
-
-            syslinux_conf = ""
-            syslinux_conf += "PROMPT 0\n"
-            syslinux_conf += "TIMEOUT " + str(bootloader.timeout) + "\n"
-            syslinux_conf += "\n"
-            syslinux_conf += "ALLOWOPTIONS 1\n"
-            syslinux_conf += "SERIAL 0 115200\n"
-            syslinux_conf += "\n"
-            if splashline:
-                syslinux_conf += "%s\n" % splashline
-            syslinux_conf += "DEFAULT boot\n"
-            syslinux_conf += "LABEL boot\n"
-
-            kernel = "/vmlinuz"
-            syslinux_conf += "KERNEL " + kernel + "\n"
-
-            syslinux_conf += "APPEND label=boot root=%s %s\n" % \
-                             (creator.rootdev, bootloader.append)
-
-        logger.debug("Writing syslinux config %s/hdd/boot/syslinux.cfg",
-                     cr_workdir)
-        cfg = open("%s/hdd/boot/syslinux.cfg" % cr_workdir, "w")
-        cfg.write(syslinux_conf)
-        cfg.close()
-
-    @classmethod
-    def do_prepare_partition(cls, part, source_params, creator, cr_workdir,
-                             oe_builddir, bootimg_dir, kernel_dir,
-                             rootfs_dir, native_sysroot):
-        """
-        Called to do the actual content population for a partition i.e. it
-        'prepares' the partition to be incorporated into the image.
-        In this case, prepare content for legacy bios boot partition.
-        """
-        bootimg_dir = cls._get_bootimg_dir(bootimg_dir, 'syslinux')
-
-        staging_kernel_dir = kernel_dir
-
-        hdddir = "%s/hdd/boot" % cr_workdir
-
-        cmds = ("install -m 0644 %s/bzImage %s/vmlinuz" %
-                (staging_kernel_dir, hdddir),
-                "install -m 444 %s/syslinux/ldlinux.sys %s/ldlinux.sys" %
-                (bootimg_dir, hdddir),
-                "install -m 0644 %s/syslinux/vesamenu.c32 %s/vesamenu.c32" %
-                (bootimg_dir, hdddir),
-                "install -m 444 %s/syslinux/libcom32.c32 %s/libcom32.c32" %
-                (bootimg_dir, hdddir),
-                "install -m 444 %s/syslinux/libutil.c32 %s/libutil.c32" %
-                (bootimg_dir, hdddir))
-
-        for install_cmd in cmds:
-            exec_cmd(install_cmd)
-
-        du_cmd = "du -bks %s" % hdddir
-        out = exec_cmd(du_cmd)
-        blocks = int(out.split()[0])
-
-        extra_blocks = part.get_extra_block_count(blocks)
-
-        if extra_blocks < BOOTDD_EXTRA_SPACE:
-            extra_blocks = BOOTDD_EXTRA_SPACE
-
-        blocks += extra_blocks
-
-        logger.debug("Added %d extra blocks to %s to get to %d total blocks",
-                     extra_blocks, part.mountpoint, blocks)
-
-        # dosfs image, created by mkdosfs
-        bootimg = "%s/boot%s.img" % (cr_workdir, part.lineno)
-
-        dosfs_cmd = "mkdosfs -n boot -i %s -S 512 -C %s %d" % \
-                    (part.fsuuid, bootimg, blocks)
-        exec_native_cmd(dosfs_cmd, native_sysroot)
-
-        mcopy_cmd = "mcopy -i %s -s %s/* ::/" % (bootimg, hdddir)
-        exec_native_cmd(mcopy_cmd, native_sysroot)
-
-        syslinux_cmd = "syslinux %s" % bootimg
-        exec_native_cmd(syslinux_cmd, native_sysroot)
-
-        chmod_cmd = "chmod 644 %s" % bootimg
-        exec_cmd(chmod_cmd)
-
-        du_cmd = "du -Lbks %s" % bootimg
-        out = exec_cmd(du_cmd)
-        bootimg_size = out.split()[0]
-
-        part.size = int(bootimg_size)
-        part.source_file = bootimg
diff --git a/import-layers/yocto-poky/scripts/lib/wic/plugins/source/isoimage-isohybrid.py b/import-layers/yocto-poky/scripts/lib/wic/plugins/source/isoimage-isohybrid.py
deleted file mode 100644
index d6bd3bff7..000000000
--- a/import-layers/yocto-poky/scripts/lib/wic/plugins/source/isoimage-isohybrid.py
+++ /dev/null
@@ -1,466 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 2 as
-# published by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty 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.
-#
-# DESCRIPTION
-# This implements the 'isoimage-isohybrid' source plugin class for 'wic'
-#
-# AUTHORS
-# Mihaly Varga <mihaly.varga (at] ni.com>
-
-import glob
-import logging
-import os
-import re
-import shutil
-
-from wic import WicError
-from wic.engine import get_custom_config
-from wic.pluginbase import SourcePlugin
-from wic.misc import exec_cmd, exec_native_cmd, get_bitbake_var
-
-logger = logging.getLogger('wic')
-
-class IsoImagePlugin(SourcePlugin):
-    """
-    Create a bootable ISO image
-
-    This plugin creates a hybrid, legacy and EFI bootable ISO image. The
-    generated image can be used on optical media as well as USB media.
-
-    Legacy boot uses syslinux and EFI boot uses grub or gummiboot (not
-    implemented yet) as bootloader. The plugin creates the directories required
-    by bootloaders and populates them by creating and configuring the
-    bootloader files.
-
-    Example kickstart file:
-    part /boot --source isoimage-isohybrid --sourceparams="loader=grub-efi, \\
-    image_name= IsoImage" --ondisk cd --label LIVECD --fstype=ext2
-    bootloader  --timeout=10  --append=" "
-
-    In --sourceparams "loader" specifies the bootloader used for booting in EFI
-    mode, while "image_name" specifies the name of the generated image. In the
-    example above, wic creates an ISO image named IsoImage-cd.direct (default
-    extension added by direct imeger plugin) and a file named IsoImage-cd.iso
-    """
-
-    name = 'isoimage-isohybrid'
-
-    @classmethod
-    def do_configure_syslinux(cls, creator, cr_workdir):
-        """
-        Create loader-specific (syslinux) config
-        """
-        splash = os.path.join(cr_workdir, "ISO/boot/splash.jpg")
-        if os.path.exists(splash):
-            splashline = "menu background splash.jpg"
-        else:
-            splashline = ""
-
-        bootloader = creator.ks.bootloader
-
-        syslinux_conf = ""
-        syslinux_conf += "PROMPT 0\n"
-        syslinux_conf += "TIMEOUT %s \n" % (bootloader.timeout or 10)
-        syslinux_conf += "\n"
-        syslinux_conf += "ALLOWOPTIONS 1\n"
-        syslinux_conf += "SERIAL 0 115200\n"
-        syslinux_conf += "\n"
-        if splashline:
-            syslinux_conf += "%s\n" % splashline
-        syslinux_conf += "DEFAULT boot\n"
-        syslinux_conf += "LABEL boot\n"
-
-        kernel = "/bzImage"
-        syslinux_conf += "KERNEL " + kernel + "\n"
-        syslinux_conf += "APPEND initrd=/initrd LABEL=boot %s\n" \
-                             % bootloader.append
-
-        logger.debug("Writing syslinux config %s/ISO/isolinux/isolinux.cfg",
-                     cr_workdir)
-
-        with open("%s/ISO/isolinux/isolinux.cfg" % cr_workdir, "w") as cfg:
-            cfg.write(syslinux_conf)
-
-    @classmethod
-    def do_configure_grubefi(cls, part, creator, target_dir):
-        """
-        Create loader-specific (grub-efi) config
-        """
-        configfile = creator.ks.bootloader.configfile
-        if configfile:
-            grubefi_conf = get_custom_config(configfile)
-            if grubefi_conf:
-                logger.debug("Using custom configuration file %s for grub.cfg",
-                             configfile)
-            else:
-                raise WicError("configfile is specified "
-                               "but failed to get it from %s", configfile)
-        else:
-            splash = os.path.join(target_dir, "splash.jpg")
-            if os.path.exists(splash):
-                splashline = "menu background splash.jpg"
-            else:
-                splashline = ""
-
-            bootloader = creator.ks.bootloader
-
-            grubefi_conf = ""
-            grubefi_conf += "serial --unit=0 --speed=115200 --word=8 "
-            grubefi_conf += "--parity=no --stop=1\n"
-            grubefi_conf += "default=boot\n"
-            grubefi_conf += "timeout=%s\n" % (bootloader.timeout or 10)
-            grubefi_conf += "\n"
-            grubefi_conf += "search --set=root --label %s " % part.label
-            grubefi_conf += "\n"
-            grubefi_conf += "menuentry 'boot'{\n"
-
-            kernel = "/bzImage"
-
-            grubefi_conf += "linux %s rootwait %s\n" \
-                            % (kernel, bootloader.append)
-            grubefi_conf += "initrd /initrd \n"
-            grubefi_conf += "}\n"
-
-            if splashline:
-                grubefi_conf += "%s\n" % splashline
-
-        cfg_path = os.path.join(target_dir, "grub.cfg")
-        logger.debug("Writing grubefi config %s", cfg_path)
-
-        with open(cfg_path, "w") as cfg:
-            cfg.write(grubefi_conf)
-
-    @staticmethod
-    def _build_initramfs_path(rootfs_dir, cr_workdir):
-        """
-        Create path for initramfs image
-        """
-
-        initrd = get_bitbake_var("INITRD_LIVE") or get_bitbake_var("INITRD")
-        if not initrd:
-            initrd_dir = get_bitbake_var("DEPLOY_DIR_IMAGE")
-            if not initrd_dir:
-                raise WicError("Couldn't find DEPLOY_DIR_IMAGE, exiting.")
-
-            image_name = get_bitbake_var("IMAGE_BASENAME")
-            if not image_name:
-                raise WicError("Couldn't find IMAGE_BASENAME, exiting.")
-
-            image_type = get_bitbake_var("INITRAMFS_FSTYPES")
-            if not image_type:
-                raise WicError("Couldn't find INITRAMFS_FSTYPES, exiting.")
-
-            machine = os.path.basename(initrd_dir)
-
-            pattern = '%s/%s*%s.%s' % (initrd_dir, image_name, machine, image_type)
-            files = glob.glob(pattern)
-            if files:
-                initrd = files[0]
-
-        if not initrd or not os.path.exists(initrd):
-            # Create initrd from rootfs directory
-            initrd = "%s/initrd.cpio.gz" % cr_workdir
-            initrd_dir = "%s/INITRD" % cr_workdir
-            shutil.copytree("%s" % rootfs_dir, \
-                            "%s" % initrd_dir, symlinks=True)
-
-            if os.path.isfile("%s/init" % rootfs_dir):
-                shutil.copy2("%s/init" % rootfs_dir, "%s/init" % initrd_dir)
-            elif os.path.lexists("%s/init" % rootfs_dir):
-                os.symlink(os.readlink("%s/init" % rootfs_dir), \
-                            "%s/init" % initrd_dir)
-            elif os.path.isfile("%s/sbin/init" % rootfs_dir):
-                shutil.copy2("%s/sbin/init" % rootfs_dir, \
-                            "%s" % initrd_dir)
-            elif os.path.lexists("%s/sbin/init" % rootfs_dir):
-                os.symlink(os.readlink("%s/sbin/init" % rootfs_dir), \
-                            "%s/init" % initrd_dir)
-            else:
-                raise WicError("Couldn't find or build initrd, exiting.")
-
-            exec_cmd("cd %s && find . | cpio -o -H newc -R +0:+0 >./initrd.cpio " \
-                    % initrd_dir, as_shell=True)
-            exec_cmd("gzip -f -9 -c %s/initrd.cpio > %s" \
-                    % (cr_workdir, initrd), as_shell=True)
-            shutil.rmtree(initrd_dir)
-
-        return initrd
-
-    @classmethod
-    def do_configure_partition(cls, part, source_params, creator, cr_workdir,
-                               oe_builddir, bootimg_dir, kernel_dir,
-                               native_sysroot):
-        """
-        Called before do_prepare_partition(), creates loader-specific config
-        """
-        isodir = "%s/ISO/" % cr_workdir
-
-        if os.path.exists(isodir):
-            shutil.rmtree(isodir)
-
-        install_cmd = "install -d %s " % isodir
-        exec_cmd(install_cmd)
-
-        # Overwrite the name of the created image
-        logger.debug(source_params)
-        if 'image_name' in source_params and \
-                    source_params['image_name'].strip():
-            creator.name = source_params['image_name'].strip()
-            logger.debug("The name of the image is: %s", creator.name)
-
-    @classmethod
-    def do_prepare_partition(cls, part, source_params, creator, cr_workdir,
-                             oe_builddir, bootimg_dir, kernel_dir,
-                             rootfs_dir, native_sysroot):
-        """
-        Called to do the actual content population for a partition i.e. it
-        'prepares' the partition to be incorporated into the image.
-        In this case, prepare content for a bootable ISO image.
-        """
-
-        isodir = "%s/ISO" % cr_workdir
-
-        if part.rootfs_dir is None:
-            if not 'ROOTFS_DIR' in rootfs_dir:
-                raise WicError("Couldn't find --rootfs-dir, exiting.")
-            rootfs_dir = rootfs_dir['ROOTFS_DIR']
-        else:
-            if part.rootfs_dir in rootfs_dir:
-                rootfs_dir = rootfs_dir[part.rootfs_dir]
-            elif part.rootfs_dir:
-                rootfs_dir = part.rootfs_dir
-            else:
-                raise WicError("Couldn't find --rootfs-dir=%s connection "
-                               "or it is not a valid path, exiting." %
-                               part.rootfs_dir)
-
-        if not os.path.isdir(rootfs_dir):
-            rootfs_dir = get_bitbake_var("IMAGE_ROOTFS")
-        if not os.path.isdir(rootfs_dir):
-            raise WicError("Couldn't find IMAGE_ROOTFS, exiting.")
-
-        part.rootfs_dir = rootfs_dir
-
-        # Prepare rootfs.img
-        deploy_dir = get_bitbake_var("DEPLOY_DIR_IMAGE")
-        img_iso_dir = get_bitbake_var("ISODIR")
-        rootfs_img = "%s/rootfs.img" % img_iso_dir
-        if not os.path.isfile(rootfs_img):
-            # check if rootfs.img is in deploydir
-            deploy_dir = get_bitbake_var("DEPLOY_DIR_IMAGE")
-            image_name = get_bitbake_var("IMAGE_LINK_NAME")
-            rootfs_img = "%s/%s.%s" \
-                % (deploy_dir, image_name, part.fstype)
-
-        if not os.path.isfile(rootfs_img):
-            # create image file with type specified by --fstype
-            # which contains rootfs
-            du_cmd = "du -bks %s" % rootfs_dir
-            out = exec_cmd(du_cmd)
-            part.size = int(out.split()[0])
-            part.extra_space = 0
-            part.overhead_factor = 1.2
-            part.prepare_rootfs(cr_workdir, oe_builddir, rootfs_dir, \
-                                native_sysroot)
-            rootfs_img = part.source_file
-
-        install_cmd = "install -m 0644 %s %s/rootfs.img" \
-            % (rootfs_img, isodir)
-        exec_cmd(install_cmd)
-
-        # Remove the temporary file created by part.prepare_rootfs()
-        if os.path.isfile(part.source_file):
-            os.remove(part.source_file)
-
-        # Support using a different initrd other than default
-        if source_params.get('initrd'):
-            initrd = source_params['initrd']
-            if not deploy_dir:
-                raise WicError("Couldn't find DEPLOY_DIR_IMAGE, exiting")
-            cp_cmd = "cp %s/%s %s" % (deploy_dir, initrd, cr_workdir)
-            exec_cmd(cp_cmd)
-        else:
-            # Prepare initial ramdisk
-            initrd = "%s/initrd" % deploy_dir
-            if not os.path.isfile(initrd):
-                initrd = "%s/initrd" % img_iso_dir
-            if not os.path.isfile(initrd):
-                initrd = cls._build_initramfs_path(rootfs_dir, cr_workdir)
-
-        install_cmd = "install -m 0644 %s %s/initrd" % (initrd, isodir)
-        exec_cmd(install_cmd)
-
-        # Remove the temporary file created by _build_initramfs_path function
-        if os.path.isfile("%s/initrd.cpio.gz" % cr_workdir):
-            os.remove("%s/initrd.cpio.gz" % cr_workdir)
-
-        # Install bzImage
-        install_cmd = "install -m 0644 %s/bzImage %s/bzImage" % \
-                      (kernel_dir, isodir)
-        exec_cmd(install_cmd)
-
-        #Create bootloader for efi boot
-        try:
-            target_dir = "%s/EFI/BOOT" % isodir
-            if os.path.exists(target_dir):
-                shutil.rmtree(target_dir)
-
-            os.makedirs(target_dir)
-
-            if source_params['loader'] == 'grub-efi':
-                # Builds bootx64.efi/bootia32.efi if ISODIR didn't exist or
-                # didn't contains it
-                target_arch = get_bitbake_var("TARGET_SYS")
-                if not target_arch:
-                    raise WicError("Coludn't find target architecture")
-
-                if re.match("x86_64", target_arch):
-                    grub_image = "grub-efi-bootx64.efi"
-                elif re.match('i.86', target_arch):
-                    grub_image = "grub-efi-bootia32.efi"
-                else:
-                    raise WicError("grub-efi is incompatible with target %s" %
-                                   target_arch)
-
-                grub_target = os.path.join(target_dir, grub_image)
-                if not os.path.isfile(grub_target):
-                    grub_src = os.path.join(deploy_dir, grub_image)
-                    if not os.path.exists(grub_src):
-                        raise WicError("Grub loader %s is not found in %s. "
-                                       "Please build grub-efi first" % (grub_image, deploy_dir))
-                    shutil.copy(grub_src, grub_target)
-
-                if not os.path.isfile(os.path.join(target_dir, "boot.cfg")):
-                    cls.do_configure_grubefi(part, creator, target_dir)
-
-            else:
-                raise WicError("unrecognized bootimg-efi loader: %s" %
-                               source_params['loader'])
-        except KeyError:
-            raise WicError("bootimg-efi requires a loader, none specified")
-
-        # Create efi.img that contains bootloader files for EFI booting
-        # if ISODIR didn't exist or didn't contains it
-        if os.path.isfile("%s/efi.img" % img_iso_dir):
-            install_cmd = "install -m 0644 %s/efi.img %s/efi.img" % \
-                (img_iso_dir, isodir)
-            exec_cmd(install_cmd)
-        else:
-            du_cmd = "du -bks %s/EFI" % isodir
-            out = exec_cmd(du_cmd)
-            blocks = int(out.split()[0])
-            # Add some extra space for file system overhead
-            blocks += 100
-            logger.debug("Added 100 extra blocks to %s to get to %d "
-                         "total blocks", part.mountpoint, blocks)
-
-            # dosfs image for EFI boot
-            bootimg = "%s/efi.img" % isodir
-
-            dosfs_cmd = 'mkfs.vfat -n "EFIimg" -S 512 -C %s %d' \
-                        % (bootimg, blocks)
-            exec_native_cmd(dosfs_cmd, native_sysroot)
-
-            mmd_cmd = "mmd -i %s ::/EFI" % bootimg
-            exec_native_cmd(mmd_cmd, native_sysroot)
-
-            mcopy_cmd = "mcopy -i %s -s %s/EFI/* ::/EFI/" \
-                        % (bootimg, isodir)
-            exec_native_cmd(mcopy_cmd, native_sysroot)
-
-            chmod_cmd = "chmod 644 %s" % bootimg
-            exec_cmd(chmod_cmd)
-
-        # Prepare files for legacy boot
-        syslinux_dir = get_bitbake_var("STAGING_DATADIR")
-        if not syslinux_dir:
-            raise WicError("Couldn't find STAGING_DATADIR, exiting.")
-
-        if os.path.exists("%s/isolinux" % isodir):
-            shutil.rmtree("%s/isolinux" % isodir)
-
-        install_cmd = "install -d %s/isolinux" % isodir
-        exec_cmd(install_cmd)
-
-        cls.do_configure_syslinux(creator, cr_workdir)
-
-        install_cmd = "install -m 444 %s/syslinux/ldlinux.sys " % syslinux_dir
-        install_cmd += "%s/isolinux/ldlinux.sys" % isodir
-        exec_cmd(install_cmd)
-
-        install_cmd = "install -m 444 %s/syslinux/isohdpfx.bin " % syslinux_dir
-        install_cmd += "%s/isolinux/isohdpfx.bin" % isodir
-        exec_cmd(install_cmd)
-
-        install_cmd = "install -m 644 %s/syslinux/isolinux.bin " % syslinux_dir
-        install_cmd += "%s/isolinux/isolinux.bin" % isodir
-        exec_cmd(install_cmd)
-
-        install_cmd = "install -m 644 %s/syslinux/ldlinux.c32 " % syslinux_dir
-        install_cmd += "%s/isolinux/ldlinux.c32" % isodir
-        exec_cmd(install_cmd)
-
-        #create ISO image
-        iso_img = "%s/tempiso_img.iso" % cr_workdir
-        iso_bootimg = "isolinux/isolinux.bin"
-        iso_bootcat = "isolinux/boot.cat"
-        efi_img = "efi.img"
-
-        mkisofs_cmd = "mkisofs -V %s " % part.label
-        mkisofs_cmd += "-o %s -U " % iso_img
-        mkisofs_cmd += "-J -joliet-long -r -iso-level 2 -b %s " % iso_bootimg
-        mkisofs_cmd += "-c %s -no-emul-boot -boot-load-size 4 " % iso_bootcat
-        mkisofs_cmd += "-boot-info-table -eltorito-alt-boot "
-        mkisofs_cmd += "-eltorito-platform 0xEF -eltorito-boot %s " % efi_img
-        mkisofs_cmd += "-no-emul-boot %s " % isodir
-
-        logger.debug("running command: %s", mkisofs_cmd)
-        exec_native_cmd(mkisofs_cmd, native_sysroot)
-
-        shutil.rmtree(isodir)
-
-        du_cmd = "du -Lbks %s" % iso_img
-        out = exec_cmd(du_cmd)
-        isoimg_size = int(out.split()[0])
-
-        part.size = isoimg_size
-        part.source_file = iso_img
-
-    @classmethod
-    def do_install_disk(cls, disk, disk_name, creator, workdir, oe_builddir,
-                        bootimg_dir, kernel_dir, native_sysroot):
-        """
-        Called after all partitions have been prepared and assembled into a
-        disk image.  In this case, we insert/modify the MBR using isohybrid
-        utility for booting via BIOS from disk storage devices.
-        """
-
-        iso_img = "%s.p1" % disk.path
-        full_path = creator._full_path(workdir, disk_name, "direct")
-        full_path_iso = creator._full_path(workdir, disk_name, "iso")
-
-        isohybrid_cmd = "isohybrid -u %s" % iso_img
-        logger.debug("running command: %s", isohybrid_cmd)
-        exec_native_cmd(isohybrid_cmd, native_sysroot)
-
-        # Replace the image created by direct plugin with the one created by
-        # mkisofs command. This is necessary because the iso image created by
-        # mkisofs has a very specific MBR is system area of the ISO image, and
-        # direct plugin adds and configures an another MBR.
-        logger.debug("Replaceing the image created by direct plugin\n")
-        os.remove(disk.path)
-        shutil.copy2(iso_img, full_path_iso)
-        shutil.copy2(full_path_iso, full_path)
diff --git a/import-layers/yocto-poky/scripts/lib/wic/plugins/source/rawcopy.py b/import-layers/yocto-poky/scripts/lib/wic/plugins/source/rawcopy.py
deleted file mode 100644
index e86398ac8..000000000
--- a/import-layers/yocto-poky/scripts/lib/wic/plugins/source/rawcopy.py
+++ /dev/null
@@ -1,91 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 2 as
-# published by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty 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.
-#
-
-import logging
-import os
-
-from wic import WicError
-from wic.pluginbase import SourcePlugin
-from wic.misc import exec_cmd, get_bitbake_var
-from wic.filemap import sparse_copy
-
-logger = logging.getLogger('wic')
-
-class RawCopyPlugin(SourcePlugin):
-    """
-    Populate partition content from raw image file.
-    """
-
-    name = 'rawcopy'
-
-    @staticmethod
-    def do_image_label(fstype, dst, label):
-        if fstype.startswith('ext'):
-            cmd = 'tune2fs -L %s %s' % (label, dst)
-        elif fstype in ('msdos', 'vfat'):
-            cmd = 'dosfslabel %s %s' % (dst, label)
-        elif fstype == 'btrfs':
-            cmd = 'btrfs filesystem label %s %s' % (dst, label)
-        elif fstype == 'swap':
-            cmd = 'mkswap -L %s %s' % (label, dst)
-        elif fstype == 'squashfs':
-            raise WicError("It's not possible to update a squashfs "
-                           "filesystem label '%s'" % (label))
-        else:
-            raise WicError("Cannot update filesystem label: "
-                           "Unknown fstype: '%s'" % (fstype))
-
-        exec_cmd(cmd)
-
-    @classmethod
-    def do_prepare_partition(cls, part, source_params, cr, cr_workdir,
-                             oe_builddir, bootimg_dir, kernel_dir,
-                             rootfs_dir, native_sysroot):
-        """
-        Called to do the actual content population for a partition i.e. it
-        'prepares' the partition to be incorporated into the image.
-        """
-        if not kernel_dir:
-            kernel_dir = get_bitbake_var("DEPLOY_DIR_IMAGE")
-            if not kernel_dir:
-                raise WicError("Couldn't find DEPLOY_DIR_IMAGE, exiting")
-
-        logger.debug('Kernel dir: %s', kernel_dir)
-
-        if 'file' not in source_params:
-            raise WicError("No file specified")
-
-        src = os.path.join(kernel_dir, source_params['file'])
-        dst = os.path.join(cr_workdir, "%s.%s" % (source_params['file'], part.lineno))
-
-        if 'skip' in source_params:
-            sparse_copy(src, dst, skip=int(source_params['skip']))
-        else:
-            sparse_copy(src, dst)
-
-        # get the size in the right units for kickstart (kB)
-        du_cmd = "du -Lbks %s" % dst
-        out = exec_cmd(du_cmd)
-        filesize = int(out.split()[0])
-
-        if filesize > part.size:
-            part.size = filesize
-
-        if part.label:
-            RawCopyPlugin.do_image_label(part.fstype, dst, part.label)
-
-        part.source_file = dst
diff --git a/import-layers/yocto-poky/scripts/lib/wic/plugins/source/rootfs.py b/import-layers/yocto-poky/scripts/lib/wic/plugins/source/rootfs.py
deleted file mode 100644
index aec720fb2..000000000
--- a/import-layers/yocto-poky/scripts/lib/wic/plugins/source/rootfs.py
+++ /dev/null
@@ -1,126 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-#
-# Copyright (c) 2014, Intel Corporation.
-# All rights reserved.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 2 as
-# published by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty 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.
-#
-# DESCRIPTION
-# This implements the 'rootfs' source plugin class for 'wic'
-#
-# AUTHORS
-# Tom Zanussi <tom.zanussi (at] linux.intel.com>
-# Joao Henrique Ferreira de Freitas <joaohf (at] gmail.com>
-#
-
-import logging
-import os
-import shutil
-import sys
-
-from oe.path import copyhardlinktree
-
-from wic import WicError
-from wic.pluginbase import SourcePlugin
-from wic.misc import get_bitbake_var
-
-logger = logging.getLogger('wic')
-
-class RootfsPlugin(SourcePlugin):
-    """
-    Populate partition content from a rootfs directory.
-    """
-
-    name = 'rootfs'
-
-    @staticmethod
-    def __get_rootfs_dir(rootfs_dir):
-        if os.path.isdir(rootfs_dir):
-            return os.path.realpath(rootfs_dir)
-
-        image_rootfs_dir = get_bitbake_var("IMAGE_ROOTFS", rootfs_dir)
-        if not os.path.isdir(image_rootfs_dir):
-            raise WicError("No valid artifact IMAGE_ROOTFS from image "
-                           "named %s has been found at %s, exiting." %
-                           (rootfs_dir, image_rootfs_dir))
-
-        return os.path.realpath(image_rootfs_dir)
-
-    @classmethod
-    def do_prepare_partition(cls, part, source_params, cr, cr_workdir,
-                             oe_builddir, bootimg_dir, kernel_dir,
-                             krootfs_dir, native_sysroot):
-        """
-        Called to do the actual content population for a partition i.e. it
-        'prepares' the partition to be incorporated into the image.
-        In this case, prepare content for legacy bios boot partition.
-        """
-        if part.rootfs_dir is None:
-            if not 'ROOTFS_DIR' in krootfs_dir:
-                raise WicError("Couldn't find --rootfs-dir, exiting")
-
-            rootfs_dir = krootfs_dir['ROOTFS_DIR']
-        else:
-            if part.rootfs_dir in krootfs_dir:
-                rootfs_dir = krootfs_dir[part.rootfs_dir]
-            elif part.rootfs_dir:
-                rootfs_dir = part.rootfs_dir
-            else:
-                raise WicError("Couldn't find --rootfs-dir=%s connection or "
-                               "it is not a valid path, exiting" % part.rootfs_dir)
-
-        part.rootfs_dir = cls.__get_rootfs_dir(rootfs_dir)
-
-        new_rootfs = None
-        # Handle excluded paths.
-        if part.exclude_path is not None:
-            # We need a new rootfs directory we can delete files from. Copy to
-            # workdir.
-            new_rootfs = os.path.realpath(os.path.join(cr_workdir, "rootfs%d" % part.lineno))
-
-            if os.path.lexists(new_rootfs):
-                shutil.rmtree(os.path.join(new_rootfs))
-
-            copyhardlinktree(part.rootfs_dir, new_rootfs)
-
-            for orig_path in part.exclude_path:
-                path = orig_path
-                if os.path.isabs(path):
-                    logger.error("Must be relative: --exclude-path=%s" % orig_path)
-                    sys.exit(1)
-
-                full_path = os.path.realpath(os.path.join(new_rootfs, path))
-
-                # Disallow climbing outside of parent directory using '..',
-                # because doing so could be quite disastrous (we will delete the
-                # directory).
-                if not full_path.startswith(new_rootfs):
-                    logger.error("'%s' points to a path outside the rootfs" % orig_path)
-                    sys.exit(1)
-
-                if path.endswith(os.sep):
-                    # Delete content only.
-                    for entry in os.listdir(full_path):
-                        full_entry = os.path.join(full_path, entry)
-                        if os.path.isdir(full_entry) and not os.path.islink(full_entry):
-                            shutil.rmtree(full_entry)
-                        else:
-                            os.remove(full_entry)
-                else:
-                    # Delete whole directory.
-                    shutil.rmtree(full_path)
-
-        part.prepare_rootfs(cr_workdir, oe_builddir,
-                            new_rootfs or part.rootfs_dir, native_sysroot)