docs: def bootstrap(
          platform,
          root,
          img_format='dir',
          fs_format='ext2',
          fs_opts=None,
          arch=None,
          flavor=None,
          repo_url=None,
          static_qemu=None,
          img_size=None,
          mount_dir=None,
          pkg_cache=None,
          pkgs=None,
          exclude_pkgs=None,
          epel_url=EPEL_URL,
      ):
      '''
      Create an image for a specific platform.
  
      Please note that this function *MUST* be run as root, as images that are
      created make files belonging to root.
  
      platform
          Which platform to use to create the image. Currently supported platforms
          are rpm, deb and pacman.
  
      root
          Local path to create the root of the image filesystem.
  
      img_format
          Which format to create the image in. By default, just copies files into
          a directory on the local filesystem (``dir``). Future support will exist
          for ``sparse``.
  
      fs_format
          When using a non-``dir`` ``img_format``, which filesystem to format the
          image to. By default, ``ext2``.
  
      fs_opts
          When using a non-``dir`` ``img_format``, a dict of opts may be
          specified.
  
      arch
          Architecture to install packages for, if supported by the underlying
          bootstrap tool. Currently only used for deb.
  
      flavor
          Which flavor of operating system to install. This correlates to a
          specific directory on the distribution repositories. For instance,
          ``wheezy`` on Debian.
  
      repo_url
          Mainly important for Debian-based repos. Base URL for the mirror to
          install from. (e.x.: http://ftp.debian.org/debian/)
  
      static_qemu
          Local path to the static qemu binary required for this arch.
          (e.x.: /usr/bin/qemu-amd64-static)
  
      pkg_confs
          The location of the conf files to copy into the image, to point the
          installer to the right repos and configuration.
  
      img_size
          If img_format is not ``dir``, then the size of the image must be
          specified.
  
      mount_dir
          If img_format is not ``dir``, then the image must be mounted somewhere.
          If the ``mount_dir`` is not specified, then it will be created at
          ``/opt/salt-genesis.<random_uuid>``. This directory will be unmounted
          and removed when the process is finished.
  
      pkg_cache
          This points to a directory containing a cache of package files to be
          copied to the image. It does not need to be specified.
  
      pkgs
          A list of packages to be installed on this image. For RedHat, this
          will include ``yum``, ``centos-release`` and ``iputils`` by default.
  
      exclude_pkgs
          A list of packages to be excluded. If you do not want to install the
          defaults, you need to include them in this list.
  
      epel_url
          The URL to download the EPEL release package from.
  
      CLI Examples:
  
      .. code-block:: bash
  
          salt myminion genesis.bootstrap pacman /root/arch
          salt myminion genesis.bootstrap rpm /root/redhat
          salt myminion genesis.bootstrap deb /root/wheezy arch=amd64 \
              flavor=wheezy static_qemu=/usr/bin/qemu-x86_64-static
  
      '''
      if img_format not in ('dir', 'sparse'):
          raise SaltInvocationError('The img_format must be "sparse" or "dir"')
  
      if img_format == 'dir':
          # We can just use the root as the root
          if not __salt__['file.directory_exists'](root):
              try:
                  __salt__['file.mkdir'](root)
              except Exception as exc:
                  return {'Error': salt.utils.stringutils.to_unicode(pprint.pformat(exc))}
      elif img_format == 'sparse':
          if not img_size:
              raise SaltInvocationError('An img_size must be specified for a sparse file')
          if not mount_dir:
              mount_dir = '/opt/salt-genesis.{0}'.format(uuid.uuid4())
          __salt__['file.mkdir'](mount_dir, 'root', 'root', '755')
          __salt__['cmd.run'](('fallocate', '-l', img_size, root), python_shell=False)
          _mkpart(root, fs_format, fs_opts, mount_dir)
  
          loop1 = __salt__['cmd.run']('losetup -f')
          log.debug('First loop device is %s', loop1)
          __salt__['cmd.run']('losetup {0} {1}'.format(loop1, root))
          loop2 = __salt__['cmd.run']('losetup -f')
          log.debug('Second loop device is %s', loop2)
          start = six.text_type(2048 * 2048)
          __salt__['cmd.run']('losetup -o {0} {1} {2}'.format(start, loop2, loop1))
          __salt__['mount.mount'](mount_dir, loop2)
  
          _populate_cache(platform, pkg_cache, mount_dir)
  
      if mount_dir:
          root = mount_dir
  
      if pkgs is None:
          pkgs = []
  
      if exclude_pkgs is None:
          exclude_pkgs = []
  
      if platform in ('rpm', 'yum'):
          _bootstrap_yum(
              root,
              pkgs=pkgs,
              exclude_pkgs=exclude_pkgs,
              epel_url=epel_url,
          )
      elif platform == 'deb':
          _bootstrap_deb(
              root,
              arch=arch,
              flavor=flavor,
              repo_url=repo_url,
              static_qemu=static_qemu,
              pkgs=pkgs,
              exclude_pkgs=exclude_pkgs,
          )
      elif platform == 'pacman':
          _bootstrap_pacman(
              root,
              img_format=img_format,
              pkgs=pkgs,
              exclude_pkgs=exclude_pkgs,
          )
  
      if img_format != 'dir':
          blkinfo = __salt__['disk.blkid'](loop2)
          __salt__['file.replace'](
              '{0}/boot/grub/grub.cfg'.format(mount_dir),
              'ad4103fa-d940-47ca-8506-301d8071d467',  # This seems to be the default
              blkinfo[loop2]['UUID']
          )
          __salt__['mount.umount'](root)
          __salt__['cmd.run']('losetup -d {0}'.format(loop2))
          __salt__['cmd.run']('losetup -d {0}'.format(loop1))
          __salt__['file.rmdir'](mount_dir)