Пример #1
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
Пример #2
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
Пример #3
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
Пример #4
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
Пример #5
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
Пример #6
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
Пример #7
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
Пример #8
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
Пример #9
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
Пример #10
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
Пример #11
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
Пример #12
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
Пример #13
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
Пример #14
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
Пример #15
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
Пример #16
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
Пример #17
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
Пример #18
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
Пример #19
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
Пример #20
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
Пример #21
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
Пример #22
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
Пример #23
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
Пример #24
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
Пример #25
0
    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
Пример #26
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
Пример #27
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
Пример #28
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
Пример #29
0
 def post_run(self):
     self._output.output("[%s|%s] %s" % (
             blue("CdrootHandler"), darkred(self.spec_name),
             _("executing post_run"),
         )
     )
     return 0
Пример #30
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)
Пример #31
0
 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
Пример #33
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 Exception:
            dorm()
            raise

        if rc != 0:
            dorm()

        return rc
Пример #34
0
    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
Пример #35
0
    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
Пример #36
0
    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
Пример #37
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
Пример #38
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
Пример #39
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
Пример #40
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
Пример #41
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
Пример #42
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
Пример #43
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
Пример #44
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()
Пример #45
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
Пример #46
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
Пример #47
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
Пример #48
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
Пример #49
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()
Пример #50
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
Пример #51
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
Пример #52
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
Пример #53
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
Пример #54
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
Пример #55
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
Пример #56
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
Пример #57
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
Пример #58
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
Пример #59
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