def test_find_ffile(self, filelist): assert PathHelper.find_first_dir_with_file( "dir1", "*le") == os.path.abspath(os.path.dirname(filelist[9])) assert PathHelper.find_first_dir_with_file( "dir1", "ff*") == os.path.abspath(os.path.dirname(filelist[8])) assert PathHelper.find_first_dir_with_file("dir1/foo", "ff*") is None
def _build_srpm(cls, spec, workdir, results_dir, srpm_results_dir, srpm_builder_options): """ 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. :param srpm_results_dir: path to directory where SRPM will be placed. :param srpm_builder_options: list of additional options to rpmbuild. :return: abs path to built SRPM. """ 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] if srpm_builder_options is not None: cmd.extend(srpm_builder_options) ret = ProcessHelper.run_subprocess_cwd_env(cmd, cwd=spec_loc, env={'HOME': workdir}, output_file=output) build_log_path = os.path.join(srpm_results_dir, 'build.log') if ret == 0: return PathHelper.find_first_file(workdir, '*.src.rpm') # An error occurred, raise an exception logfile = build_log_path logs = [l for l in PathHelper.find_all_files(results_dir, '*.log')] cls.logs = [os.path.join(srpm_results_dir, os.path.basename(l)) for l in logs] raise SourcePackageBuildError("Building SRPM failed!", logfile=logfile)
def _build_rpm(cls, srpm, workdir, results_dir, rpm_results_dir, builder_options=None): """ Build RPM using rpmbuild. :param srpm: abs path to SRPM :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. :param rpm_results_dir: path directory to where RPMs will be placed. :return: abs paths to built RPMs. """ logger.info("Building RPMs") output = os.path.join(results_dir, "build.log") cmd = [cls.CMD, '--rebuild', srpm] if builder_options is not None: cmd.extend(builder_options) ret = ProcessHelper.run_subprocess_cwd_env(cmd, env={'HOME': workdir}, output_file=output) build_log_path = os.path.join(rpm_results_dir, 'build.log') if ret == 0: return [f for f in PathHelper.find_all_files(workdir, '*.rpm') if not f.endswith('.src.rpm')] # An error occurred, raise an exception logfile = build_log_path logs = [l for l in PathHelper.find_all_files(results_dir, '*.log')] cls.logs.extend(os.path.join(rpm_results_dir, os.path.basename(l)) for l in logs) raise BinaryPackageBuildError("Building RPMs failed!", results_dir, logfile=logfile)
def _build_rpm(cls, srpm, workdir, results_dir, rpm_results_dir, builder_options=None): """ Build RPM using rpmbuild. :param srpm: abs path to SRPM :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. :param rpm_results_dir: path directory to where RPMs will be placed. :return: abs paths to built RPMs. """ logger.info("Building RPMs") output = os.path.join(results_dir, "build.log") cmd = [cls.CMD, '--rebuild', srpm] if builder_options is not None: cmd.extend(builder_options) ret = ProcessHelper.run_subprocess_cwd_env(cmd, env={'HOME': workdir}, output_file=output) build_log_path = os.path.join(rpm_results_dir, 'build.log') if ret == 0: return [f for f in PathHelper.find_all_files(workdir, '*.rpm') if not f.endswith('.src.rpm')] # An error occurred, raise an exception logfile = build_log_path logs = [l for l in PathHelper.find_all_files(results_dir, '*.log')] cls.logs.extend([os.path.join(rpm_results_dir, os.path.basename(l)) for l in logs]) raise BinaryPackageBuildError("Building RPMs failed!", results_dir, logfile=logfile)
def run_check(cls, results_dir, **kwargs): """Compares old and new RPMs using pkgdiff""" csmock_report = {} old_pkgs = results_store.get_old_build().get('srpm', None) new_pkgs = results_store.get_new_build().get('srpm', None) results_dir = os.path.join(results_dir, cls.CMD) os.makedirs(results_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', results_dir]) output = io.StringIO() try: ProcessHelper.run_subprocess(cmd, output_file=output) except OSError: raise CheckerNotFoundError("Checker '{}' was not found or installed.".format(cls.name)) csmock_report['error'] = PathHelper.find_all_files_current_dir(results_dir, '*.err') csmock_report['txt'] = PathHelper.find_all_files_current_dir(results_dir, '*.txt') csmock_report['log'] = PathHelper.find_all_files_current_dir(results_dir, '*.log') csmock_report['path'] = cls.get_checker_output_dir_short() return csmock_report
def run_check(cls, results_dir, **kwargs): """Compares old and new RPMs using pkgdiff""" csmock_report = {} old_pkgs = results_store.get_old_build().get('srpm', None) new_pkgs = results_store.get_new_build().get('srpm', None) cls.results_dir = os.path.join(results_dir, cls.CMD) cls.prepare_results_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', results_dir]) output = io.StringIO() try: ProcessHelper.run_subprocess(cmd, output_file=output) except OSError as e: raise CheckerNotFoundError( "Checker '{}' was not found or installed.".format( cls.name)) from e csmock_report['error'] = PathHelper.find_all_files_current_dir( results_dir, '*.err') csmock_report['txt'] = PathHelper.find_all_files_current_dir( results_dir, '*.txt') csmock_report['log'] = PathHelper.find_all_files_current_dir( results_dir, '*.log') csmock_report['path'] = cls.get_checker_output_dir_short() return csmock_report
def _build_rpm(cls, srpm, results_dir, rpm_results_dir, root=None, arch=None, builder_options=None): """ Build RPM using mock. :param srpm: full path to the srpm. :param results_dir: abs path to dir where the log should be placed. :param rpm_results_dir: directory where rpms will be placed. :param root: path to where chroot should be built. :param arch: target architectures for the build. :param builder_options: builder_options for mock. :return abs paths to RPMs. """ logger.info("Building RPMs") output = os.path.join(results_dir, "mock_output.log") cmd = [cls.CMD, '--old-chroot', '--rebuild', srpm, '--resultdir', results_dir] if root is not None: cmd.extend(['--root', root]) if arch is not None: cmd.extend(['--arch', arch]) if builder_options is not None: cmd.extend(builder_options) ret = ProcessHelper.run_subprocess(cmd, output_file=output) if ret == 0: return [f for f in PathHelper.find_all_files(results_dir, '*.rpm') if not f.endswith('.src.rpm')] else: logfile = Mock.get_mock_logfile_path(ret, rpm_results_dir, tmp_path=results_dir) logs = [l for l in PathHelper.find_all_files(results_dir, '*.log')] cls.logs.extend(os.path.join(rpm_results_dir, os.path.basename(l)) for l in logs) raise BinaryPackageBuildError("Building RPMs failed!", rpm_results_dir, logfile=logfile)
def test_find_pythoon(self, filelist): assert PathHelper.find_first_dir_with_file( "dir1", "pythooon") == os.path.abspath( os.path.dirname(filelist[4])) assert PathHelper.find_first_dir_with_file( os.path.curdir, "py*n") == os.path.abspath(os.path.dirname(filelist[4])) assert PathHelper.find_first_dir_with_file( "dir1/bar", "pythooon") is None
def test_find_file(self, filelist): assert PathHelper.find_first_dir_with_file( "dir1", "file") == os.path.abspath( os.path.dirname(filelist[9])) assert PathHelper.find_first_dir_with_file( os.path.curdir, "file") == os.path.abspath(os.path.dirname(filelist[0])) assert PathHelper.find_first_dir_with_file( "dir1/baz", "file") is None
def test_find_ffile(self, filelist): assert PathHelper.find_first_dir_with_file( "dir1", "*le") == os.path.abspath( os.path.dirname(filelist[9])) assert PathHelper.find_first_dir_with_file( "dir1", "ff*") == os.path.abspath( os.path.dirname(filelist[8])) assert PathHelper.find_first_dir_with_file( "dir1/foo", "ff*") is None
def test_find_pythoon(self, filelist): assert PathHelper.find_first_dir_with_file( "dir1", "pythooon") == os.path.abspath(os.path.dirname(filelist[4])) assert PathHelper.find_first_dir_with_file( os.path.curdir, "py*n") == os.path.abspath(os.path.dirname(filelist[4])) assert PathHelper.find_first_dir_with_file("dir1/bar", "pythooon") is None
def test_find_file(self, filelist): assert PathHelper.find_first_dir_with_file( "dir1", "file") == os.path.abspath(os.path.dirname(filelist[9])) assert PathHelper.find_first_dir_with_file( os.path.curdir, "file") == os.path.abspath(os.path.dirname(filelist[0])) assert PathHelper.find_first_dir_with_file("dir1/baz", "file") is None
def _build_srpm(cls, spec, workdir, results_dir, srpm_results_dir, srpm_builder_options): """Builds SRPM using mock. Args: spec: Path to SPEC file to build the SRPM from. workdir: Path to working directory with rpmbuild directory structure. results_dir: Path to directory where logs will be placed. srpm_results_dir: Path to directory where SRPM will be placed. srpm_builder_options: Additional mock options. Returns: Tuple, the first element is path to SRPM, the second is a list of paths to logs. """ logger.info("Building SRPM") spec_loc = os.path.dirname(spec) output = os.path.join(results_dir, "build.log") path_to_sources = os.path.join(workdir, 'SOURCES') cmd = [cls.CMD, '--old-chroot', '--buildsrpm'] if srpm_builder_options is not None: cmd.extend(srpm_builder_options) cmd.extend(['--spec', spec]) cmd.extend(['--sources', path_to_sources]) cmd.extend(['--resultdir', results_dir]) if not check_mock_privileges(): cmd = ['pkexec'] + cmd ret = ProcessHelper.run_subprocess_cwd_env(cmd, cwd=spec_loc, env={'HOME': workdir}, output_file=output) build_log_path = os.path.join(srpm_results_dir, 'build.log') mock_log_path = os.path.join(srpm_results_dir, 'mock_output.log') root_log_path = os.path.join(srpm_results_dir, 'root.log') logs = [] for log in PathHelper.find_all_files(results_dir, '*.log'): logs.append(os.path.join(srpm_results_dir, os.path.basename(log))) if ret == 0: return PathHelper.find_first_file(workdir, '*.src.rpm'), logs if ret == 1: if not os.path.exists(build_log_path) and os.path.exists( mock_log_path): logfile = mock_log_path else: logfile = build_log_path else: logfile = root_log_path raise SourcePackageBuildError("Building SRPM failed!", logfile=logfile, logs=logs)
def _build_rpm(cls, srpm, results_dir, rpm_results_dir, root=None, arch=None, builder_options=None): """Builds RPMs using mock. Args: srpm: Path to SRPM. results_dir: Path to directory where logs will be placed. rpm_results_dir: Path to directory where rpms will be placed. root: Path to where chroot will be built arch: Target architectures for the build. builder_options: Additional options for mock. Returns: Tuple where first element is list of paths to built RPMs and the second element is list of paths to logs. """ logger.info("Building RPMs") output = os.path.join(results_dir, "mock_output.log") cmd = [ cls.CMD, '--old-chroot', '--rebuild', srpm, '--resultdir', results_dir ] if root is not None: cmd.extend(['--root', root]) if arch is not None: cmd.extend(['--arch', arch]) if builder_options is not None: cmd.extend(builder_options) if not check_mock_privileges(): cmd = ['pkexec'] + cmd ret = ProcessHelper.run_subprocess(cmd, output_file=output) logs = [] for log in PathHelper.find_all_files(results_dir, '*.log'): logs.append(os.path.join(rpm_results_dir, os.path.basename(log))) if ret == 0: return [ f for f in PathHelper.find_all_files(results_dir, '*.rpm') if not f.endswith('.src.rpm') ], logs else: logfile = get_mock_logfile_path(ret, rpm_results_dir, tmp_path=results_dir) raise BinaryPackageBuildError("Building RPMs failed!", rpm_results_dir, logfile=logfile, logs=logs)
def test_find_with_recursion(self, filelist): 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(filelist[-1])
def get_all_log_files(self): """ Function returns all log_files created by rebase-helper First if debug log file and second is report summary log file :return: """ log_list = [] if PathHelper.file_available(self.debug_log_file): log_list.append(self.debug_log_file) if PathHelper.file_available(self.report_log_file): log_list.append(self.report_log_file) return log_list
def _build_rpm(cls, srpm, results_dir, rpm_results_dir, root=None, arch=None, builder_options=None): """ Build RPM using mock. :param srpm: full path to the srpm. :param results_dir: abs path to dir where the log should be placed. :param rpm_results_dir: directory where rpms will be placed. :param root: path to where chroot should be built. :param arch: target architectures for the build. :param builder_options: builder_options for mock. :return abs paths to RPMs. """ logger.info("Building RPMs") output = os.path.join(results_dir, "mock_output.log") cmd = [ cls.CMD, '--old-chroot', '--rebuild', srpm, '--resultdir', results_dir ] if root is not None: cmd.extend(['--root', root]) if arch is not None: cmd.extend(['--arch', arch]) if builder_options is not None: cmd.extend(builder_options) ret = ProcessHelper.run_subprocess(cmd, output_file=output) if ret == 0: return [ f for f in PathHelper.find_all_files(results_dir, '*.rpm') if not f.endswith('.src.rpm') ] else: logfile = MockBuildTool.get_mock_logfile_path(ret, rpm_results_dir, tmp_path=results_dir) logs = [l for l in PathHelper.find_all_files(results_dir, '*.log')] cls.logs.extend( [os.path.join(rpm_results_dir, os.path.basename(l)) for l in logs]) raise BinaryPackageBuildError("Building RPMs failed!", rpm_results_dir, logfile=logfile)
def build(cls, spec, results_dir, **kwargs): """ Build SRPM with chosen SRPM Build Tool :param spec: SpecFile object :param results_dir: absolute path to DIR where results should be stored :return: absolute path to SRPM, list with absolute paths to logs """ srpm_results_dir = os.path.join(results_dir, "SRPM") sources = spec.get_sources() patches = [p.get_path() for p in spec.get_patches()] with RpmbuildTemporaryEnvironment(sources, patches, spec.get_path(), srpm_results_dir) as tmp_env: srpm_builder_options = cls.get_srpm_builder_options(**kwargs) env = tmp_env.env() tmp_dir = tmp_env.path() tmp_spec = env.get(RpmbuildTemporaryEnvironment.TEMPDIR_SPEC) tmp_results_dir = env.get( RpmbuildTemporaryEnvironment.TEMPDIR_RESULTS) srpm = cls._build_srpm(tmp_spec, tmp_dir, tmp_results_dir, srpm_results_dir, srpm_builder_options=srpm_builder_options) logger.info("Building SRPM finished successfully") # srpm path in results_dir srpm = os.path.join(srpm_results_dir, os.path.basename(srpm)) logger.verbose("Successfully built SRPM: '%s'", str(srpm)) # gather logs logs = [l for l in PathHelper.find_all_files(srpm_results_dir, '*.log')] logger.verbose("logs: '%s'", str(logs)) return dict(srpm=srpm, logs=logs)
def build(cls, spec, results_dir, srpm, **kwargs): """ Builds the RPMs using rpmbuild :param spec: SpecFile object :param results_dir: absolute path to DIR where results should be stored :param srpm: absolute path to SRPM :return: dict with: 'rpm' -> list with absolute paths to RPMs 'logs' -> list with absolute paths to build_logs """ cls.logs = [] rpm_results_dir = os.path.join(results_dir, "RPM") sources = spec.get_sources() patches = [p.get_path() for p in spec.get_patches()] with RpmbuildTemporaryEnvironment(sources, patches, spec.get_path(), rpm_results_dir) as tmp_env: env = tmp_env.env() tmp_dir = tmp_env.path() tmp_results_dir = env.get(RpmbuildTemporaryEnvironment.TEMPDIR_RESULTS) rpms = cls._build_rpm(srpm, tmp_dir, tmp_results_dir, rpm_results_dir, builder_options=cls.get_builder_options(**kwargs)) logger.info("Building RPMs finished successfully") # RPMs paths in results_dir rpms = [os.path.join(rpm_results_dir, os.path.basename(f)) for f in rpms] logger.verbose("Successfully built RPMs: '%s'", str(rpms)) # gather logs cls.logs.extend(l for l in PathHelper.find_all_files(rpm_results_dir, '*.log')) logger.verbose("logs: '%s'", str(cls.logs)) return dict(rpm=rpms, logs=cls.logs)
def build(cls, spec, results_dir, srpm, **kwargs): """ Builds the RPMs using rpmbuild :param spec: SpecFile object :param results_dir: absolute path to DIR where results should be stored :param srpm: absolute path to SRPM :return: dict with: 'rpm' -> list with absolute paths to RPMs 'logs' -> list with absolute paths to build_logs """ cls.logs = [] rpm_results_dir = os.path.join(results_dir, "RPM") sources = spec.get_sources() patches = [p.get_path() for p in spec.get_patches()] with RpmbuildTemporaryEnvironment(sources, patches, spec.get_path(), rpm_results_dir) as tmp_env: env = tmp_env.env() tmp_dir = tmp_env.path() tmp_results_dir = env.get(RpmbuildTemporaryEnvironment.TEMPDIR_RESULTS) rpms = cls._build_rpm(srpm, tmp_dir, tmp_results_dir, rpm_results_dir, builder_options=cls.get_builder_options(**kwargs)) logger.info("Building RPMs finished successfully") # RPMs paths in results_dir rpms = [os.path.join(rpm_results_dir, os.path.basename(f)) for f in rpms] logger.verbose("Successfully built RPMs: '%s'", str(rpms)) # gather logs cls.logs.extend([l for l in PathHelper.find_all_files(rpm_results_dir, '*.log')]) logger.verbose("logs: '%s'", str(cls.logs)) return dict(rpm=rpms, logs=cls.logs)
def build(cls, spec, results_dir, **kwargs): """ Build SRPM with chosen SRPM Build Tool :param spec: SpecFile object :param results_dir: absolute path to DIR where results should be stored :return: absolute path to SRPM, list with absolute paths to logs """ srpm_results_dir = os.path.join(results_dir, "SRPM") sources = spec.get_sources() patches = [p.get_path() for p in spec.get_patches()] with MockTemporaryEnvironment(sources, patches, spec.get_path(), srpm_results_dir) as tmp_env: srpm_builder_options = cls.get_srpm_builder_options(**kwargs) env = tmp_env.env() tmp_dir = tmp_env.path() tmp_spec = env.get(MockTemporaryEnvironment.TEMPDIR_SPEC) tmp_results_dir = env.get( MockTemporaryEnvironment.TEMPDIR_RESULTS) srpm = cls._build_srpm(tmp_spec, tmp_dir, tmp_results_dir, srpm_results_dir, srpm_builder_options=srpm_builder_options) logger.info("Building SRPM finished successfully") # srpm path in results_dir srpm = os.path.join(srpm_results_dir, os.path.basename(srpm)) logger.verbose("Successfully built SRPM: '%s'", str(srpm)) # gather logs logs = [l for l in PathHelper.find_all_files(srpm_results_dir, '*.log')] logger.verbose("logs: '%s'", str(logs)) return dict(srpm=srpm, logs=logs)
def _build_srpm(cls, spec, workdir, results_dir, srpm_results_dir, srpm_builder_options): """ Build SRPM using mock. :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. :param srpm_results_dir: path to directory where SRPM will be placed. :param srpm_builder_options: list of additional options for mock build tool(eg. '-r fedora-XX-x86_64'). :return: abs path to built SRPM. """ logger.info("Building SRPM") spec_loc = os.path.dirname(spec) output = os.path.join(results_dir, "build.log") path_to_sources = os.path.join(workdir, 'SOURCES') cmd = ['mock', '--old-chroot', '--buildsrpm'] if srpm_builder_options is not None: cmd.extend(srpm_builder_options) cmd.extend(['--spec', spec]) cmd.extend(['--sources', path_to_sources]) cmd.extend(['--resultdir', results_dir]) ret = ProcessHelper.run_subprocess_cwd_env(cmd, cwd=spec_loc, env={'HOME': workdir}, output_file=output) build_log_path = os.path.join(srpm_results_dir, 'build.log') mock_log_path = os.path.join(srpm_results_dir, 'mock_output.log') root_log_path = os.path.join(srpm_results_dir, 'root.log') if ret == 0: return PathHelper.find_first_file(workdir, '*.src.rpm') if ret == 1: if not os.path.exists(build_log_path) and os.path.exists(mock_log_path): logfile = mock_log_path else: logfile = build_log_path else: logfile = root_log_path logs = [l for l in PathHelper.find_all_files(results_dir, '*.log')] cls.logs = [os.path.join(srpm_results_dir, os.path.basename(l)) for l in logs] raise SourcePackageBuildError("Building SRPM failed!", logfile=logfile)
def _build_rpm(cls, srpm, workdir, results_dir, rpm_results_dir, builder_options=None): """Builds RPMs using rpmbuild Args: srpm: Path to SRPM. workdir: Path to working directory with rpmbuild directory structure. results_dir: Path to directory where logs will be placed. rpm_results_dir: Path to directory where RPMs will be placed. builder_options: Additional options for rpmbuild. Returns: Tuple, the first element is a list of paths to built RPMs, the second is a list of paths to logs. """ logger.info("Building RPMs") output = os.path.join(results_dir, "build.log") cmd = [cls.CMD, '--rebuild', srpm] if builder_options is not None: cmd.extend(builder_options) ret = ProcessHelper.run_subprocess_cwd_env(cmd, env={'HOME': workdir}, output_file=output) build_log_path = os.path.join(rpm_results_dir, 'build.log') logs = [] for log in PathHelper.find_all_files(results_dir, '*.log'): logs.append(os.path.join(rpm_results_dir, os.path.basename(log))) if ret == 0: return [ f for f in PathHelper.find_all_files(workdir, '*.rpm') if not f.endswith('.src.rpm') ], logs # An error occurred, raise an exception raise BinaryPackageBuildError("Building RPMs failed!", results_dir, logfile=build_log_path, logs=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 build(cls, spec, results_dir, srpm, **kwargs): """ Builds the RPMs using mock :param spec: SpecFile object :param results_dir: absolute path to directory where results will be stored :param srpm: absolute path to SRPM :param root: mock root used for building :param arch: architecture to build the RPM for :return: dict with: 'rpm' -> list with absolute paths to RPMs 'logs' -> list with absolute paths to logs """ cls.logs = [] rpm_results_dir = os.path.join(results_dir, "RPM") sources = spec.get_sources() patches = [p.get_path() for p in spec.get_patches()] with MockTemporaryEnvironment(sources, patches, spec.get_path(), 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, rpm_results_dir, builder_options=cls.get_builder_options(**kwargs)) # 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) logger.info("Building RPMs finished successfully") rpms = [ os.path.join(rpm_results_dir, os.path.basename(f)) for f in rpms ] logger.verbose("Successfully built RPMs: '%s'", str(rpms)) # gather logs cls.logs.extend( [l for l in PathHelper.find_all_files(rpm_results_dir, '*.log')]) logger.verbose("logs: '%s'", str(cls.logs)) return dict(rpm=rpms, logs=cls.logs)
def get_checker_outputs(self): checkers = {} for check, data in six.iteritems(results_store.get_checkers()): if data: for log in six.iterkeys(data): if PathHelper.file_available(log): checkers[check] = log else: checkers[check] = None return checkers
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: """ 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 get_checker_outputs(self): checkers = {} for check, data in results_store.get_checkers().items(): if data: for log in data: if PathHelper.file_available(log): checkers[check] = log else: checkers[check] = None return checkers
def _build_srpm(cls, spec, workdir, results_dir, srpm_results_dir, srpm_builder_options): """Builds SRPM using rpmbuild. Args: spec: Path to SPEC file to build the SRPM from. workdir: Path to working directory with rpmbuild directory structure. results_dir: Path to directory where logs will be placed. srpm_results_dir: Path to directory where SRPM will be placed. srpm_builder_options: Additional rpmbuild options. Returns: Tuple, the first element is path to SRPM, the second is a list of paths to logs. """ logger.info("Building SRPM") spec_loc, spec_name = os.path.split(spec) output = os.path.join(results_dir, "build.log") cmd = [cls.CMD, '-bs', spec_name] if srpm_builder_options is not None: cmd.extend(srpm_builder_options) ret = ProcessHelper.run_subprocess_cwd_env(cmd, cwd=spec_loc, env={'HOME': workdir}, output_file=output) build_log_path = os.path.join(srpm_results_dir, 'build.log') logs = [] for l in PathHelper.find_all_files(results_dir, '*.log'): logs.append(os.path.join(srpm_results_dir, os.path.basename(l))) if ret == 0: return PathHelper.find_first_file(workdir, '*.src.rpm'), logs # An error occurred, raise an exception raise SourcePackageBuildError("Building SRPM failed!", logfile=build_log_path, logs=logs)
def _build_srpm(cls, spec, workdir, results_dir, srpm_results_dir, srpm_builder_options): """ 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. :param srpm_results_dir: path to directory where SRPM will be placed. :param srpm_builder_options: list of additional options to rpmbuild. :return: abs path to built SRPM. """ 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] if srpm_builder_options is not None: cmd.extend(srpm_builder_options) ret = ProcessHelper.run_subprocess_cwd_env(cmd, cwd=spec_loc, env={'HOME': workdir}, output_file=output) build_log_path = os.path.join(srpm_results_dir, 'build.log') if ret == 0: return PathHelper.find_first_file(workdir, '*.src.rpm') # An error occurred, raise an exception logfile = build_log_path logs = [l for l in PathHelper.find_all_files(results_dir, '*.log')] cls.logs = [ os.path.join(srpm_results_dir, os.path.basename(l)) for l in logs ] raise SourcePackageBuildError("Building SRPM failed!", logfile=logfile)
def build(cls, spec, results_dir, srpm, **kwargs): """ Builds the RPMs using mock :param spec: SpecFile object :param results_dir: absolute path to directory where results will be stored :param srpm: absolute path to SRPM :param root: mock root used for building :param arch: architecture to build the RPM for :return: dict with: 'rpm' -> list with absolute paths to RPMs 'logs' -> list with absolute paths to logs """ cls.logs = [] rpm_results_dir = os.path.join(results_dir, "RPM") sources = spec.get_sources() patches = [p.get_path() for p in spec.get_patches()] with MockTemporaryEnvironment(sources, patches, spec.get_path(), 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, rpm_results_dir, builder_options=cls.get_builder_options(**kwargs)) # 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) logger.info("Building RPMs finished successfully") rpms = [os.path.join(rpm_results_dir, os.path.basename(f)) for f in rpms] logger.verbose("Successfully built RPMs: '%s'", str(rpms)) # gather logs cls.logs.extend(l for l in PathHelper.find_all_files(rpm_results_dir, '*.log')) logger.verbose("logs: '%s'", str(cls.logs)) return dict(rpm=rpms, logs=cls.logs)
def _find_spec_file(self) -> str: """Finds a spec file in the execution_dir directory. Returns: Path to the spec file. Raises: RebaseHelperError: If no spec file could be found. """ spec_file_path = PathHelper.find_first_file(self.execution_dir, '*.spec', 0) if not spec_file_path: raise RebaseHelperError("Could not find any SPEC file " "in the current directory '{}'".format( self.execution_dir)) return spec_file_path
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 results_store.set_build_data(version, data) if not found: return False return True
def __enter__(self): self._env[self.TEMPDIR] = PathHelper.get_temp_dir() logger.debug("Created environment in '%s'", self.path()) return self
def test_find_with_recursion(self, filelist): 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(filelist[-1])
def test_find_without_recursion(self, filelist): assert PathHelper.find_first_file(os.path.curdir, "*.spec") == os.path.abspath(filelist[-1])
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 '{}'".format(self.execution_dir))
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 test_find_without_recursion(self, filelist): assert PathHelper.find_first_file( os.path.curdir, "*.spec") == os.path.abspath(filelist[-1])
def __init__(self, filename): self.tmp = PathHelper.get_temp_dir() TarArchiveType.extract(TarArchiveType.open(filename), '', self.tmp) self.data = TarGzArchiveType.open( os.path.join(self.tmp, 'data.tar.gz'))