def pre_run(self):
self._output.output("[%s|%s] %s" % (
blue("ChrootHandler"), darkred(self.spec_name),
_("executing pre_run"),
)
)
# run outer chroot script
exec_script = self.metadata.get('outer_chroot_script')
if exec_script:
env = os.environ.copy()
env['CHROOT_DIR'] = self.source_dir
self._output.output("[%s|%s] %s: %s" % (
blue("ChrootHandler"), darkred(self.spec_name),
_("spawning"), " ".join(exec_script),
)
)
rc = molecule.utils.exec_cmd(exec_script, env=env)
if rc != 0:
self._output.output("[%s|%s] %s: %s" % (
blue("ChrootHandler"), darkred(self.spec_name),
_("outer chroot hook failed"), rc,
)
)
return rc
return 0
def _fill_image_file(self):
"""
Fill image file (using _tmp_loop_device_fd) with either zeroes or
random data of image_mb size.
@raises IOError: if space is not enough
@raises OSError: well, sorry
"""
if self.randomize:
self._output.output("[%s|%s] %s => %s" % (
blue("ImageHandler"),
darkred(self.spec_name),
_("generating random base image file"),
self.tmp_loop_device_file,
))
else:
self._output.output("[%s|%s] %s => %s" % (
blue("ImageHandler"),
darkred(self.spec_name),
_("generating zeroed base image file"),
self.tmp_loop_device_file,
))
image_mb = self.image_mb
loop_f = os.fdopen(self._tmp_loop_device_fd, "wb")
self._tmp_loop_device_fd = None
arr = None
mb_bytes = ImageHandler.MB_IN_BYTES
while image_mb > 0:
image_mb -= 1
if self.randomize:
arr = array.array('c', os.urandom(mb_bytes))
else:
arr = array.array('c', chr(0) * mb_bytes)
arr.tofile(loop_f)
del arr
gc.collect()
# file self._tmp_loop_device_fd is closed here.
# no more writes needed
loop_f.flush()
loop_f.close()
# last but not least, tell the loop device that the file size changed
args = [ImageHandler.LOSETUP_EXEC, "-c", self.loop_device]
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"),
darkred(self.spec_name),
_("spawning"),
" ".join(args),
))
rc = molecule.utils.exec_cmd(args)
if rc != 0:
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"),
darkred(self.spec_name),
_("image file resize failed"),
rc,
))
return rc
def post_run(self):
# run post tar script
exec_script = self.metadata.get('post_image_script')
if exec_script:
env = os.environ.copy()
env['IMAGE_NAME'] = self.image_name # self.metadata['image_name']
env['DESTINATION_IMAGE_DIR'] = self.dest_path
# self.metadata['destination_image_directory']
env['CHROOT_DIR'] = self.source_dir
env['IMAGE_PATH'] = self.dest_path
env['IMAGE_CHECKSUM_PATH'] = self.dest_path + \
FinalImageHandler.MD5_EXT
self._output.output("[%s|%s] %s: %s" % (
blue("FinalImageHandler"), darkred(self.spec_name),
_("spawning"), " ".join(exec_script),
)
)
rc = molecule.utils.exec_cmd(exec_script, env = env)
if rc != 0:
self._output.output("[%s|%s] %s: %s" % (
blue("FinalImageHandler"), darkred(self.spec_name),
_("post image hook failed"), rc,
)
)
return rc
return 0
def post_run(self):
self._output.output("[%s|%s] %s" % (
blue("ChrootHandler"), darkred(self.spec_name),
_("executing post_run"),
)
)
# run outer chroot script after
exec_script = self.metadata.get('outer_source_chroot_script_after')
if exec_script:
env = os.environ.copy()
env['IMAGE_NAME'] = self.metadata['image_name']
env['DESTINATION_IMAGE_DIR'] = \
self.metadata['destination_image_directory']
env['CHROOT_DIR'] = self.source_dir
self._output.output("[%s|%s] %s: %s" % (
blue("ChrootHandler"), darkred(self.spec_name),
_("spawning"), " ".join(exec_script),
)
)
rc = molecule.utils.exec_cmd(exec_script, env = env)
if rc != 0:
self._output.output("[%s|%s] %s: %s" % (
blue("ChrootHandler"), darkred(self.spec_name),
_("outer chroot hook (after inner) failed"), rc,
)
)
return rc
return 0
def pre_run(self):
self._output.output("[%s|%s] %s" % (
blue("ChrootHandler"),
darkred(self.spec_name),
_("executing pre_run"),
))
# run outer chroot script
exec_script = self.metadata.get('outer_chroot_script')
if exec_script:
env = os.environ.copy()
env['CHROOT_DIR'] = self.source_dir
self._output.output("[%s|%s] %s: %s" % (
blue("ChrootHandler"),
darkred(self.spec_name),
_("spawning"),
" ".join(exec_script),
))
rc = molecule.utils.exec_cmd(exec_script, env=env)
if rc != 0:
self._output.output("[%s|%s] %s: %s" % (
blue("ChrootHandler"),
darkred(self.spec_name),
_("outer chroot hook failed"),
rc,
))
return rc
return 0
def kill(self, success=True):
self._output.output("[%s|%s] %s" % (
blue("IsoUnpackHandler"), darkred(self.spec_name),
_("executing kill"),
)
)
if not success:
self._run_error_script(None, self.chroot_dir, self.dest_root)
rc = 0
if self.squash_mounted:
umounter = self.metadata.get('squash_umounter',
self._squash_umounter)
args = umounter + [self.tmp_squash_mount]
rc = molecule.utils.exec_cmd(args)
if rc == 0:
try:
os.rmdir(self.tmp_squash_mount)
except OSError:
self._output.output(
"[%s|%s] %s: %s" % (
blue("IsoUnpackHandler"), darkred(self.spec_name),
_("unable to remove temp. dir"), self.tmp_squash_mount,
)
)
rc = 0
if self.iso_mounted:
umounter = self.metadata.get('iso_umounter',
self._iso_umounter)
args = umounter + [self.tmp_mount]
rc = molecule.utils.exec_cmd(args)
if rc == 0:
try:
os.rmdir(self.tmp_mount)
except OSError:
# if not empty, skip
self._output.output(
"[%s|%s] %s: %s" % (
blue("IsoUnpackHandler"), darkred(self.spec_name),
_("unable to remove temp. dir"), self.tmp_mount,
)
)
if not success:
tmp_dir = self.metadata['chroot_tmp_dir']
if tmp_dir is not None:
try:
shutil.rmtree(tmp_dir, True)
except (shutil.Error, OSError,):
self._output.output("[%s|%s] %s: %s" % (
blue("IsoUnpackHandler"), darkred(self.spec_name),
_("unable to remove temp. dir"), tmp_dir,
)
)
return 0
def run(self):
self._output.output("[%s|%s] %s" % (
blue("MirrorHandler"),
darkred(self.spec_name),
_("mirroring running"),
))
# running sync
args = [self._mirror_syncer]
args.extend(self._mirror_syncer_builtin_args)
args.extend(self.metadata.get('extra_rsync_parameters', []))
args.append(self.source_dir + "/")
args.append(self.dest_dir + "/")
self._output.output("[%s|%s] %s: %s" % (
blue("MirrorHandler"),
darkred(self.spec_name),
_("spawning"),
" ".join(args),
))
rc = molecule.utils.exec_cmd(args)
if rc != 0:
self._output.output("[%s|%s] %s: %s" % (
blue("MirrorHandler"),
darkred(self.spec_name),
_("mirroring failed"),
rc,
))
return rc
self._output.output("[%s|%s] %s" % (
blue("MirrorHandler"),
darkred(self.spec_name),
_("mirroring completed successfully"),
))
return 0
def pre_run(self):
self._output.output("[%s|%s] %s" % (
blue("TarHandler"), darkred(self.spec_name),
_("executing pre_run"),
)
)
# run pre tar script
exec_script = self.metadata.get('pre_tar_script')
if exec_script:
env = os.environ.copy()
env['CHROOT_DIR'] = self.chroot_path
env['TAR_PATH'] = self.dest_path
env['TAR_CHECKSUM_PATH'] = self.dest_path + \
TarHandler.MD5_EXT
self._output.output("[%s|%s] %s: %s" % (
blue("TarHandler"), darkred(self.spec_name),
_("spawning"), " ".join(exec_script),
)
)
rc = molecule.utils.exec_cmd(exec_script, env=env)
if rc != 0:
self._output.output(
"[%s|%s] %s: %s" % (
blue("TarHandler"), darkred(self.spec_name),
_("pre tar hook failed"), rc,
)
)
return rc
return 0
def pre_run(self):
self._output.output("[%s|%s] %s" % (
blue("MirrorHandler"),
darkred(self.spec_name),
_("executing pre_run"),
))
exec_script = self.metadata.get('inner_source_chroot_script')
if exec_script:
if os.path.isfile(exec_script[0]) and \
os.access(exec_script[0], os.R_OK):
rc = self._exec_inner_script(exec_script, self.source_dir)
if rc != 0:
self._output.output("[%s|%s] %s: %s" % (
blue("MirrorHandler"),
darkred(self.spec_name),
_("inner_source_chroot_script failed"),
rc,
))
return rc
self._output.output("[%s|%s] %s" % (
blue("MirrorHandler"),
darkred(self.spec_name),
_("pre_run completed successfully"),
))
return 0
def post_run(self):
self._output.output("[%s|%s] %s" % (
blue("IsoHandler"),
darkred(self.spec_name),
_("executing post_run"),
))
# run post iso script
exec_script = self.metadata.get('post_iso_script')
if exec_script:
env = os.environ.copy()
env['ISO_PATH'] = self.dest_iso
env['ISO_CHECKSUM_PATH'] = self.dest_iso + IsoHandler.MD5_EXT
self._output.output("[%s|%s] %s: %s" % (
blue("IsoHandler"),
darkred(self.spec_name),
_("spawning"),
" ".join(exec_script),
))
rc = molecule.utils.exec_cmd(exec_script, env=env)
if rc != 0:
self._output.output("[%s|%s] %s: %s" % (
blue("IsoHandler"),
darkred(self.spec_name),
_("post iso hook failed"),
rc,
))
return rc
return 0
def run(self):
self._output.output("[%s|%s] %s" % (
blue("MirrorHandler"), darkred(self.spec_name),
_("mirroring running"),
)
)
# running sync
args = [self._mirror_syncer]
args.extend(self._mirror_syncer_builtin_args)
args.extend(self.metadata.get('extra_rsync_parameters', []))
args.append(self.source_dir + "/")
args.append(self.dest_dir + "/")
self._output.output("[%s|%s] %s: %s" % (
blue("MirrorHandler"), darkred(self.spec_name),
_("spawning"), " ".join(args),
)
)
rc = molecule.utils.exec_cmd(args)
if rc != 0:
self._output.output("[%s|%s] %s: %s" % (
blue("MirrorHandler"), darkred(self.spec_name),
_("mirroring failed"), rc,
)
)
return rc
self._output.output("[%s|%s] %s" % (
blue("MirrorHandler"), darkred(self.spec_name),
_("mirroring completed successfully"),
)
)
return 0
def post_run(self):
self._output.output("[%s|%s] %s" % (
blue("ChrootHandler"), darkred(self.spec_name),
_("executing post_run"),
)
)
# run outer chroot script after
exec_script = self.metadata.get('outer_source_chroot_script_after')
if exec_script:
env = os.environ.copy()
env['IMAGE_NAME'] = self.metadata['image_name']
env['DESTINATION_IMAGE_DIR'] = \
self.metadata['destination_image_directory']
env['CHROOT_DIR'] = self.source_dir
self._output.output("[%s|%s] %s: %s" % (
blue("ChrootHandler"), darkred(self.spec_name),
_("spawning"), " ".join(exec_script),
)
)
rc = molecule.utils.exec_cmd(exec_script, env=env)
if rc != 0:
self._output.output("[%s|%s] %s: %s" % (
blue("ChrootHandler"), darkred(self.spec_name),
_("outer chroot hook (after inner) failed"), rc,
)
)
return rc
return 0
def post_run(self):
# run post tar script
exec_script = self.metadata.get('post_image_script')
if exec_script:
env = os.environ.copy()
env['IMAGE_NAME'] = self.image_name # self.metadata['image_name']
env['DESTINATION_IMAGE_DIR'] = self.dest_path
# self.metadata['destination_image_directory']
env['CHROOT_DIR'] = self.source_dir
env['IMAGE_PATH'] = self.dest_path
env['IMAGE_CHECKSUM_PATH'] = self.dest_path + \
FinalImageHandler.MD5_EXT
self._output.output("[%s|%s] %s: %s" % (
blue("FinalImageHandler"), darkred(self.spec_name),
_("spawning"), " ".join(exec_script),
)
)
rc = molecule.utils.exec_cmd(exec_script, env=env)
if rc != 0:
self._output.output("[%s|%s] %s: %s" % (
blue("FinalImageHandler"), darkred(self.spec_name),
_("post image hook failed"), rc,
)
)
return rc
return 0
def post_run(self):
self._output.output("[%s|%s] %s" % (
blue("IsoHandler"), darkred(self.spec_name),
_("executing post_run"),
)
)
# run post iso script
exec_script = self.metadata.get('post_iso_script')
if exec_script:
env = os.environ.copy()
env['ISO_PATH'] = self.dest_iso
env['ISO_CHECKSUM_PATH'] = self.dest_iso + IsoHandler.MD5_EXT
self._output.output("[%s|%s] %s: %s" % (
blue("IsoHandler"), darkred(self.spec_name),
_("spawning"), " ".join(exec_script),
)
)
rc = molecule.utils.exec_cmd(exec_script, env=env)
if rc != 0:
self._output.output("[%s|%s] %s: %s" % (
blue("IsoHandler"), darkred(self.spec_name),
_("post iso hook failed"), rc,
)
)
return rc
return 0
def pre_run(self):
self._output.output("[%s|%s] %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("executing pre_run"),
)
)
# run pre image script
exec_script = self.metadata.get('pre_image_script')
if exec_script:
env = os.environ.copy()
env['IMAGE_NAME'] = self.metadata['image_name']
env['DESTINATION_IMAGE_DIR'] = \
self.metadata['destination_image_directory']
env['CHROOT_DIR'] = self.source_dir
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("spawning"), " ".join(exec_script),
)
)
rc = molecule.utils.exec_cmd(exec_script, env=env)
if rc != 0:
self._output.output(
"[%s|%s] %s: %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("pre image hook failed"), rc,
)
)
return rc
return 0
def pre_run(self):
self._output.output("[%s|%s] %s" % (
blue("ImageHandler"),
darkred(self.spec_name),
_("executing pre_run"),
))
# run pre image script
exec_script = self.metadata.get('pre_image_script')
if exec_script:
env = os.environ.copy()
env['TMP_IMAGE_PATH'] = self.tmp_loop_device_file
env['LOOP_DEVICE'] = self.loop_device
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"),
darkred(self.spec_name),
_("spawning"),
" ".join(exec_script),
))
rc = molecule.utils.exec_cmd(exec_script, env=env)
if rc != 0:
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"),
darkred(self.spec_name),
_("pre image hook failed"),
rc,
))
return rc
return 0
def pre_run(self):
self._output.output("[%s|%s] %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("executing pre_run"),
)
)
# run pre image script
exec_script = self.metadata.get('pre_image_script')
if exec_script:
env = os.environ.copy()
env['IMAGE_NAME'] = self.metadata['image_name']
env['DESTINATION_IMAGE_DIR'] = \
self.metadata['destination_image_directory']
env['CHROOT_DIR'] = self.source_dir
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("spawning"), " ".join(exec_script),
)
)
rc = molecule.utils.exec_cmd(exec_script, env = env)
if rc != 0:
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("pre image hook failed"), rc,
)
)
return rc
return 0
def pre_run(self):
self._output.output("[%s|%s] %s" % (
blue("TarHandler"),
darkred(self.spec_name),
_("executing pre_run"),
))
# run pre tar script
exec_script = self.metadata.get('pre_tar_script')
if exec_script:
env = os.environ.copy()
env['CHROOT_DIR'] = self.chroot_path
env['TAR_PATH'] = self.dest_path
env['TAR_CHECKSUM_PATH'] = self.dest_path + \
TarHandler.MD5_EXT
self._output.output("[%s|%s] %s: %s" % (
blue("TarHandler"),
darkred(self.spec_name),
_("spawning"),
" ".join(exec_script),
))
rc = molecule.utils.exec_cmd(exec_script, env=env)
if rc != 0:
self._output.output("[%s|%s] %s: %s" % (
blue("TarHandler"),
darkred(self.spec_name),
_("pre tar hook failed"),
rc,
))
return rc
return 0
def pre_run(self):
self._output.output("[%s|%s] %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("executing pre_run"),
)
)
# run pre image script
exec_script = self.metadata.get('pre_image_script')
if exec_script:
env = os.environ.copy()
env['TMP_IMAGE_PATH'] = self.tmp_loop_device_file
env['LOOP_DEVICE'] = self.loop_device
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("spawning"), " ".join(exec_script),
)
)
rc = molecule.utils.exec_cmd(exec_script, env=env)
if rc != 0:
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("pre image hook failed"), rc,
)
)
return rc
return 0
def pre_run(self):
self._output.output("[%s|%s] %s" % (
blue("MirrorHandler"), darkred(self.spec_name),
_("executing pre_run"),
)
)
exec_script = self.metadata.get('inner_source_chroot_script')
if exec_script:
if os.path.isfile(exec_script[0]) and \
os.access(exec_script[0], os.R_OK):
rc = self._exec_inner_script(exec_script, self.source_dir)
if rc != 0:
self._output.output("[%s|%s] %s: %s" % (
blue("MirrorHandler"), darkred(self.spec_name),
_("inner_source_chroot_script failed"), rc,
)
)
return rc
self._output.output("[%s|%s] %s" % (
blue("MirrorHandler"), darkred(self.spec_name),
_("pre_run completed successfully"),
)
)
return 0
def _fill_image_file(self):
"""
Fill image file (using _tmp_loop_device_fd) with either zeroes or
random data of image_mb size.
@raises IOError: if space is not enough
@raises OSError: well, sorry
"""
if self.randomize:
self._output.output("[%s|%s] %s => %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("generating random base image file"),
self.tmp_loop_device_file,
)
)
else:
self._output.output("[%s|%s] %s => %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("generating zeroed base image file"),
self.tmp_loop_device_file,
)
)
image_mb = self.image_mb
loop_f = os.fdopen(self._tmp_loop_device_fd, "wb")
self._tmp_loop_device_fd = None
arr = None
mb_bytes = ImageHandler.MB_IN_BYTES
while image_mb > 0:
image_mb -= 1
if self.randomize:
arr = array.array('c', os.urandom(mb_bytes))
else:
arr = array.array('c', chr(0)*mb_bytes)
arr.tofile(loop_f)
del arr
gc.collect()
# file self._tmp_loop_device_fd is closed here.
# no more writes needed
loop_f.flush()
loop_f.close()
# last but not least, tell the loop device that the file size changed
args = [ImageHandler.LOSETUP_EXEC, "-c", self.loop_device]
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("spawning"), " ".join(args),
)
)
rc = molecule.utils.exec_cmd(args)
if rc != 0:
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("image file resize failed"), rc,
)
)
return rc
def setup(self):
self.image_mb = self.metadata['image_mb']
if self.metadata.get('image_randomize') == "yes":
self.randomize = True
sts, loop_device = molecule.utils.exec_cmd_get_status_output(
[ImageHandler.LOSETUP_EXEC, "-f"])
if sts != 0:
# ouch
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"),
darkred(self.spec_name),
_("setup hook failed"),
_("cannot setup loop device"),
))
return sts
try:
self._tmp_loop_device_fd, self.tmp_loop_device_file = \
tempfile.mkstemp(prefix="molecule", dir=self._config['tmp_dir'])
except (
OSError,
IOError,
):
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"),
darkred(self.spec_name),
_("setup hook failed"),
_("cannot create temporary file"),
))
return 1
# bind loop device
args = [
ImageHandler.LOSETUP_EXEC, loop_device, self.tmp_loop_device_file
]
rc = molecule.utils.exec_cmd(args)
if rc != 0:
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"),
darkred(self.spec_name),
_("setup hook failed"),
_("cannot bind loop device"),
))
return 1
self.loop_device = loop_device
self.tmp_image_mount = molecule.utils.mkdtemp()
# setup metadata for next phases
self.metadata['ImageHandler_loop_device_file'] = \
self.tmp_loop_device_file
self.metadata['ImageHandler_tmp_image_mount'] = self.tmp_image_mount
self.metadata['ImageHandler_loop_device'] = self.loop_device
self.metadata['ImageHandler_kill_loop_device'] = self._kill_loop_device
return 0
def _kill_loop_device(self, preserve_loop_device_file=False):
kill_rc = 0
if self.image_mounted:
umounter = self.metadata.get(
'image_umounter',
ImageHandler.DEFAULT_IMAGE_UMOUNTER
)
args = umounter + [self.tmp_image_mount]
rc = molecule.utils.exec_cmd(args)
if rc != 0:
self._output.output(
"[%s|%s] %s: %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("unable to umount loop device"), self.loop_device,
)
)
kill_rc = rc
else:
self.image_mounted = False
if self.tmp_image_mount is not None:
try:
os.rmdir(self.tmp_image_mount)
except OSError:
pass
# kill loop device
if self.loop_device is not None:
rc = molecule.utils.exec_cmd([ImageHandler.LOSETUP_EXEC, "-d",
self.loop_device])
if rc != 0:
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("unable to kill loop device"), self.loop_device,
)
)
kill_rc = rc
else:
self.loop_device = None
if (self.tmp_loop_device_file is not None) and \
(not preserve_loop_device_file):
try:
os.remove(self.tmp_loop_device_file)
self.tmp_loop_device_file = None
except OSError as err:
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("unable to remove temp. loop device file"),
err,
)
)
kill_rc = 1
return kill_rc
def _kill_loop_device(self, preserve_loop_device_file=False):
kill_rc = 0
if self.image_mounted:
umounter = self.metadata.get('image_umounter',
ImageHandler.DEFAULT_IMAGE_UMOUNTER)
args = umounter + [self.tmp_image_mount]
rc = molecule.utils.exec_cmd(args)
if rc != 0:
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"),
darkred(self.spec_name),
_("unable to umount loop device"),
self.loop_device,
))
kill_rc = rc
else:
self.image_mounted = False
if self.tmp_image_mount is not None:
try:
os.rmdir(self.tmp_image_mount)
except OSError:
pass
# kill loop device
if self.loop_device is not None:
rc = molecule.utils.exec_cmd(
[ImageHandler.LOSETUP_EXEC, "-d", self.loop_device])
if rc != 0:
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"),
darkred(self.spec_name),
_("unable to kill loop device"),
self.loop_device,
))
kill_rc = rc
else:
self.loop_device = None
if (self.tmp_loop_device_file is not None) and \
(not preserve_loop_device_file):
try:
os.remove(self.tmp_loop_device_file)
self.tmp_loop_device_file = None
except OSError as err:
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"),
darkred(self.spec_name),
_("unable to remove temp. loop device file"),
err,
))
kill_rc = 1
return kill_rc
def run(self):
self._output.output("[%s|%s] %s" % (
blue("IsoHandler"),
darkred(self.spec_name),
_("building ISO image"),
))
args = [self._iso_builder]
args.extend(self._iso_builder_builtin_args)
args.extend(self.metadata.get('extra_mkisofs_parameters', []))
if self.iso_title.strip():
args.extend(["-V", self.iso_title[:32]])
args.extend(['-o', self.dest_iso, self.source_path])
self._output.output("[%s|%s] %s: %s" % (
blue("IsoHandler"),
darkred(self.spec_name),
_("spawning"),
" ".join(args),
))
rc = molecule.utils.exec_cmd(args)
if rc != 0:
self._output.output("[%s|%s] %s: %s" % (
blue("IsoHandler"),
darkred(self.spec_name),
_("ISO image build failed"),
rc,
))
return rc
self._output.output("[%s|%s] %s: %s" % (
blue("IsoHandler"),
darkred(self.spec_name),
_("built ISO image"),
self.dest_iso,
))
if os.path.isfile(self.dest_iso) and os.access(self.dest_iso, os.R_OK):
self._output.output("[%s|%s] %s: %s" % (
blue("IsoHandler"),
darkred(self.spec_name),
_("generating md5 for"),
self.dest_iso,
))
digest = molecule.utils.md5sum(self.dest_iso)
md5file = self.dest_iso + IsoHandler.MD5_EXT
with open(md5file, "w") as f:
f.write("%s %s\n" % (
digest,
os.path.basename(self.dest_iso),
))
f.flush()
return 0
def pre_run(self):
self._output.output("[%s|%s] %s" % (
blue("CdrootHandler"), darkred(self.spec_name),
_("executing pre_run"),
)
)
self._output.output("[%s|%s] %s" % (
blue("CdrootHandler"), darkred(self.spec_name),
_("preparing environment"),
)
)
return 0
def pre_run(self):
self._output.output("[%s|%s] %s" % (
blue("CdrootHandler"),
darkred(self.spec_name),
_("executing pre_run"),
))
self._output.output("[%s|%s] %s" % (
blue("CdrootHandler"),
darkred(self.spec_name),
_("preparing environment"),
))
return 0
def setup(self):
self.image_mb = self.metadata['image_mb']
if self.metadata.get('image_randomize') == "yes":
self.randomize = True
sts, loop_device = molecule.utils.exec_cmd_get_status_output(
[ImageHandler.LOSETUP_EXEC, "-f"])
if sts != 0:
# ouch
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("setup hook failed"), _("cannot setup loop device"),
)
)
return sts
try:
self._tmp_loop_device_fd, self.tmp_loop_device_file = \
tempfile.mkstemp(prefix="molecule", dir=self._config['tmp_dir'])
except (OSError, IOError,):
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("setup hook failed"), _("cannot create temporary file"),
)
)
return 1
# bind loop device
args = [ImageHandler.LOSETUP_EXEC, loop_device,
self.tmp_loop_device_file]
rc = molecule.utils.exec_cmd(args)
if rc != 0:
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("setup hook failed"), _("cannot bind loop device"),
)
)
return 1
self.loop_device = loop_device
self.tmp_image_mount = molecule.utils.mkdtemp()
# setup metadata for next phases
self.metadata['ImageHandler_loop_device_file'] = \
self.tmp_loop_device_file
self.metadata['ImageHandler_tmp_image_mount'] = self.tmp_image_mount
self.metadata['ImageHandler_loop_device'] = self.loop_device
self.metadata['ImageHandler_kill_loop_device'] = self._kill_loop_device
return 0
def post_run(self):
self._output.output("[%s|%s] %s" % (
blue("CdrootHandler"), darkred(self.spec_name),
_("executing post_run"),
)
)
return 0
def _run_error_script(self,
source_chroot_dir,
chroot_dir,
cdroot_dir,
env=None):
error_script = self.metadata.get('error_script')
if error_script:
if env is None:
env = os.environ.copy()
else:
env = env.copy()
if source_chroot_dir:
env['SOURCE_CHROOT_DIR'] = source_chroot_dir
if chroot_dir:
env['CHROOT_DIR'] = chroot_dir
if cdroot_dir:
env['CDROOT_DIR'] = cdroot_dir
self._output.output("[%s|%s] %s: %s" % (
blue("BuiltinHandler"),
darkred(self.spec_name),
_("spawning"),
" ".join(error_script),
))
molecule.utils.exec_cmd(error_script, env=env)
def post_run(self):
self._output.output("[%s|%s] %s" % (
blue("CdrootHandler"),
darkred(self.spec_name),
_("executing post_run"),
))
return 0
def run(self):
self._output.output("[%s|%s] %s: %s => %s" % (
blue("IsoUnpackHandler"), darkred(self.spec_name),
_("iso unpacker running"), self.tmp_squash_mount,
self.metadata['chroot_unpack_path'],
)
)
def dorm():
if self.metadata['chroot_tmp_dir'] is not None:
shutil.rmtree(self.metadata['chroot_tmp_dir'], True)
# create chroot path
try:
rc = molecule.utils.copy_dir(self.tmp_squash_mount,
self.metadata['chroot_unpack_path'])
except:
dorm()
raise
if rc != 0:
dorm()
return rc
def run(self):
self._output.output("[%s|%s] %s: %s => %s" % (
blue("IsoUnpackHandler"), darkred(self.spec_name),
_("iso unpacker running"), self.tmp_squash_mount,
self.metadata['chroot_unpack_path'],
)
)
def dorm():
if self.metadata['chroot_tmp_dir'] is not None:
shutil.rmtree(self.metadata['chroot_tmp_dir'], True)
# create chroot path
try:
rc = molecule.utils.copy_dir(self.tmp_squash_mount,
self.metadata['chroot_unpack_path'])
except Exception:
dorm()
raise
if rc != 0:
dorm()
return rc
def run(self):
self._output.output("[%s|%s] %s: %s => %s" % (
blue("ImageIsoUnpackHandler"), darkred(self.spec_name),
_("iso unpacker running"), self.tmp_squash_mount,
self.metadata['chroot_unpack_path'],
)
)
def dorm():
if self.metadata['chroot_tmp_dir'] is not None:
shutil.rmtree(self.metadata['chroot_tmp_dir'], True)
# copy data into chroot, in our case, destination dir already
# exists, so copy_dir() is a bit tricky
try:
rc = molecule.utils.copy_dir_existing_dest(
self.tmp_squash_mount,
self.metadata['chroot_unpack_path']
)
except Exception:
dorm()
raise
if rc != 0:
dorm()
return rc
def run(self):
self._output.output("[%s|%s] %s: %s => %s" % (
blue("ImageIsoUnpackHandler"),
darkred(self.spec_name),
_("iso unpacker running"),
self.tmp_squash_mount,
self.metadata['chroot_unpack_path'],
))
def dorm():
if self.metadata['chroot_tmp_dir'] is not None:
shutil.rmtree(self.metadata['chroot_tmp_dir'], True)
# copy data into chroot, in our case, destination dir already
# exists, so copy_dir() is a bit tricky
try:
rc = molecule.utils.copy_dir_existing_dest(
self.tmp_squash_mount, self.metadata['chroot_unpack_path'])
except Exception:
dorm()
raise
if rc != 0:
dorm()
return rc
def run(self):
self._output.output("[%s|%s] %s" % (
blue("IsoHandler"), darkred(self.spec_name),
_("building ISO image"),
)
)
args = [self._iso_builder]
args.extend(self._iso_builder_builtin_args)
args.extend(self.metadata.get('extra_mkisofs_parameters', []))
if self.iso_title.strip():
args.extend(["-V", self.iso_title[:32]])
args.extend(['-o', self.dest_iso, self.source_path])
self._output.output("[%s|%s] %s: %s" % (
blue("IsoHandler"), darkred(self.spec_name),
_("spawning"), " ".join(args),
)
)
rc = molecule.utils.exec_cmd(args)
if rc != 0:
self._output.output("[%s|%s] %s: %s" % (
blue("IsoHandler"), darkred(self.spec_name),
_("ISO image build failed"), rc,
)
)
return rc
self._output.output("[%s|%s] %s: %s" % (
blue("IsoHandler"), darkred(self.spec_name),
_("built ISO image"), self.dest_iso,
)
)
if os.path.isfile(self.dest_iso) and os.access(self.dest_iso, os.R_OK):
self._output.output("[%s|%s] %s: %s" % (
blue("IsoHandler"), darkred(self.spec_name),
_("generating md5 for"), self.dest_iso,
)
)
digest = molecule.utils.md5sum(self.dest_iso)
md5file = self.dest_iso + IsoHandler.MD5_EXT
with open(md5file, "w") as f:
f.write("%s %s\n" % (digest, os.path.basename(self.dest_iso),))
f.flush()
return 0
def run(self):
self._output.output("[%s|%s] %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("run hook called"),
)
)
# run pre image script
oexec_script = self.metadata.get('image_generator_script')
if oexec_script:
exec_script = oexec_script + [
self._tmp_image_file, str(self.metadata['image_mb']),
self.metadata['source_boot_directory'],
self.metadata['source_chroot']]
env = os.environ.copy()
env['PATHS_TO_REMOVE'] = ";".join(
self.metadata.get('paths_to_remove', []))
env['PATHS_TO_EMPTY'] = ";".join(
self.metadata.get('paths_to_empty', []))
env['RELEASE_STRING'] = self.metadata['release_string']
env['RELEASE_VERSION'] = self.metadata['release_version']
env['RELEASE_DESC'] = self.metadata['release_desc']
env['RELEASE_FILE'] = self.metadata['release_file']
env['IMAGE_NAME'] = self.metadata['image_name']
env['PACKAGES_TO_ADD'] = " ".join(self.metadata.get('packages_to_add', []))
env['PACKAGES_TO_REMOVE'] = " ".join(self.metadata.get('packages_to_remove', []))
env['DESTINATION_IMAGE_DIR'] = \
self.metadata['destination_image_directory']
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("spawning"), " ".join(exec_script),
)
)
rc = molecule.utils.exec_cmd(exec_script, env=env)
if rc != 0:
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("image hook failed"), rc,
)
)
return rc
return 0
def run(self):
self._output.output("[%s|%s] %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("run hook called"),
)
)
# run pre image script
oexec_script = self.metadata.get('image_generator_script')
if oexec_script:
exec_script = oexec_script + [
self._tmp_image_file, str(self.metadata['image_mb']),
self.metadata['source_boot_directory'],
self.metadata['source_chroot']]
env = os.environ.copy()
env['PATHS_TO_REMOVE'] = ";".join(
self.metadata.get('paths_to_remove', []))
env['PATHS_TO_EMPTY'] = ";".join(
self.metadata.get('paths_to_empty', []))
env['RELEASE_STRING'] = self.metadata['release_string']
env['RELEASE_VERSION'] = self.metadata['release_version']
env['RELEASE_DESC'] = self.metadata['release_desc']
env['RELEASE_FILE'] = self.metadata['release_file']
env['IMAGE_NAME'] = self.metadata['image_name']
env['PACKAGES_TO_ADD'] = " ".join(self.metadata.get('packages_to_add', []))
env['PACKAGES_TO_REMOVE'] = " ".join(self.metadata.get('packages_to_remove', []))
env['DESTINATION_IMAGE_DIR'] = \
self.metadata['destination_image_directory']
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("spawning"), " ".join(exec_script),
)
)
rc = molecule.utils.exec_cmd(exec_script, env = env)
if rc != 0:
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("image hook failed"), rc,
)
)
return rc
return 0
def kill(self, success=True):
if not success:
self._run_error_script(None, self.source_chroot, self.dest_root)
self._output.output("[%s|%s] %s" % (
blue("CdrootHandler"),
darkred(self.spec_name),
_("executing kill"),
))
return 0
def kill(self, success=True):
if not success:
self._run_error_script(self.source_dir, self.dest_dir, None)
self._output.output("[%s|%s] %s" % (
blue("ChrootHandler"),
darkred(self.spec_name), _("executing kill"),
)
)
return 0
def kill(self, success=True):
if not success:
self._run_error_script(self.source_dir, self.dest_dir, None)
self._output.output("[%s|%s] %s" % (
blue("MirrorHandler"),
darkred(self.spec_name),
_("executing kill"),
))
return 0
def run(self):
self._output.output("[%s|%s] %s => %s" % (
blue("TarHandler"),
darkred(self.spec_name),
_("compressing chroot"),
self.chroot_path,
))
dest_path_dir = os.path.dirname(self.dest_path)
if not os.path.isdir(dest_path_dir) and not \
os.path.lexists(dest_path_dir):
os.makedirs(dest_path_dir, 0o755)
current_dir = os.getcwd()
# change dir to chroot dir
os.chdir(self.chroot_path)
args = (TarHandler._TAR_EXEC, "cfp" + self._get_tar_comp_method(),
self.dest_path, ".", "--atime-preserve", "--numeric-owner")
rc = molecule.utils.exec_cmd(args)
os.chdir(current_dir)
if rc != 0:
self._output.output("[%s|%s] %s: %s" % (
blue("TarHandler"),
darkred(self.spec_name),
_("chroot compression failed"),
rc,
))
return rc
self._output.output("[%s|%s] %s: %s" % (
blue("TarHandler"),
darkred(self.spec_name),
_("generating md5 for"),
self.dest_path,
))
digest = molecule.utils.md5sum(self.dest_path)
md5file = self.dest_path + TarHandler.MD5_EXT
with open(md5file, "w") as f:
f.write("%s %s\n" % (
digest,
os.path.basename(self.dest_path),
))
f.flush()
return 0
def kill(self, success=True):
if not success:
self._run_error_script(self.source_chroot, self.chroot_dir,
self.source_path)
self._output.output("[%s|%s] %s" % (
blue("IsoHandler"),
darkred(self.spec_name),
_("executing kill"),
))
return 0
def run(self):
self._output.output("[%s|%s] %s: %s %s" % (
blue("FinalImageHandler"),
darkred(self.spec_name),
_("run hook called"),
_("moving image file to destination"),
self.dest_path,
))
try:
os.rename(self.tmp_loop_device_file, self.dest_path)
except OSError as err:
if err.errno != errno.EXDEV:
raise
# cannot move atomically, fallback to shutil.move
try:
shutil.move(self.tmp_loop_device_file, self.dest_path)
except shutil.Error:
raise
self._loop_device_file_removed = True
self._output.output("[%s|%s] %s: %s" % (
blue("FinalImageHandler"),
darkred(self.spec_name),
_("built image"),
self.dest_path,
))
if os.path.isfile(self.dest_path) and os.access(
self.dest_path, os.R_OK):
self._output.output("[%s|%s] %s: %s" % (
blue("FinalImageHandler"),
darkred(self.spec_name),
_("generating md5 for"),
self.dest_path,
))
digest = molecule.utils.md5sum(self.dest_path)
md5file = self.dest_path + FinalImageHandler.MD5_EXT
with open(md5file, "w") as f:
f.write("%s %s\n" % (
digest,
os.path.basename(self.dest_path),
))
f.flush()
def run(self):
self._output.output("[%s|%s] %s" % (
blue("ChrootHandler"), darkred(self.spec_name),
_("hooks running"),
)
)
# run inner chroot script
exec_script = self.metadata.get('inner_chroot_script')
if exec_script:
if os.path.isfile(exec_script[0]) and os.access(exec_script[0], os.R_OK):
rc = self._exec_inner_script(exec_script, self.dest_dir)
if rc != 0:
return rc
self._output.output("[%s|%s] %s" % (
blue("ChrootHandler"), darkred(self.spec_name),
_("hooks completed succesfully"),
)
)
return 0
def run(self):
self._output.output("[%s|%s] %s => %s" % (
blue("TarHandler"), darkred(self.spec_name),
_("compressing chroot"),
self.chroot_path,
)
)
dest_path_dir = os.path.dirname(self.dest_path)
if not os.path.isdir(dest_path_dir) and not \
os.path.lexists(dest_path_dir):
os.makedirs(dest_path_dir, 0o755)
current_dir = os.getcwd()
# change dir to chroot dir
os.chdir(self.chroot_path)
args = (TarHandler._TAR_EXEC, "cfp" + self._get_tar_comp_method(),
self.dest_path, ".", "--atime-preserve", "--numeric-owner")
rc = molecule.utils.exec_cmd(args)
os.chdir(current_dir)
if rc != 0:
self._output.output("[%s|%s] %s: %s" % (
blue("TarHandler"), darkred(self.spec_name),
_("chroot compression failed"), rc,
)
)
return rc
self._output.output("[%s|%s] %s: %s" % (
blue("TarHandler"), darkred(self.spec_name),
_("generating md5 for"), self.dest_path,
)
)
digest = molecule.utils.md5sum(self.dest_path)
md5file = self.dest_path + TarHandler.MD5_EXT
with open(md5file, "w") as f:
f.write("%s %s\n" % (digest, os.path.basename(self.dest_path),))
f.flush()
return 0
def run(self):
self._output.output("[%s|%s] %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("run hook called"),
)
)
# fill image file
try:
rc = self._fill_image_file()
if rc != 0:
return rc
except (IOError, OSError) as err:
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("image file generation failed"), err,
)
)
return 1
# format image file
image_formatter = self.metadata.get('image_formatter',
ImageHandler.DEFAULT_IMAGE_FORMATTER)
formatter_args = image_formatter + [self.loop_device]
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("spawning"), " ".join(formatter_args),
)
)
rc = molecule.utils.exec_cmd(formatter_args)
if rc != 0:
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("image formatter hook failed"), rc,
)
)
return rc
# mount image file
mounter = self.metadata.get('image_mounter',
ImageHandler.DEFAULT_IMAGE_MOUNTER)
mount_args = mounter + [self.loop_device, self.tmp_image_mount]
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("spawning"), " ".join(mount_args),
)
)
rc = molecule.utils.exec_cmd(mount_args)
if rc != 0:
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("image mount failed"), rc,
)
)
return rc
self.image_mounted = True
return 0
def run(self):
self._output.output("[%s|%s] %s" % (
blue("ChrootHandler"),
darkred(self.spec_name),
_("hooks running"),
))
# run inner chroot script
exec_script = self.metadata.get('inner_chroot_script')
if exec_script:
if os.path.isfile(exec_script[0]) and os.access(
exec_script[0], os.R_OK):
rc = self._exec_inner_script(exec_script, self.dest_dir)
if rc != 0:
return rc
self._output.output("[%s|%s] %s" % (
blue("ChrootHandler"),
darkred(self.spec_name),
_("hooks completed succesfully"),
))
return 0
def run(self):
self._output.output("[%s|%s] %s: %s %s" % (
blue("FinalImageHandler"), darkred(self.spec_name),
_("run hook called"), _("moving image file to destination"),
self.dest_path,
)
)
try:
os.rename(self.tmp_loop_device_file, self.dest_path)
except OSError as err:
if err.errno != errno.EXDEV:
raise
# cannot move atomically, fallback to shutil.move
try:
shutil.move(self.tmp_loop_device_file, self.dest_path)
except shutil.Error:
raise
self._loop_device_file_removed = True
self._output.output("[%s|%s] %s: %s" % (
blue("FinalImageHandler"), darkred(self.spec_name),
_("built image"), self.dest_path,
)
)
if os.path.isfile(self.dest_path) and os.access(self.dest_path, os.R_OK):
self._output.output("[%s|%s] %s: %s" % (
blue("FinalImageHandler"), darkred(self.spec_name),
_("generating md5 for"), self.dest_path,
)
)
digest = molecule.utils.md5sum(self.dest_path)
md5file = self.dest_path + FinalImageHandler.MD5_EXT
with open(md5file, "w") as f:
f.write("%s %s\n" % (digest,
os.path.basename(self.dest_path),))
f.flush()
def kill(self, success = True):
self._output.output("[%s|%s] %s" % (
blue("ImageChrootHandler"),
darkred(self.spec_name), _("executing kill"),
)
)
if not success:
env = os.environ.copy()
loop_device = self.metadata.get('ImageHandler_loop_device')
if loop_device is not None:
env["LOOP_DEVICE"] = loop_device
self._run_error_script(self.source_dir, self.dest_dir, None,
env = env)
self.metadata['ImageHandler_kill_loop_device']()
return 0
def kill(self, success=True):
self._output.output("[%s|%s] %s" % (
blue("ImageChrootHandler"),
darkred(self.spec_name),
_("executing kill"),
))
if not success:
env = os.environ.copy()
loop_device = self.metadata.get('ImageHandler_loop_device')
if loop_device is not None:
env["LOOP_DEVICE"] = loop_device
self._run_error_script(self.source_dir,
self.dest_dir,
None,
env=env)
self.metadata['ImageHandler_kill_loop_device']()
return 0
def kill(self, success = True):
# ImageHandler sets this
if not success:
self.metadata['ImageHandler_kill_loop_device']()
RemasterIsoUnpackHandler.kill(self, success = success)
# we don't need the whole dir
tmp_dir = self.metadata['chroot_tmp_dir']
if os.path.isdir(tmp_dir):
try:
shutil.rmtree(tmp_dir, True)
except (shutil.Error, OSError,):
self._output.output("[%s|%s] %s: %s" % (
blue("ImageIsoUnpackHandler"), darkred(self.spec_name),
_("unable to remove temp. dir"), tmp_dir,
)
)
return 0
def setup(self):
self.source_dir = self.metadata['source_chroot']
self.image_mb = self.metadata['image_mb']
try:
self._tmp_image_file_fd, self._tmp_image_file = \
tempfile.mkstemp(prefix="molecule",
dir=self._config['tmp_dir'],
suffix=".mmc_img")
except (OSError, IOError,):
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("setup hook failed"), _("cannot create temporary file"),
)
)
return 1
self.metadata['MmcImageHandler_image_file'] = self._tmp_image_file
return 0
def setup(self):
self.source_dir = self.metadata['source_chroot']
self.image_mb = self.metadata['image_mb']
try:
self._tmp_image_file_fd, self._tmp_image_file = \
tempfile.mkstemp(prefix = "molecule",
dir = self._config['tmp_dir'],
suffix=".mmc_img")
except (OSError, IOError,) as err:
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("setup hook failed"), _("cannot create temporary file"),
)
)
return 1
self.metadata['MmcImageHandler_image_file'] = self._tmp_image_file
return 0
def _exec_inner_script(self, exec_script, dest_chroot):
source_exec = exec_script[0]
with open(source_exec, "rb") as f_src:
tmp_fd, tmp_exec = tempfile.mkstemp(dir=dest_chroot,
prefix="molecule_inner")
f_dst = os.fdopen(tmp_fd, "wb")
try:
shutil.copyfileobj(f_src, f_dst)
finally:
f_dst.flush()
f_dst.close()
shutil.copystat(source_exec, tmp_exec)
os.chmod(tmp_exec, 0o744)
dest_exec = os.path.basename(tmp_exec)
if not dest_exec.startswith("/"):
dest_exec = "/%s" % (dest_exec,)
try:
rc = molecule.utils.exec_chroot_cmd(
[dest_exec] + exec_script[1:],
dest_chroot,
pre_chroot=self.metadata.get('prechroot', [])
)
except Exception:
# kill all the pids inside chroot, no matter what just happened
molecule.utils.kill_chroot_pids(dest_chroot, sleep=True)
raise
finally:
os.remove(tmp_exec)
if rc != 0:
molecule.utils.kill_chroot_pids(dest_chroot, sleep=True)
self._output.output("[%s|%s] %s: %s" % (
blue("BuiltinHandler"), darkred(self.spec_name),
_("inner chroot hook failed"), rc,
)
)
return rc
def _exec_inner_script(self, exec_script, dest_chroot):
source_exec = exec_script[0]
with open(source_exec, "rb") as f_src:
tmp_fd, tmp_exec = tempfile.mkstemp(dir=dest_chroot,
prefix="molecule_inner")
f_dst = os.fdopen(tmp_fd, "wb")
try:
shutil.copyfileobj(f_src, f_dst)
finally:
f_dst.flush()
f_dst.close()
shutil.copystat(source_exec, tmp_exec)
os.chmod(tmp_exec, 0o744)
dest_exec = os.path.basename(tmp_exec)
if not dest_exec.startswith("/"):
dest_exec = "/%s" % (dest_exec, )
try:
rc = molecule.utils.exec_chroot_cmd([dest_exec] + exec_script[1:],
dest_chroot,
pre_chroot=self.metadata.get(
'prechroot', []))
except Exception:
# kill all the pids inside chroot, no matter what just happened
molecule.utils.kill_chroot_pids(dest_chroot, sleep=True)
raise
finally:
os.remove(tmp_exec)
if rc != 0:
molecule.utils.kill_chroot_pids(dest_chroot, sleep=True)
self._output.output("[%s|%s] %s: %s" % (
blue("BuiltinHandler"),
darkred(self.spec_name),
_("inner chroot hook failed"),
rc,
))
return rc
def kill(self, success=True):
# kill tmp files
if self._tmp_loop_device_fd is not None:
try:
os.close(self._tmp_loop_device_fd)
except IOError as err:
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("unable to close temp fd"), err,
)
)
self._tmp_loop_device_fd = None
if not success:
env = os.environ.copy()
env["LOOP_DEVICE"] = self.loop_device
self._run_error_script(None, None, None, env=env)
self._kill_loop_device()
return 0
def kill(self, success = True):
# kill tmp files
if self._tmp_image_file_fd is not None:
try:
os.close(self._tmp_image_file_fd)
except IOError as err:
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"), darkred(self.spec_name),
_("unable to close temp fd"), err,
)
)
self._tmp_image_file_fd = None
if not success:
env = os.environ.copy()
self._run_error_script(None, None, None, env = env)
if self._tmp_image_file is not None:
os.remove(self._tmp_image_file)
self._tmp_image_file = None
return 0
def kill(self, success=True):
# kill tmp files
if self._tmp_loop_device_fd is not None:
try:
os.close(self._tmp_loop_device_fd)
except IOError as err:
self._output.output("[%s|%s] %s: %s" % (
blue("ImageHandler"),
darkred(self.spec_name),
_("unable to close temp fd"),
err,
))
self._tmp_loop_device_fd = None
if not success:
env = os.environ.copy()
env["LOOP_DEVICE"] = self.loop_device
self._run_error_script(None, None, None, env=env)
self._kill_loop_device()
return 0
