def _stage_final_image(self):
if self.taring_to:
import tarfile
curdir = os.getcwd()
os.chdir(self.__imgdir)
self._resparse(0)
tarfile_name = self.taring_to
if not tarfile_name.endswith('.tar'):
tarfile_name += ".tar"
msger.info("Tar all loop images together to %s" % tarfile_name)
tar = tarfile.open(os.path.join(self._outdir, tarfile_name), 'w')
for item in self._instloops:
if item['fstype'] == "ext4":
runner.show('/sbin/tune2fs -O ^huge_file,extents,uninit_bg ' + item['name'])
tar.add(item['name'])
tar.close()
os.chdir(curdir)
else:
self._resparse()
for item in self._instloops:
shutil.move(os.path.join(self.__imgdir, item['name']), os.path.join(self._outdir, item['name']))
def package(self, destdir = "."):
"""Prepares the created image for final delivery.
In its simplest form, this method merely copies the install root to the
supplied destination directory; other subclasses may choose to package
the image by e.g. creating a bootable ISO containing the image and
bootloader configuration.
destdir -- the directory into which the final image should be moved;
this defaults to the current directory.
"""
self._stage_final_image()
if not os.path.exists(destdir):
fs.makedirs(destdir)
if self._img_compression_method:
if not self._img_name:
raise CreatorError("Image name not set.")
rc = None
img_location = os.path.join(self._outdir,self._img_name)
if self._img_compression_method == "bz2":
bzip2 = fs.find_binary_path('bzip2')
msger.info("Compressing %s with bzip2. Please wait..." \
% img_location)
rc = runner.show([bzip2, "-f", img_location])
if rc:
raise CreatorError("Failed to compress image %s with %s." \
% (img_location, self._img_compression_method))
for bootimg in glob.glob(os.path.dirname(img_location) + \
"/*-boot.bin"):
msger.info("Compressing %s with bzip2. Please wait..." \
% bootimg)
rc = runner.show([bzip2, "-f", bootimg])
if rc:
raise CreatorError("Failed to compress image %s with "
"%s." \
% (bootimg,
self._img_compression_method))
if self._recording_pkgs:
self._save_recording_pkgs(destdir)
# For image formats with two or multiple image files, it will be
# better to put them under a directory
if self.image_format in ("raw", "vmdk", "vdi", "nand", "mrstnand"):
destdir = os.path.join(destdir, "%s-%s" \
% (self.name, self.image_format))
msger.debug("creating destination dir: %s" % destdir)
fs.makedirs(destdir)
# Ensure all data is flushed to _outdir
runner.quiet('sync')
for f in os.listdir(self._outdir):
shutil.move(os.path.join(self._outdir, f),
os.path.join(destdir, f))
self.outimage.append(os.path.join(destdir, f))
self.do_genchecksum(os.path.join(destdir, f))
def __create_iso(self, isodir):
iso = self._outdir + "/" + self.name + ".iso"
genisoimage = fs_related.find_binary_path("genisoimage")
args = [
genisoimage, "-J", "-r", "-hide-rr-moved",
"-hide-joliet-trans-tbl", "-V", self.fslabel, "-o", iso
]
args.extend(self._get_mkisofs_options(isodir))
args.append(isodir)
if runner.show(args) != 0:
raise CreatorError("ISO creation failed!")
""" It should be ok still even if you haven't isohybrid """
isohybrid = None
try:
isohybrid = fs_related.find_binary_path("isohybrid")
except:
pass
if isohybrid:
args = [isohybrid, "-partok", iso]
if runner.show(args) != 0:
raise CreatorError("Hybrid ISO creation failed!")
self.__implant_md5sum(iso)
def resize2fs(fs, size):
resize2fs = find_binary_path("resize2fs")
if size == 0:
# it means to minimalize it
return runner.show([resize2fs, '-M', fs])
else:
return runner.show([resize2fs, fs, "%sK" % (size / 1024,)])
def _stage_final_image(self):
if self.compress_to:
self._resparse(0)
cfile_name = self.compress_to
mountfp_xml = os.path.splitext(cfile_name)[0] + ".xml"
for item in self._instloops:
imgfile = os.path.join(self.__imgdir, item['name'])
if item['fstype'] == "ext4":
runner.show('/sbin/tune2fs '
'-O ^huge_file,extents,uninit_bg %s ' \
% imgfile)
msger.info("Compress all loop images together to %s" % cfile_name)
dstfile = os.path.join(self._outdir, cfile_name)
if self.compress_imgdir_method == "tar":
misc.taring(dstfile, self.__imgdir)
elif self.compress_imgdir_method == "zip":
misc.ziping(dstfile, self.__imgdir)
else:
raise CreatorError("Unsupported compress type: %s" \
% self.compress_imgdir_method)
# save mount points mapping file to xml
save_mountpoints(os.path.join(self._outdir, mountfp_xml),
self._instloops,
self.target_arch)
else:
self._resparse()
for item in self._instloops:
shutil.move(os.path.join(self.__imgdir, item['name']),
os.path.join(self._outdir, item['name']))
def __create_iso(self, isodir):
iso = self._outdir + "/" + self.name + ".iso"
genisoimage = fs_related.find_binary_path("genisoimage")
args = [genisoimage,
"-J", "-r",
"-hide-rr-moved", "-hide-joliet-trans-tbl",
"-V", self.fslabel,
"-o", iso]
args.extend(self._get_mkisofs_options(isodir))
args.append(isodir)
if runner.show(args) != 0:
raise CreatorError("ISO creation failed!")
""" It should be ok still even if you haven't isohybrid """
isohybrid = None
try:
isohybrid = fs_related.find_binary_path("isohybrid")
except:
pass
if isohybrid:
args = [isohybrid, "-partok", iso ]
if runner.show(args) != 0:
raise CreatorError("Hybrid ISO creation failed!")
self.__implant_md5sum(iso)
def _stage_final_image(self):
if self.taring_to:
import tarfile
curdir = os.getcwd()
os.chdir(self.__imgdir)
self._resparse(0)
tarfile_name = self.taring_to
if not tarfile_name.endswith('.tar'):
tarfile_name += ".tar"
msger.info("Tar all loop images together to %s" % tarfile_name)
tar = tarfile.open(os.path.join(self._outdir, tarfile_name), 'w')
for item in self._instloops:
if item['fstype'] == "ext4":
runner.show(
'/sbin/tune2fs -O ^huge_file,extents,uninit_bg ' +
item['name'])
tar.add(item['name'])
tar.close()
os.chdir(curdir)
else:
self._resparse()
for item in self._instloops:
shutil.move(os.path.join(self.__imgdir, item['name']),
os.path.join(self._outdir, item['name']))
def myurlgrab(url, filename, proxies, progress_obj=None):
g = grabber.URLGrabber()
if progress_obj is None:
progress_obj = TextProgress()
if url.startswith("file:/"):
filepath = "/%s" % url.replace("file:", "").lstrip('/')
if not os.path.exists(filepath):
raise CreatorError("URLGrabber error: can't find file %s" % url)
if url.endswith('.rpm'):
return filepath
else:
# untouch repometadata in source path
runner.show(['cp', '-f', filepath, filename])
else:
try:
filename = g.urlgrab(url=str(url),
filename=filename,
ssl_verify_host=False,
ssl_verify_peer=False,
proxies=proxies,
http_headers=(('Pragma', 'no-cache'), ),
quote=0,
progress_obj=progress_obj)
except grabber.URLGrabError, err:
msg = str(err)
if msg.find(url) < 0:
msg += ' on %s' % url
raise CreatorError(msg)
def __format_filesystem(self):
if self.skipformat:
msger.debug("Skip filesystem format.")
return
msger.verbose("Formating %s filesystem on %s" % (self.fstype, self.disk.device))
cmdlist = [self.mkfscmd, "-F", "-L", self.fslabel, "-m", "1", "-b",
str(self.blocksize)]
if self.extopts:
cmdlist.extend(self.extopts.split())
cmdlist.extend([self.disk.device])
rc, errout = runner.runtool(cmdlist, catch=2)
if rc != 0:
raise MountError("Error creating %s filesystem on disk %s:\n%s" %
(self.fstype, self.disk.device, errout))
if not self.extopts:
msger.debug("Tuning filesystem on %s" % self.disk.device)
runner.show([self.tune2fs, "-c0", "-i0", "-Odir_index", "-ouser_xattr,acl", self.disk.device])
rc, out = runner.runtool([self.dumpe2fs, '-h', self.disk.device],
catch=2)
if rc != 0:
raise MountError("Error dumpe2fs %s filesystem on disk %s:\n%s" %
(self.fstype, self.disk.device, out))
# FIXME: specify uuid in mkfs parameter
try:
self.uuid = self.__parse_field(out, "Filesystem UUID")
except:
self.uuid = None
def unmount(self):
if self.has_chroot_instance():
return
if self.ismounted():
runner.show([self.umountcmd, "-l", self.dest])
self.mounted = False
def _install_syslinux(self):
for name in self.__disks.keys():
loopdev = self.__disks[name].device
# Set MBR
mbrfile = "%s/usr/share/syslinux/" % self._instroot
if self._ptable_format == 'gpt':
mbrfile += "gptmbr.bin"
else:
mbrfile += "mbr.bin"
msger.debug("Installing syslinux bootloader '%s' to %s" % \
(mbrfile, loopdev))
rc = runner.show(['dd', 'if=%s' % mbrfile, 'of=' + loopdev])
if rc != 0:
raise MountError("Unable to set MBR to %s" % loopdev)
# Ensure all data is flushed to disk before doing syslinux install
runner.quiet('sync')
fullpathsyslinux = fs_related.find_binary_path("extlinux")
rc = runner.show([fullpathsyslinux,
"-i",
"%s/boot/extlinux" % self._instroot])
if rc != 0:
raise MountError("Unable to install syslinux bootloader to %s" \
% loopdev)
def _stage_final_image(self):
try:
self.cmd_qemuimg = fs_related.find_binary_path('qemu-img')
except errors.CreatorError:
return LoopImageCreator._stage_final_image(self)
self._resparse()
imgfile = None
for item in self._instloops:
if item['mountpoint'] == '/':
if item['fstype'] == "ext4":
runner.show(
'/sbin/tune2fs -O ^huge_file,extents,uninit_bg %s' %
imgfile)
self.image_files.setdefault('partitions', {}).update(
{item['mountpoint']: item['label']})
imgfile = os.path.join(self._imgdir, item['name'])
if imgfile:
qemuimage = imgfile + ".x86"
runner.show("%s convert -O qcow2 %s %s" %
(self.cmd_qemuimg, imgfile, qemuimage))
os.unlink(imgfile)
os.rename(qemuimage, imgfile)
for item in os.listdir(self._imgdir):
shutil.move(os.path.join(self._imgdir, item),
os.path.join(self._outdir, item))
def __format_filesystem(self):
if self.skipformat:
msger.debug("Skip filesystem format.")
return
msger.verbose("Formating %s filesystem on %s" %
(self.fstype, self.disk.device))
cmdlist = [
self.mkfscmd, "-F", "-L", self.fslabel, "-m", "1", "-b",
str(self.blocksize), "-U", self.uuid
]
if self.extopts:
cmdlist.extend(self.extopts.split())
cmdlist.extend([self.disk.device])
rc, errout = runner.runtool(cmdlist, catch=2)
if rc != 0:
raise MountError("Error creating %s filesystem on disk %s:\n%s" %
(self.fstype, self.disk.device, errout))
if not self.extopts:
msger.debug("Tuning filesystem on %s" % self.disk.device)
runner.show([
self.tune2fs, "-c0", "-i0", "-Odir_index", "-ouser_xattr,acl",
self.disk.device
])
def unmount(self):
if self.has_chroot_instance():
return
if self.ismounted():
runner.show([self.umountcmd, "-l", self.dest])
self.mounted = False
def resize2fs(fs, size):
resize2fs = find_binary_path("resize2fs")
if size == 0:
# it means to minimalize it
return runner.show([resize2fs, '-M', fs])
else:
return runner.show([resize2fs, fs, "%sK" % (size / 1024, )])
def _stage_final_image(self):
if self.pack_to or self.shrink_image:
self._resparse(0)
else:
self._resparse()
for item in self._instloops:
imgfile = os.path.join(self.__imgdir, item['name'])
if item['fstype'] == "ext4":
runner.show('/sbin/tune2fs -O ^huge_file,extents,uninit_bg %s '
% imgfile)
if self.compress_image:
misc.compressing(imgfile, self.compress_image)
if not self.pack_to:
for item in os.listdir(self.__imgdir):
shutil.move(os.path.join(self.__imgdir, item),
os.path.join(self._outdir, item))
else:
msger.info("Pack all loop images together to %s" % self.pack_to)
dstfile = os.path.join(self._outdir, self.pack_to)
misc.packing(dstfile, self.__imgdir)
if self.pack_to:
mountfp_xml = os.path.splitext(self.pack_to)[0]
mountfp_xml = misc.strip_end(mountfp_xml, '.tar') + ".xml"
else:
mountfp_xml = self.name + ".xml"
# save mount points mapping file to xml
save_mountpoints(os.path.join(self._outdir, mountfp_xml),
self._instloops,
self.target_arch)
def __create_subvolumes(self, p, pdisk):
""" Create all the subvolumes. """
for subvol in self.subvolumes:
argv = [ self.btrfscmd, "subvolume", "create", pdisk.mountdir + "/" + subvol["subvol"]]
rc = runner.show(argv)
if rc != 0:
raise MountError("Failed to create subvolume '%s', return code: %d." % (subvol["subvol"], rc))
# Set default subvolume, subvolume for "/" is default
subvol = None
for subvolume in self.subvolumes:
if subvolume["mountpoint"] == "/" and p['disk_name'] == subvolume['disk_name']:
subvol = subvolume
break
if subvol:
# Get default subvolume id
subvolid = self. __get_subvolume_id(pdisk.mountdir, subvol["subvol"])
# Set default subvolume
if subvolid != -1:
rc = runner.show([ self.btrfscmd, "subvolume", "set-default", "%d" % subvolid, pdisk.mountdir])
if rc != 0:
raise MountError("Failed to set default subvolume id: %d', return code: %d." % (subvolid, rc))
self.__create_subvolume_metadata(p, pdisk)
def _install_syslinux(self):
i = 0
for name in self.__disks.keys():
loopdev = self.__disks[name].device
i =i+1
msger.debug("Installing syslinux bootloader to %s" % loopdev)
(bootdevnum, rootdevnum, rootdev, prefix) = self._get_syslinux_boot_config()
#Set MBR
mbrsize = os.stat("%s/usr/share/syslinux/mbr.bin" % self._instroot)[stat.ST_SIZE]
rc = runner.show(['dd', "if=%s/usr/share/syslinux/mbr.bin" % self._instroot, "of=" + loopdev])
if rc != 0:
raise MountError("Unable to set MBR to %s" % loopdev)
#Set Bootable flag
parted = fs_related.find_binary_path("parted")
rc = runner.quiet([parted, "-s", loopdev, "set", "%d" % (bootdevnum + 1), "boot", "on"])
#XXX disabled return code check because parted always fails to
#reload part table with loop devices. Annoying because we can't
#distinguish this failure from real partition failures :-(
if rc != 0 and 1 == 0:
raise MountError("Unable to set bootable flag to %sp%d" % (loopdev, (bootdevnum + 1)))
#Ensure all data is flushed to disk before doing syslinux install
runner.quiet('sync')
fullpathsyslinux = fs_related.find_binary_path("extlinux")
rc = runner.show([fullpathsyslinux, "-i", "%s/boot/extlinux" % self._instroot])
if rc != 0:
raise MountError("Unable to install syslinux bootloader to %sp%d" % (loopdev, (bootdevnum + 1)))
def _stage_final_image(self):
if self.pack_to or self.shrink_image:
self._resparse(0)
else:
self._resparse()
for item in self._instloops:
imgfile = os.path.join(self.__imgdir, item['name'])
if item['fstype'] == "ext4":
runner.show('/sbin/tune2fs -O ^huge_file,extents,uninit_bg %s '
% imgfile)
if self.compress_image:
misc.compressing(imgfile, self.compress_image)
if not self.pack_to:
for item in os.listdir(self.__imgdir):
shutil.move(os.path.join(self.__imgdir, item),
os.path.join(self._outdir, item))
else:
msger.info("Pack all loop images together to %s" % self.pack_to)
dstfile = os.path.join(self._outdir, self.pack_to)
misc.packing(dstfile, self.__imgdir)
if self.pack_to:
mountfp_xml = os.path.splitext(self.pack_to)[0]
mountfp_xml = misc.strip_end(mountfp_xml, '.tar') + ".xml"
else:
mountfp_xml = self.name + ".xml"
# save mount points mapping file to xml
save_mountpoints(os.path.join(self._outdir, mountfp_xml),
self._instloops,
self.target_arch)
def __create_subvolumes(self, p, pdisk):
""" Create all the subvolumes """
for subvol in self.subvolumes:
argv = [ self.btrfscmd, "subvolume", "create", pdisk.mountdir + "/" + subvol["subvol"]]
rc = runner.show(argv)
if rc != 0:
raise MountError("Failed to create subvolume '%s', return code: %d." % (subvol["subvol"], rc))
""" Set default subvolume, subvolume for "/" is default """
subvol = None
for subvolume in self.subvolumes:
if subvolume["mountpoint"] == "/" and p["disk"] == subvolume["disk"]:
subvol = subvolume
break
if subvol:
""" Get default subvolume id """
subvolid = self. __get_subvolume_id(pdisk.mountdir, subvol["subvol"])
""" Set default subvolume """
if subvolid != -1:
rc = runner.show([ self.btrfscmd, "subvolume", "set-default", "%d" % subvolid, pdisk.mountdir])
if rc != 0:
raise MountError("Failed to set default subvolume id: %d', return code: %d." % (subvolid, rc))
self.__create_subvolume_metadata(p, pdisk)
def _install_syslinux(self):
for name in self.__disks.keys():
loopdev = self.__disks[name].device
# Set MBR
mbrfile = "%s/usr/share/syslinux/" % self._instroot
if self._ptable_format == 'gpt':
mbrfile += "gptmbr.bin"
else:
mbrfile += "mbr.bin"
msger.debug("Installing syslinux bootloader '%s' to %s" % \
(mbrfile, loopdev))
mbrsize = os.stat(mbrfile)[stat.ST_SIZE]
rc = runner.show(['dd', 'if=%s' % mbrfile, 'of=' + loopdev])
if rc != 0:
raise MountError("Unable to set MBR to %s" % loopdev)
# Ensure all data is flushed to disk before doing syslinux install
runner.quiet('sync')
fullpathsyslinux = fs_related.find_binary_path("extlinux")
rc = runner.show([fullpathsyslinux,
"-i",
"%s/boot/extlinux" % self._instroot])
if rc != 0:
raise MountError("Unable to install syslinux bootloader to %s" \
% loopdev)
def myurlgrab(url, filename, proxies, progress_obj=None):
g = grabber.URLGrabber()
if progress_obj is None:
progress_obj = TextProgress()
if url.startswith("file:/"):
filepath = "/%s" % url.replace("file:", "").lstrip("/")
if not os.path.exists(filepath):
raise CreatorError("URLGrabber error: can't find file %s" % url)
if url.endswith(".rpm"):
return filepath
else:
# untouch repometadata in source path
runner.show(["cp", "-f", filepath, filename])
else:
try:
filename = g.urlgrab(
url=str(url),
filename=filename,
ssl_verify_host=False,
ssl_verify_peer=False,
proxies=proxies,
http_headers=(("Pragma", "no-cache"),),
quote=0,
progress_obj=progress_obj,
)
except grabber.URLGrabError, err:
msg = str(err)
if msg.find(url) < 0:
msg += " on %s" % url
raise CreatorError(msg)
def __create_subvolume_snapshots(self, p, pdisk):
import time
if self.snapshot_created:
return
""" Remount with subvolid=0 """
rc = runner.show([self.umountcmd, pdisk.mountdir])
if rc != 0:
raise MountError("Failed to umount %s" % pdisk.mountdir)
if pdisk.fsopts:
mountopts = pdisk.fsopts + ",subvolid=0"
else:
mountopts = "subvolid=0"
rc = runner.show([self.mountcmd, "-o", mountopts, pdisk.disk.device, pdisk.mountdir])
if rc != 0:
raise MountError("Failed to umount %s" % pdisk.mountdir)
""" Create all the subvolume snapshots """
snapshotts = time.strftime("%Y%m%d-%H%M")
for subvol in self.subvolumes:
subvolpath = pdisk.mountdir + "/" + subvol["subvol"]
snapshotpath = subvolpath + "_%s-1" % snapshotts
rc = runner.show([ self.btrfscmd, "subvolume", "snapshot", subvolpath, snapshotpath ])
if rc != 0:
raise MountError("Failed to create subvolume snapshot '%s' for '%s', return code: %d." % (snapshotpath, subvolpath, rc))
self.snapshot_created = True
def _stage_final_image(self):
try:
self.cmd_qemuimg = fs_related.find_binary_path('qemu-img')
except errors.CreatorError:
return LoopImageCreator._stage_final_image(self)
self._resparse()
imgfile = None
for item in self._instloops:
if item['mountpoint'] == '/':
if item['fstype'] == "ext4":
runner.show('/sbin/tune2fs -O ^huge_file,extents,uninit_bg %s'
% imgfile)
self.image_files.setdefault('partitions', {}).update(
{item['mountpoint']: item['label']})
imgfile = os.path.join(self._imgdir, item['name'])
if imgfile:
qemuimage = imgfile + ".x86"
runner.show("%s convert -O qcow2 %s %s"
% (self.cmd_qemuimg, imgfile, qemuimage))
os.unlink(imgfile)
os.rename(qemuimage, imgfile)
for item in os.listdir(self._imgdir):
shutil.move(os.path.join(self._imgdir, item),
os.path.join(self._outdir, item))
def __create_subvolume_snapshots(self, p, pdisk):
import time
if self.snapshot_created:
return
# Remount with subvolid=0
rc = runner.show([self.umountcmd, pdisk.mountdir])
if rc != 0:
raise MountError("Failed to umount %s" % pdisk.mountdir)
if pdisk.fsopts:
mountopts = pdisk.fsopts + ",subvolid=0"
else:
mountopts = "subvolid=0"
rc = runner.show([
self.mountcmd, "-o", mountopts, pdisk.disk.device, pdisk.mountdir
])
if rc != 0:
raise MountError("Failed to umount %s" % pdisk.mountdir)
# Create all the subvolume snapshots
snapshotts = time.strftime("%Y%m%d-%H%M")
for subvol in self.subvolumes:
subvolpath = pdisk.mountdir + "/" + subvol["subvol"]
snapshotpath = subvolpath + "_%s-1" % snapshotts
rc = runner.show([
self.btrfscmd, "subvolume", "snapshot", subvolpath,
snapshotpath
])
if rc != 0:
raise MountError(
"Failed to create subvolume snapshot '%s' for '%s', return code:"
"%d." % (snapshotpath, subvolpath, rc))
self.snapshot_created = True
def __mount_subvolumes(self, p, pdisk):
if self.skipformat:
# Get subvolume info
self.__get_subvolume_metadata(p, pdisk)
# Set default mount options
if len(self.subvolumes) != 0:
for subvol in self.subvolumes:
if subvol["mountpoint"] == p["mountpoint"] == "/":
opts = subvol["fsopts"].split(",")
for opt in opts:
if opt.strip().startswith("subvol="):
opts.remove(opt)
break
pdisk.fsopts = ",".join(opts)
break
if len(self.subvolumes) == 0:
# Return directly if no subvolumes
return
# Remount to make default subvolume mounted
rc = runner.show([self.umountcmd, pdisk.mountdir])
if rc != 0:
raise MountError("Failed to umount %s" % pdisk.mountdir)
rc = runner.show([
self.mountcmd, "-o", pdisk.fsopts, pdisk.disk.device,
pdisk.mountdir
])
if rc != 0:
raise MountError("Failed to umount %s" % pdisk.mountdir)
for subvol in self.subvolumes:
if subvol["mountpoint"] == "/":
continue
subvolid = self.__get_subvolume_id(pdisk.mountdir,
subvol["subvol"])
if subvolid == -1:
msger.debug("WARNING: invalid subvolume %s" % subvol["subvol"])
continue
# Replace subvolume name with subvolume ID
opts = subvol["fsopts"].split(",")
for opt in opts:
if opt.strip().startswith("subvol="):
opts.remove(opt)
break
opts.extend(["subvolrootid=0", "subvol=%s" % subvol["subvol"]])
fsopts = ",".join(opts)
subvol['fsopts'] = fsopts
mountpoint = self.mountdir + subvol['mountpoint']
makedirs(mountpoint)
rc = runner.show(
[self.mountcmd, "-o", fsopts, pdisk.disk.device, mountpoint])
if rc != 0:
raise MountError("Failed to mount subvolume %s to %s" %
(subvol["subvol"], mountpoint))
subvol["mounted"] = True
def package(self, destdir = "."):
ignores = ["/dev/fd",
"/dev/stdin",
"/dev/stdout",
"/dev/stderr",
"/etc/mtab"]
if not os.path.exists(destdir):
os.makedirs(destdir)
if self._recording_pkgs:
self._save_recording_pkgs(destdir)
if self._img_compression_method == None:
fsdir = os.path.join(destdir, self.name)
misc.check_space_pre_cp(self._instroot, destdir)
msger.info("Copying %s to %s ..." % (self._instroot, fsdir))
runner.show(['cp', "-af", self._instroot, fsdir])
for exclude in ignores:
if os.path.exists(fsdir + exclude):
os.unlink(fsdir + exclude)
self.outimage.append(fsdir)
elif self._img_compression_method == "tar.bz2":
dst = "%s/%s.tar.bz2" % (destdir, self.name)
msger.info("Creating %s (compressing %s with %s). Please wait..." \
% (dst, self._instroot, self._img_compression_method))
tar = find_binary_path('tar')
tar_cmdline = [tar, "--numeric-owner",
"--preserve-permissions",
"--preserve-order",
"--one-file-system",
"--directory",
self._instroot]
for ignore_entry in ignores:
if ignore_entry.startswith('/'):
ignore_entry = ignore_entry[1:]
tar_cmdline.append("--exclude=%s" % (ignore_entry))
tar_cmdline.extend(["-cjf", dst, "."])
rc = call(tar_cmdline)
if rc:
raise CreatorError("Failed compress image with tar.bz2. "
"Cmdline: %s" % (" ".join(tar_cmdline)))
self.outimage.append(dst)
else:
raise CreatorError("Compression method '%s' not supported for 'fs' "
"image format." % (self._img_compression_method))
def __implant_md5sum(self, iso):
"""Implant an isomd5sum."""
if os.path.exists("/usr/bin/implantisomd5"):
implantisomd5 = "/usr/bin/implantisomd5"
else:
msger.warning("isomd5sum not installed; not setting up mediacheck")
implantisomd5 = ""
return
runner.show([implantisomd5, iso])
def __implant_md5sum(self, iso):
"""Implant an isomd5sum."""
if os.path.exists("/usr/bin/implantisomd5"):
implantisomd5 = "/usr/bin/implantisomd5"
else:
msger.warning("isomd5sum not installed; not setting up mediacheck")
implantisomd5 = ""
return
runner.show([implantisomd5, iso])
def reread_size(self):
if self.device is None:
return
msger.debug("Reread size %s" % self.device)
rc = runner.show([self.losetupcmd, "-c", self.device])
# XXX: (WORKAROUND) re-setup loop device when losetup isn't support '-c' option.
if rc != 0:
msger.debug(
"Fail to reread size, Try to re-setup loop device to reread the size of the file associated"
)
runner.show([self.losetupcmd, "-d", self.device])
runner.show([self.losetupcmd, self.device, self.lofile])
def __mount_subvolumes(self, p, pdisk):
if self.skipformat:
""" Get subvolume info """
self.__get_subvolume_metadata(p, pdisk)
""" Set default mount options """
if len(self.subvolumes) != 0:
for subvol in self.subvolumes:
if subvol["mountpoint"] == p["mountpoint"] == "/":
opts = subvol["fsopts"].split(",")
for opt in opts:
if opt.strip().startswith("subvol="):
opts.remove(opt)
break
pdisk.fsopts = ",".join(opts)
break
if len(self.subvolumes) == 0:
""" Return directly if no subvolumes """
return
""" Remount to make default subvolume mounted """
rc = runner.show([self.umountcmd, pdisk.mountdir])
if rc != 0:
raise MountError("Failed to umount %s" % pdisk.mountdir)
rc = runner.show([self.mountcmd, "-o", pdisk.fsopts, pdisk.disk.device, pdisk.mountdir])
if rc != 0:
raise MountError("Failed to umount %s" % pdisk.mountdir)
for subvol in self.subvolumes:
if subvol["mountpoint"] == "/":
continue
subvolid = self. __get_subvolume_id(pdisk.mountdir, subvol["subvol"])
if subvolid == -1:
msger.debug("WARNING: invalid subvolume %s" % subvol["subvol"])
continue
""" Replace subvolume name with subvolume ID """
opts = subvol["fsopts"].split(",")
for opt in opts:
if opt.strip().startswith("subvol="):
opts.remove(opt)
break
opts.extend(["subvolrootid=0", "subvol=%s" % subvol["subvol"]])
fsopts = ",".join(opts)
subvol['fsopts'] = fsopts
mountpoint = self.mountdir + subvol['mountpoint']
makedirs(mountpoint)
rc = runner.show([self.mountcmd, "-o", fsopts, pdisk.disk.device, mountpoint])
if rc != 0:
raise MountError("Failed to mount subvolume %s to %s" % (subvol["subvol"], mountpoint))
subvol["mounted"] = True
def __check_btrfs(self):
found = False
""" Need to load btrfs module to mount it """
load_module("btrfs")
for line in open("/proc/filesystems").xreadlines():
if line.find("btrfs") > -1:
found = True
break
if not found:
raise MountError("Your system can't mount btrfs filesystem, please make sure your kernel has btrfs support and the module btrfs.ko has been loaded.")
# disable selinux, selinux will block write
if os.path.exists("/usr/sbin/setenforce"):
runner.show(["/usr/sbin/setenforce", "0"])
def mkvdfs(in_img, out_img, fsoptions):
""" This function is incomplete. """
fullpathmkvdfs = find_binary_path("mkfs.vdfs")
# args = fullpathmkvdfs + " -i -r "+ in_img + " -z 1024M -s " + out_img
args = fullpathmkvdfs + " " + fsoptions + " -r " + in_img + " " + out_img
msger.verbose("vdfs args: %s" % args)
runner.show("%s --help" % fullpathmkvdfs)
# if not sys.stdout.isatty():
# args.append("-no-progress")
# runner.show("%s --help" % fullpathmkvdfs)
ret = runner.show(args)
if ret != 0:
runner.show("vdfs error")
raise VdfsError("' %s' exited with error (%d)" % (args, ret))
def __check_btrfs(self):
found = False
""" Need to load btrfs module to mount it """
load_module("btrfs")
for line in open("/proc/filesystems").xreadlines():
if line.find("btrfs") > -1:
found = True
break
if not found:
raise MountError("Your system can't mount btrfs filesystem, please make sure your kernel has btrfs support and the module btrfs.ko has been loaded.")
# disable selinux, selinux will block write
if os.path.exists("/usr/sbin/setenforce"):
runner.show(["/usr/sbin/setenforce", "0"])
def mount(self):
for dev in self.disks.keys():
d = self.disks[dev]
d['disk'].create()
self.__format_disks()
self.__map_partitions()
self.__calculate_mountorder()
for mp in self.mountOrder:
p = None
for p1 in self.partitions:
if p1['mountpoint'] == mp:
p = p1
break
if mp == 'swap':
runner.show([self.mkswap, p['device']])
continue
rmmountdir = False
if p['mountpoint'] == "/":
rmmountdir = True
if p['fstype'] == "vfat" or p['fstype'] == "msdos":
myDiskMount = VfatDiskMount
elif p['fstype'] in ("ext2", "ext3", "ext4"):
myDiskMount = ExtDiskMount
elif p['fstype'] == "btrfs":
myDiskMount = BtrfsDiskMount
else:
raise MountError("Fail to support file system " + p['fstype'])
if p['fstype'] == "btrfs" and not p['fsopts']:
p['fsopts'] = "subvolid=0"
pdisk = myDiskMount(RawDisk(p['size'] * self.sector_size,
p['device']),
self.mountdir + p['mountpoint'],
p['fstype'],
4096,
p['mountpoint'],
rmmountdir,
self.skipformat,
fsopts=p['fsopts'])
pdisk.mount(pdisk.fsopts)
if p['fstype'] == "btrfs" and p['mountpoint'] == "/":
if not self.skipformat:
self.__create_subvolumes(p, pdisk)
self.__mount_subvolumes(p, pdisk)
p['mount'] = pdisk
def package(self, destdir = "."):
"""Prepares the created image for final delivery.
In its simplest form, this method merely copies the install root to the
supplied destination directory; other subclasses may choose to package
the image by e.g. creating a bootable ISO containing the image and
bootloader configuration.
destdir -- the directory into which the final image should be moved;
this defaults to the current directory.
"""
self._stage_final_image()
if not os.path.exists(destdir):
fs.makedirs(destdir)
if self._img_compression_method:
if not self._img_name:
raise CreatorError("Image name not set.")
rc = None
img_location = os.path.join(self._outdir,self._img_name)
if self._img_compression_method == "bz2":
bzip2 = fs.find_binary_path('bzip2')
msger.info("Compressing %s with bzip2. Please wait..." % img_location)
rc = runner.show([bzip2, "-f", img_location])
if rc:
raise CreatorError("Failed to compress image %s with %s." % (img_location, self._img_compression_method))
for bootimg in glob.glob(os.path.dirname(img_location) + "/*-boot.bin"):
msger.info("Compressing %s with bzip2. Please wait..." % bootimg)
rc = runner.show([bzip2, "-f", bootimg])
if rc:
raise CreatorError("Failed to compress image %s with %s." % (bootimg, self._img_compression_method))
if self._recording_pkgs:
self._save_recording_pkgs(destdir)
""" For image formats with two or multiple image files, it will be better to put them under a directory """
if self.image_format in ("raw", "vmdk", "vdi", "nand", "mrstnand"):
destdir = os.path.join(destdir, "%s-%s" % (self.name, self.image_format))
msger.debug("creating destination dir: %s" % destdir)
fs.makedirs(destdir)
# Ensure all data is flushed to _outdir
runner.quiet('sync')
for f in os.listdir(self._outdir):
shutil.move(os.path.join(self._outdir, f),
os.path.join(destdir, f))
self.outimage.append(os.path.join(destdir, f))
self.do_genchecksum(os.path.join(destdir, f))
def mount(self):
for dev in self.disks.keys():
d = self.disks[dev]
d['disk'].create()
self.__format_disks()
self.__map_partitions()
self.__calculate_mountorder()
for mp in self.mountOrder:
p = None
for p1 in self.partitions:
if p1['mountpoint'] == mp:
p = p1
break
if mp == 'swap':
runner.show([self.mkswap, p['device']])
continue
rmmountdir = False
if p['mountpoint'] == "/":
rmmountdir = True
if p['fstype'] == "vfat" or p['fstype'] == "msdos":
myDiskMount = VfatDiskMount
elif p['fstype'] in ("ext2", "ext3", "ext4"):
myDiskMount = ExtDiskMount
elif p['fstype'] == "btrfs":
myDiskMount = BtrfsDiskMount
else:
raise MountError("Fail to support file system " + p['fstype'])
if p['fstype'] == "btrfs" and not p['fsopts']:
p['fsopts'] = "subvolid=0"
pdisk = myDiskMount(RawDisk(p['size'] * self.sector_size, p['device']),
self.mountdir + p['mountpoint'],
p['fstype'],
4096,
p['mountpoint'],
rmmountdir,
self.skipformat,
fsopts = p['fsopts'])
pdisk.mount(pdisk.fsopts)
if p['fstype'] == "btrfs" and p['mountpoint'] == "/":
if not self.skipformat:
self.__create_subvolumes(p, pdisk)
self.__mount_subvolumes(p, pdisk)
p['mount'] = pdisk
def mount(self, options = None):
if self.mounted:
return
if not os.path.isdir(self.mountdir):
msger.debug("Creating mount point %s" % self.mountdir)
os.makedirs(self.mountdir)
self.rmdir = self.rmmountdir
self.__create()
msger.debug("Mounting %s at %s" % (self.disk.device, self.mountdir))
if options:
args = [ self.mountcmd, "-o", options, self.disk.device, self.mountdir ]
else:
args = [ self.mountcmd, self.disk.device, self.mountdir ]
if self.fstype:
args.extend(["-t", self.fstype])
rc = runner.show(args)
if rc != 0:
raise MountError("Failed to mount '%s' to '%s' with command '%s'. Retval: %s" %
(self.disk.device, self.mountdir, " ".join(args), rc))
self.mounted = True
def uncompress_squashfs(squashfsimg, outdir):
"""Uncompress file system from squshfs image"""
unsquashfs = find_binary_path("unsquashfs")
args = [ unsquashfs, "-d", outdir, squashfsimg ]
rc = runner.show(args)
if (rc != 0):
raise SquashfsError("Failed to uncompress %s." % squashfsimg)
def generate_bmap(self):
""" Generate block map file for the image. The idea is that while disk
images we generate may be large (e.g., 4GiB), they may actually contain
only little real data, e.g., 512MiB. This data are files, directories,
file-system meta-data, partition table, etc. In other words, when
flashing the image to the target device, you do not have to copy all the
4GiB of data, you can copy only 512MiB of it, which is 4 times faster.
This function generates the block map file for an arbitrary image that
mic has generated. The block map file is basically an XML file which
contains a list of blocks which have to be copied to the target device.
The other blocks are not used and there is no need to copy them. """
if self.bmap_needed is None:
return
msger.info("Generating the map file(s)")
for name in self.__disks.keys():
image = self._full_path(self.__imgdir, name, self.__disk_format)
bmap_file = self._full_path(self._outdir, name, "bmap")
self.image_files.setdefault(name, {}).update({'bmap': \
os.path.basename(bmap_file)})
msger.debug("Generating block map file '%s'" % bmap_file)
bmaptoolcmd = misc.find_binary_path('bmaptool')
rc = runner.show([bmaptoolcmd, 'create', image, '-o', bmap_file])
if rc != 0:
raise CreatorError("Failed to create bmap file: %s" % bmap_file)
def generate_bmap(self):
""" Generate block map file for the image. The idea is that while disk
images we generate may be large (e.g., 4GiB), they may actually contain
only little real data, e.g., 512MiB. This data are files, directories,
file-system meta-data, partition table, etc. In other words, when
flashing the image to the target device, you do not have to copy all the
4GiB of data, you can copy only 512MiB of it, which is 4 times faster.
This function generates the block map file for an arbitrary image that
mic has generated. The block map file is basically an XML file which
contains a list of blocks which have to be copied to the target device.
The other blocks are not used and there is no need to copy them. """
if self.bmap_needed is None:
return
msger.info("Generating the map file(s)")
for name in self.__disks.keys():
image = self._full_path(self.__imgdir, name, self.__disk_format)
bmap_file = self._full_path(self._outdir, name, "bmap")
self.image_files.setdefault(name, {}).update({'bmap': \
os.path.basename(bmap_file)})
msger.debug("Generating block map file '%s'" % bmap_file)
bmaptoolcmd = misc.find_binary_path('bmaptool')
rc = runner.show([bmaptoolcmd, 'create', image, '-o', bmap_file])
if rc != 0:
raise CreatorError("Failed to create bmap file: %s" % bmap_file)
def __map_partitions(self):
"""Load it if dm_snapshot isn't loaded"""
load_module("dm_snapshot")
for dev in self.disks.keys():
d = self.disks[dev]
if d['mapped']:
continue
msger.debug("Running kpartx on %s" % d['disk'].device )
rc, kpartxOutput = runner.runtool([self.kpartx, "-l", "-v", d['disk'].device])
kpartxOutput = kpartxOutput.splitlines()
if rc != 0:
raise MountError("Failed to query partition mapping for '%s'" %
d['disk'].device)
# Strip trailing blank and mask verbose output
i = 0
while i < len(kpartxOutput) and kpartxOutput[i][0:4] != "loop":
i = i + 1
kpartxOutput = kpartxOutput[i:]
# Quick sanity check that the number of partitions matches
# our expectation. If it doesn't, someone broke the code
# further up
if len(kpartxOutput) != d['numpart']:
raise MountError("Unexpected number of partitions from kpartx: %d != %d" %
(len(kpartxOutput), d['numpart']))
for i in range(len(kpartxOutput)):
line = kpartxOutput[i]
newdev = line.split()[0]
mapperdev = "/dev/mapper/" + newdev
loopdev = d['disk'].device + newdev[-1]
msger.debug("Dev %s: %s -> %s" % (newdev, loopdev, mapperdev))
pnum = d['partitions'][i]
self.partitions[pnum]['device'] = loopdev
# grub's install wants partitions to be named
# to match their parent device + partition num
# kpartx doesn't work like this, so we add compat
# symlinks to point to /dev/mapper
if os.path.lexists(loopdev):
os.unlink(loopdev)
os.symlink(mapperdev, loopdev)
msger.debug("Adding partx mapping for %s" % d['disk'].device)
rc = runner.show([self.kpartx, "-v", "-a", d['disk'].device])
if rc != 0:
# Make sure that the device maps are also removed on error case.
# The d['mapped'] isn't set to True if the kpartx fails so
# failed mapping will not be cleaned on cleanup either.
runner.quiet([self.kpartx, "-d", d['disk'].device])
raise MountError("Failed to map partitions for '%s'" %
d['disk'].device)
d['mapped'] = True
def do_unpack(cls, srcimg):
srcimgsize = (misc.get_file_size(srcimg)) * 1024L * 1024L
srcmnt = misc.mkdtemp("srcmnt")
disk = fs_related.SparseLoopbackDisk(srcimg, srcimgsize)
srcloop = PartitionedMount(srcmnt, skipformat = True)
srcloop.add_disk('/dev/sdb', disk)
srcloop.add_partition(srcimgsize/1024/1024, "/dev/sdb", "/", "ext3", boot=False)
try:
srcloop.mount()
except errors.MountError:
srcloop.cleanup()
raise
image = os.path.join(tempfile.mkdtemp(dir = "/var/tmp", prefix = "tmp"), "target.img")
args = ['dd', "if=%s" % srcloop.partitions[0]['device'], "of=%s" % image]
msger.info("`dd` image ...")
rc = runner.show(args)
srcloop.cleanup()
shutil.rmtree(os.path.dirname(srcmnt), ignore_errors = True)
if rc != 0:
raise errors.CreatorError("Failed to dd")
else:
return image
def mount(self, options=None):
if self.mounted:
return
if not os.path.isdir(self.mountdir):
msger.debug("Creating mount point %s" % self.mountdir)
os.makedirs(self.mountdir)
self.rmdir = self.rmmountdir
self.__create()
msger.debug("Mounting %s at %s" % (self.disk.device, self.mountdir))
if options:
args = [
self.mountcmd, "-o", options, self.disk.device, self.mountdir
]
else:
args = [self.mountcmd, self.disk.device, self.mountdir]
if self.fstype:
args.extend(["-t", self.fstype])
rc = runner.show(args)
if rc != 0:
raise MountError(
"Failed to mount '%s' to '%s' with command '%s'. Retval: %s" %
(self.disk.device, self.mountdir, " ".join(args), rc))
self.mounted = True
def __map_partitions(self):
"""Load it if dm_snapshot isn't loaded"""
load_module("dm_snapshot")
for dev in self.disks.keys():
d = self.disks[dev]
if d['mapped']:
continue
msger.debug("Running kpartx on %s" % d['disk'].device )
rc, kpartxOutput = runner.runtool([self.kpartx, "-l", "-v", d['disk'].device])
kpartxOutput = kpartxOutput.splitlines()
if rc != 0:
raise MountError("Failed to query partition mapping for '%s'" %
d['disk'].device)
# Strip trailing blank and mask verbose output
i = 0
while i < len(kpartxOutput) and kpartxOutput[i][0:4] != "loop":
i = i + 1
kpartxOutput = kpartxOutput[i:]
# Quick sanity check that the number of partitions matches
# our expectation. If it doesn't, someone broke the code
# further up
if len(kpartxOutput) != d['numpart']:
raise MountError("Unexpected number of partitions from kpartx: %d != %d" %
(len(kpartxOutput), d['numpart']))
for i in range(len(kpartxOutput)):
line = kpartxOutput[i]
newdev = line.split()[0]
mapperdev = "/dev/mapper/" + newdev
loopdev = d['disk'].device + newdev[-1]
msger.debug("Dev %s: %s -> %s" % (newdev, loopdev, mapperdev))
pnum = d['partitions'][i]
self.partitions[pnum]['device'] = loopdev
# grub's install wants partitions to be named
# to match their parent device + partition num
# kpartx doesn't work like this, so we add compat
# symlinks to point to /dev/mapper
if os.path.lexists(loopdev):
os.unlink(loopdev)
os.symlink(mapperdev, loopdev)
msger.debug("Adding partx mapping for %s" % d['disk'].device)
rc = runner.show([self.kpartx, "-v", "-a", d['disk'].device])
if rc != 0:
# Make sure that the device maps are also removed on error case.
# The d['mapped'] isn't set to True if the kpartx fails so
# failed mapping will not be cleaned on cleanup either.
runner.quiet([self.kpartx, "-d", d['disk'].device])
raise MountError("Failed to map partitions for '%s'" %
d['disk'].device)
d['mapped'] = True
def do_unpack(cls, srcimg):
srcimgsize = (misc.get_file_size(srcimg)) * 1024L * 1024L
srcmnt = misc.mkdtemp("srcmnt")
disk = fs_related.SparseLoopbackDisk(srcimg, srcimgsize)
srcloop = PartitionedMount({'/dev/sdb': disk}, srcmnt, skipformat=True)
srcloop.add_partition(srcimgsize / 1024 / 1024,
"/dev/sdb",
"/",
"ext3",
boot=False)
try:
srcloop.mount()
except errors.MountError:
srcloop.cleanup()
raise
image = os.path.join(tempfile.mkdtemp(dir="/var/tmp", prefix="tmp"),
"target.img")
args = [
'dd',
"if=%s" % srcloop.partitions[0]['device'],
"of=%s" % image
]
msger.info("`dd` image ...")
rc = runner.show(args)
srcloop.cleanup()
shutil.rmtree(os.path.dirname(srcmnt), ignore_errors=True)
if rc != 0:
raise errors.CreatorError("Failed to dd")
else:
return image
def do_install_disk(self, disk, disk_name, cr, 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.
"""
mbrfile = "%s/syslinux/" % bootimg_dir
if cr._ptable_format == 'gpt':
mbrfile += "gptmbr.bin"
else:
mbrfile += "mbr.bin"
if not os.path.exists(mbrfile):
msger.error(
"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 = cr._full_path(workdir, disk_name, "direct")
msger.debug("Installing MBR on disk %s as %s with size %s bytes" \
% (disk_name, full_path, disk['min_size']))
rc = runner.show(
['dd',
'if=%s' % mbrfile,
'of=%s' % full_path, 'conv=notrunc'])
if rc != 0:
raise MountError("Unable to set MBR to %s" % full_path)
def _install_syslinux(self):
i = 0
for name in self.__disks.keys():
loopdev = self.__disks[name].device
i =i+1
msger.debug("Installing syslinux bootloader to %s" % loopdev)
(bootdevnum, rootdevnum, rootdev, prefix) = \
self._get_syslinux_boot_config()
#Set MBR
mbrsize = os.stat("%s/usr/share/syslinux/mbr.bin" \
% self._instroot)[stat.ST_SIZE]
rc = runner.show(['dd',
'if=%s/usr/share/syslinux/mbr.bin' % self._instroot,
'of=' + loopdev])
if rc != 0:
raise MountError("Unable to set MBR to %s" % loopdev)
#Set Bootable flag
parted = fs_related.find_binary_path("parted")
rc = runner.quiet([parted,
"-s",
loopdev,
"set",
"%d" % (bootdevnum + 1),
"boot",
"on"])
#XXX disabled return code check because parted always fails to
#reload part table with loop devices. Annoying because we can't
#distinguish this failure from real partition failures :-(
if rc != 0 and 1 == 0:
raise MountError("Unable to set bootable flag to %sp%d" \
% (loopdev, (bootdevnum + 1)))
#Ensure all data is flushed to disk before doing syslinux install
runner.quiet('sync')
fullpathsyslinux = fs_related.find_binary_path("extlinux")
rc = runner.show([fullpathsyslinux,
"-i",
"%s/boot/extlinux" % self._instroot])
if rc != 0:
raise MountError("Unable to install syslinux bootloader to %sp%d" \
% (loopdev, (bootdevnum + 1)))
def compressing(fpath, method):
comp_map = {"gz": "gzip", "bz2": "bzip2"}
if method not in comp_map:
raise CreatorError("Unsupport compress format: %s, valid values: %s" %
(method, ','.join(comp_map.keys())))
cmd = find_binary_path(comp_map[method])
rc = runner.show([cmd, "-f", fpath])
if rc:
raise CreatorError("Failed to %s file: %s" % (comp_map[method], fpath))
def mksquashfs(in_img, out_img):
fullpathmksquashfs = find_binary_path("mksquashfs")
args = [fullpathmksquashfs, in_img, out_img]
if not sys.stdout.isatty():
args.append("-no-progress")
ret = runner.show(args)
if ret != 0:
raise SquashfsError("'%s' exited with error (%d)" % (' '.join(args), ret))
def mount(self):
if self.mounted or self.ismounted():
return
makedirs(self.dest)
rc = runner.show([self.mountcmd, "--bind", self.src, self.dest])
if rc != 0:
raise MountError("Bind-mounting '%s' to '%s' failed" %
(self.src, self.dest))
if self.option:
rc = runner.show([self.mountcmd, "--bind", "-o", "remount,%s" % self.option, self.dest])
if rc != 0:
raise MountError("Bind-remounting '%s' failed" % self.dest)
self.mounted = True
if os.path.islink(self.orig_src):
dest = os.path.join(self.root, self.orig_src.lstrip('/'))
if not os.path.exists(dest):
os.symlink(self.src, dest)
def mksquashfs(in_img, out_img):
fullpathmksquashfs = find_binary_path("mksquashfs")
args = [fullpathmksquashfs, in_img, out_img]
if not sys.stdout.isatty():
args.append("-no-progress")
ret = runner.show(args)
if ret != 0:
raise SquashfsError("'%s' exited with error (%d)" % (' '.join(args), ret))
def __format_filesystem(self):
if self.skipformat:
msger.debug("Skip filesystem format.")
return
msger.verbose("Formating %s filesystem on %s" % (self.fstype, self.disk.device))
cmdlist = [self.mkfscmd, "-F", "-L", self.fslabel, "-m", "1", "-b",
str(self.blocksize), "-U", self.uuid]
if self.extopts:
cmdlist.extend(self.extopts.split())
cmdlist.extend([self.disk.device])
rc, errout = runner.runtool(cmdlist, catch=2)
if rc != 0:
raise MountError("Error creating %s filesystem on disk %s:\n%s" %
(self.fstype, self.disk.device, errout))
if not self.extopts:
msger.debug("Tuning filesystem on %s" % self.disk.device)
runner.show([self.tune2fs, "-c0", "-i0", "-Odir_index", "-ouser_xattr,acl", self.disk.device])
def __format_filesystem(self):
if self.skipformat:
msger.debug("Skip filesystem format.")
return
msger.verbose("Formating %s filesystem on %s" % (self.fstype, self.disk.device))
rc = runner.show([self.mkfscmd, "-L", self.fslabel, self.disk.device])
if rc != 0:
raise MountError("Error creating %s filesystem on disk %s" % (self.fstype,self.disk.device))
self.uuid = self.__parse_field(runner.outs([self.blkidcmd, self.disk.device]), "UUID")
def _stage_final_image(self):
if self.pack_to or self.shrink_image:
self._resparse(0)
else:
self._resparse()
for item in self._instloops:
imgfile = os.path.join(self._imgdir, item['name'])
if item['fstype'] == "ext4":
runner.show('/sbin/tune2fs -O ^huge_file,extents,uninit_bg %s '
% imgfile)
self.image_files.setdefault('partitions', {}).update(
{item['mountpoint']: item['label']})
if self.compress_image:
compressing(imgfile, self.compress_image)
self.image_files.setdefault('image_files', []).append(
'.'.join([item['name'], self.compress_image]))
else:
self.image_files.setdefault('image_files', []).append(item['name'])
if not self.pack_to:
for item in os.listdir(self._imgdir):
shutil.move(os.path.join(self._imgdir, item),
os.path.join(self._outdir, item))
else:
msger.info("Pack all loop images together to %s" % self.pack_to)
dstfile = os.path.join(self._outdir, self.pack_to)
packing(dstfile, self._imgdir)
self.image_files['image_files'] = [self.pack_to]
if self.pack_to:
mountfp_xml = os.path.splitext(self.pack_to)[0]
mountfp_xml = misc.strip_end(mountfp_xml, '.tar') + ".xml"
else:
mountfp_xml = self.name + ".xml"
# save mount points mapping file to xml
save_mountpoints(os.path.join(self._outdir, mountfp_xml),
self._instloops,
self.target_arch)
def compressing(fpath, method):
comp_map = {
"gz": "gzip",
"bz2": "bzip2"
}
if method not in comp_map:
raise CreatorError("Unsupport compress format: %s, valid values: %s"
% (method, ','.join(comp_map.keys())))
cmd = find_binary_path(comp_map[method])
rc = runner.show([cmd, "-f", fpath])
if rc:
raise CreatorError("Failed to %s file: %s" % (comp_map[method], fpath))
def __format_filesystem(self):
if self.skipformat:
msger.debug("Skip filesystem format.")
return
msger.verbose("Formating %s filesystem on %s" % (self.fstype, self.disk.device))
rc = runner.show([self.mkfscmd, "-n", self.fslabel,
"-i", self.uuid.replace("-", ""), self.disk.device])
if rc != 0:
raise MountError("Error creating %s filesystem on disk %s" % (self.fstype,self.disk.device))
msger.verbose("Tuning filesystem on %s" % self.disk.device)
