import re
import tarfile
import glob
+import json
+from datetime import datetime
import rpm
from mic import kickstart
-from mic import msger
+from mic import msger, __version__ as VERSION
from mic.utils.errors import CreatorError, Abort
from mic.utils import misc, grabber, runner, fs_related as fs
from mic.chroot import kill_proc_inchroot
imgcreate.ImageCreator(ks, "foo").create()
"""
+ # Output image format
+ img_format = ''
def __del__(self):
self.cleanup()
# Output image file names
self.outimage = []
-
+ # Output info related with manifest
+ self.image_files = {}
# A flag to generate checksum
self._genchecksum = False
return self.pkgmgr(target_arch = self.target_arch,
instroot = self._instroot,
cachedir = self.cachedir)
+
+ def create_manifest(self):
+ def get_pack_suffix():
+ return '.' + self.pack_to.split('.', 1)[1]
+
+ if not os.path.exists(self.destdir):
+ os.makedirs(self.destdir)
+
+ now = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+ manifest_dict = {'version': VERSION,
+ 'created': now}
+ if self.img_format:
+ manifest_dict.update({'format': self.img_format})
+
+ if hasattr(self, 'logfile') and self.logfile:
+ manifest_dict.update({'log_file': self.logfile})
+
+ if self.image_files:
+ if self.pack_to:
+ self.image_files.update({'pack': get_pack_suffix()})
+ manifest_dict.update({self.img_format: self.image_files})
+
+ msger.info('Creating manifest file...')
+ manifest_file_path = os.path.join(self.destdir, 'manifest.json')
+ with open(manifest_file_path, 'w') as fest_file:
+ json.dump(manifest_dict, fest_file, indent=4)
+ self.outimage.append(manifest_file_path)
from mic.imager.baseimager import BaseImageCreator
class FsImageCreator(BaseImageCreator):
+ img_format = 'fs'
+
def __init__(self, cfgmgr = None, pkgmgr = None):
self.zips = {
"tar.bz2" : ""
self._save_recording_pkgs(destdir)
if not self.pack_to:
+ self.image_files = {'image_files': [self.name]}
fsdir = os.path.join(destdir, self.name)
misc.check_space_pre_cp(self._instroot, destdir)
self.outimage.append(fsdir)
else:
+ self.image_files = {'image_files': [self.pack_to]}
(tar, comp) = os.path.splitext(self.pack_to)
try:
tarcreat = {'.tar': '-cf',
"Cmdline: %s" % (" ".join(tar_cmdline)))
self.outimage.append(dst)
-
from mic.utils import fs_related, rpmmisc, runner, misc
from mic.utils.errors import CreatorError
from mic.imager.loop import LoopImageCreator
+from mic.imager.baseimager import BaseImageCreator
class LiveImageCreatorBase(LoopImageCreator):
bootloader, bootloader configuration, kernel and initramfs.
"""
+ img_format = 'livecd'
+
def __init__(self, creatoropts = None, pkgmgr = None):
"""Initialise a LiveImageCreator instance.
packimg = os.path.join(self._outdir, self.pack_to)
misc.packing(packimg, isoimg)
os.unlink(isoimg)
+ self.image_files.update({'image_files': [self.pack_to]})
+ else:
+ self.image_files.update({'image_files': [self.name + ".iso"]})
finally:
shutil.rmtree(self.__isodir, ignore_errors = True)
self.__isodir = None
+
class x86LiveImageCreator(LiveImageCreatorBase):
"""ImageCreator for x86 machines"""
def _get_mkisofs_options(self, isodir):
class LiveUSBImageCreator(LiveCDImageCreator):
+ img_format = 'liveusb'
+
def __init__(self, *args):
LiveCDImageCreator.__init__(self, *args)
self._create_usbimg(isodir)
if self.pack_to:
+ self.image_files.update({'image_files': self.pack_to})
usbimg = os.path.join(self._outdir, self.name + ".usbimg")
packimg = os.path.join(self._outdir, self.pack_to)
misc.packing(packimg, usbimg)
os.unlink(usbimg)
+ else:
+ self.image_files.update({'image_files': self.name + ".usbimg"})
finally:
shutil.rmtree(isodir, ignore_errors = True)
When specifying multiple partitions in kickstart file, each partition
will be created as a separated loop image.
"""
+ img_format = 'loop'
def __init__(self, creatoropts=None, pkgmgr=None,
compress_image=None,
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:
misc.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):
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)
+ self.image_files['image_files'] = [self.pack_to]
+
if self.pack_to:
mountfp_xml = os.path.splitext(self.pack_to)[0]
msger.verbose("Copy attachment %s to %s" % (item, dpath))
shutil.copy(item, dpath)
+ def create_manifest(self):
+ if self.compress_image:
+ self.image_files.update({'compress': self.compress_image})
+ super(LoopImageCreator, self).create_manifest()
and the system installed into an virtual disk. The disk image can
subsequently be booted in a virtual machine or accessed with kpartx
"""
+ img_format = 'raw'
def __init__(self, creatoropts=None, pkgmgr=None, compress_image=None, generate_bmap=None, fstab_entry="uuid"):
"""Initialize a ApplianceImageCreator instance.
write meta data
"""
self._resparse()
+ self.image_files.update({'disks': self.__disks.keys()})
+
+ if not (self.compress_image or self.pack_to):
+ for imgfile in os.listdir(self.__imgdir):
+ if imgfile.endswith('.raw'):
+ for disk in self.__disks.keys():
+ if imgfile.find(disk) != -1:
+ self.image_files.setdefault(disk, {}).update(
+ {'image': imgfile})
+ self.image_files.setdefault('image_files',
+ []).append(imgfile)
if self.compress_image:
for imgfile in os.listdir(self.__imgdir):
imgpath = os.path.join(self.__imgdir, imgfile)
msger.info("Compressing image %s" % imgfile)
misc.compressing(imgpath, self.compress_image)
+ if imgfile.endswith('.raw') and not self.pack_to:
+ for disk in self.__disks.keys():
+ if imgfile.find(disk) != -1:
+ imgname = '%s.%s' % (imgfile, self.compress_image)
+ self.image_files.setdefault(disk, {}).update(
+ {'image': imgname})
+ self.image_files.setdefault('image_files',
+ []).append(imgname)
if self.pack_to:
dst = os.path.join(self._outdir, self.pack_to)
msger.info("Pack all raw images to %s" % dst)
misc.packing(dst, self.__imgdir)
+ self.image_files.update({'image_files': self.pack_to})
else:
msger.debug("moving disks to stage location")
for imgfile in os.listdir(self.__imgdir):
dst = os.path.join(self._outdir, imgfile)
msger.debug("moving %s to %s" % (src,dst))
shutil.move(src,dst)
+
self._write_image_xml()
def _write_image_xml(self):
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)
del creator
except BmapCreate.Error as err:
raise CreatorError("Failed to create bmap file: %s" % str(err))
+
+ def create_manifest(self):
+ if self.compress_image:
+ self.image_files.update({'compress': self.compress_image})
+ super(RawImageCreator, self).create_manifest()
creator.copy_kernel()
creator.unmount()
creator.package(creatoropts["destdir"])
+ creator.create_manifest()
if creatoropts['release'] is not None:
creator.release_output(ksconf, creatoropts['destdir'],
creatoropts['release'])
creator.copy_kernel()
creator.unmount()
creator.package(creatoropts["destdir"])
+ creator.create_manifest()
if creatoropts['release'] is not None:
creator.release_output(ksconf, creatoropts['destdir'], creatoropts['release'])
creator.print_outimage_info()
creator.copy_kernel()
creator.unmount()
creator.package(creatoropts["destdir"])
+ creator.create_manifest()
if creatoropts['release'] is not None:
creator.release_output(ksconf, creatoropts['destdir'], creatoropts['release'])
creator.print_outimage_info()
creator.copy_kernel()
creator.unmount()
creator.package(creatoropts["destdir"])
+ creator.create_manifest()
if creatoropts['release'] is not None:
creator.release_output(ksconf,
creator.unmount()
creator.generate_bmap()
creator.package(creatoropts["destdir"])
+ creator.create_manifest()
if creatoropts['release'] is not None:
creator.release_output(ksconf, creatoropts['destdir'], creatoropts['release'])
creator.print_outimage_info()