Python utils.PathHelper类代码示例

 def test_find_pythoon(self):
     assert PathHelper.find_first_dir_with_file("dir1", "pythooon") == os.path.abspath(
         os.path.dirname(self.files[4])
     )
     assert PathHelper.find_first_dir_with_file(os.path.curdir, "py*n") == os.path.abspath(
         os.path.dirname(self.files[4])
     )
     assert PathHelper.find_first_dir_with_file("dir1/bar", "pythooon") is None

 def test_find_file(self):
     assert PathHelper.find_first_dir_with_file("dir1", "file") == os.path.abspath(
         os.path.dirname(self.files[9])
     )
     assert PathHelper.find_first_dir_with_file(os.path.curdir, "file") == os.path.abspath(
         os.path.dirname(self.files[0])
     )
     assert PathHelper.find_first_dir_with_file("dir1/baz", "file") is None

 def test_find_ffile(self):
     assert PathHelper.find_first_dir_with_file(
         "dir1", "*le") == os.path.abspath(
         os.path.dirname(self.files[9]))
     assert PathHelper.find_first_dir_with_file(
         "dir1", "ff*") == os.path.abspath(
         os.path.dirname(self.files[8]))
     assert PathHelper.find_first_dir_with_file(
         "dir1/foo", "ff*") is None

    def _do_build_srpm(cls, spec, workdir, results_dir):
        """
        Build SRPM using rpmbuild.

        :param spec: abs path to SPEC file inside the rpmbuild/SPECS in workdir.
        :param workdir: abs path to working directory with rpmbuild directory
                        structure, which will be used as HOME dir.
        :param results_dir: abs path to dir where the log should be placed.
        :return: If build process ends successfully returns abs path
                 to built SRPM, otherwise 'None'.
        """
        logger.info("Building SRPM")
        spec_loc, spec_name = os.path.split(spec)
        output = os.path.join(results_dir, "build.log")

        cmd = ['rpmbuild', '-bs', spec_name]
        ret = ProcessHelper.run_subprocess_cwd_env(cmd,
                                                   cwd=spec_loc,
                                                   env={'HOME': workdir},
                                                   output=output)

        if ret != 0:
            return None
        else:
            return PathHelper.find_first_file(workdir, '*.src.rpm')

 def _get_spec_file(self):
     """
     Function gets the spec file from the execution_dir directory
     """
     self.spec_file_path = PathHelper.find_first_file(self.execution_dir, '*.spec', 0)
     if not self.spec_file_path:
         raise RebaseHelperError("Could not find any SPEC file in the current directory '%s'", self.execution_dir)

    def build(cls, spec, sources, patches, results_dir, root=None, arch=None, **kwargs):
        """
        Builds the SRPM and RPM using mock

        :param spec: absolute path to a SPEC file
        :param sources: list with absolute paths to SOURCES
        :param patches: list with absolute paths to PATCHES
        :param results_dir: absolute path to directory where results will be stored
        :param root: mock root used for building
        :param arch: architecture to build the RPM for
        :return: dict with:
                 'srpm' -> absolute path to SRPM
                 'rpm' -> list with absolute paths to RPMs
                 'logs' -> list with absolute paths to logs
        """
        # build SRPM
        srpm, cls.logs = cls._build_srpm(spec, sources, patches, results_dir)

        # build RPMs
        rpm_results_dir = os.path.join(results_dir, "RPM")
        with MockTemporaryEnvironment(sources, patches, spec, rpm_results_dir) as tmp_env:
            env = tmp_env.env()
            tmp_results_dir = env.get(MockTemporaryEnvironment.TEMPDIR_RESULTS)
            rpms = cls._build_rpm(srpm, tmp_results_dir)
            # remove SRPM - side product of building RPM
            tmp_srpm = PathHelper.find_first_file(tmp_results_dir, "*.src.rpm")
            if tmp_srpm is not None:
                os.unlink(tmp_srpm)

        if rpms is None:
            # We need to be inform what directory to analyze and what spec file failed
            cls.logs.extend([l for l in PathHelper.find_all_files(rpm_results_dir, '*.log')])
            raise BinaryPackageBuildError("Building RPMs failed!", rpm_results_dir, spec)
        else:
            logger.info("Building RPMs finished successfully")

        rpms = [os.path.join(rpm_results_dir, os.path.basename(f)) for f in rpms]
        logger.debug("Successfully built RPMs: '%s'", str(rpms))

        # gather logs
        cls.logs.extend([l for l in PathHelper.find_all_files(rpm_results_dir, '*.log')])
        logger.debug("logs: '%s'", str(cls.logs))

        return {'srpm': srpm,
                'rpm': rpms,
                'logs': cls.logs}

    def _build_env_exit_callback(self, results_dir, **kwargs):
        """
        The function that is called just before the destruction of the TemporaryEnvironment.
        It copies packages and logs into the results directory.

        :param results_dir: absolute path to results directory
        :return: 
        """
        os.makedirs(results_dir)
        log_message = "Copying '%s' '%s' to '%s'"
        # copy logs
        for log in PathHelper.find_all_files(kwargs[self.TEMPDIR_RESULTS], '*.log'):
            logger.debug(log_message, 'log', log, results_dir)
            shutil.copy(log, results_dir)
        # copy packages
        for package in PathHelper.find_all_files(kwargs[self.TEMPDIR], '*.rpm'):
            logger.debug(log_message, 'package', package, results_dir)
            shutil.copy(package, results_dir)

    def run_check(cls, results_dir):
        """Compares old and new RPMs using pkgdiff"""
        csmock_report = {}

        old_pkgs = OutputLogger.get_old_build().get('srpm', None)
        new_pkgs = OutputLogger.get_new_build().get('srpm', None)
        csmock_dir = os.path.join(results_dir, cls.CMD)
        os.makedirs(csmock_dir)
        arguments = ['--force', '-a', '-r', 'fedora-rawhide-x86_64', '--base-srpm']
        if old_pkgs and new_pkgs:
            cmd = [cls.CMD]
            cmd.extend(arguments)
            cmd.append(old_pkgs)
            cmd.append(new_pkgs)
            cmd.extend(['-o', csmock_dir])
            output = StringIO()
            try:
                ProcessHelper.run_subprocess(cmd, output=output)
            except OSError:
                raise CheckerNotFoundError("Checker '%s' was not found or installed." % cls.CMD)
        csmock_report['error'] = PathHelper.find_all_files_current_dir(csmock_dir, '*.err')
        csmock_report['txt'] = PathHelper.find_all_files_current_dir(csmock_dir, '*.txt')
        csmock_report['log'] = PathHelper.find_all_files_current_dir(csmock_dir, '*.log')
        return csmock_report

    def _build_rpm(cls, srpm, results_dir, root=None, arch=None):
        """Build RPM using mock."""
        logger.info("Building RPMs")
        output = os.path.join(results_dir, "mock_output.log")

        cmd = [cls.CMD, '--rebuild', srpm, '--resultdir', results_dir]
        if root is not None:
            cmd.extend(['--root', root])
        if arch is not None:
            cmd.extend(['--arch', arch])

        ret = ProcessHelper.run_subprocess(cmd, output=output)

        if ret != 0:
            return None
        else:
            return [f for f in PathHelper.find_all_files(results_dir, '*.rpm') if not f.endswith('.src.rpm')]

    def _build_srpm(cls, spec, sources, results_dir, root=None, arch=None):
        """Build SRPM using mock."""
        logger.info("Building SRPM")
        output = os.path.join(results_dir, "mock_output.log")

        cmd = [cls.CMD, '--buildsrpm', '--spec', spec, '--sources', sources,
               '--resultdir', results_dir]
        if root is not None:
            cmd.extend(['--root', root])
        if arch is not None:
            cmd.extend(['--arch', arch])

        ret = ProcessHelper.run_subprocess(cmd, output=output)
        if ret != 0:
            return None
        else:
            return PathHelper.find_first_file(results_dir, '*.src.rpm')

 def get_rpm_packages(self, dirname):
     """
     Function returns RPM packages stored in dirname/old and dirname/new directories
     :param dirname: directory where are stored old and new RPMS
     :return:
     """
     found = True
     for version in ['old', 'new']:
         data = {}
         data['name'] = self.spec_file.get_package_name()
         if version == 'old':
             spec_version = self.spec_file.get_version()
         else:
             spec_version = self.rebase_spec_file.get_version()
         data['version'] = spec_version
         data['rpm'] = PathHelper.find_all_files(os.path.join(os.path.realpath(dirname), version, 'RPM'), '*.rpm')
         if not data['rpm']:
             logger.error('Your path %s%s/RPM does not contain any RPM packages' % (dirname, version))
             found = False
         OutputLogger.set_build_data(version, data)
     if not found:
         return False
     return True

 def test_find_without_recursion(self):
     assert PathHelper.find_first_file(os.path.curdir, "*.spec") == os.path.abspath(self.files[-1])

 def test_find_with_recursion(self):
     assert PathHelper.find_first_file(os.path.curdir, "*.spec", 0) is None
     assert PathHelper.find_first_file(os.path.curdir, "*.spec", 1) is None
     assert PathHelper.find_first_file(os.path.curdir, "*.spec", 2) is None
     assert PathHelper.find_first_file(os.path.curdir, "*.spec", 3) is None
     assert PathHelper.find_first_file(os.path.curdir, "*.spec", 4) == os.path.abspath(self.files[-1])