def _build_srpm(cls, spec, sources, patches, results_dir):
"""
Builds the SRPM using rpmbuild
:param spec: absolute path to the SPEC file.
:param sources: list with absolute paths to SOURCES
:param patches: list with absolute paths to PATCHES
:param results_dir: absolute path to DIR where results should be stored
:return: absolute path to SRPM, list with absolute paths to logs
"""
# build SRPM
srpm_results_dir = os.path.join(results_dir, "SRPM")
with RpmbuildTemporaryEnvironment(sources, patches, spec,
srpm_results_dir) as tmp_env:
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._do_build_srpm(tmp_spec, tmp_dir, tmp_results_dir)
if srpm is None:
cls.logs = [l for l in PathHelper.find_all_files(srpm_results_dir, '*.log')]
raise SourcePackageBuildError("Building SRPM failed!")
else:
logger.info("Building SRPM finished successfully")
# srpm path in results_dir
srpm = os.path.join(srpm_results_dir, os.path.basename(srpm))
logger.debug("Successfully built SRPM: '%s'", str(srpm))
# gather logs
logs = [l for l in PathHelper.find_all_files(srpm_results_dir, '*.log')]
logger.debug("logs: '%s'", str(logs))
return srpm, logs
def run_check(cls, results_dir):
"""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)
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 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_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
cls.logs.extend([l for l in PathHelper.find_all_files(rpm_results_dir, '*.log')])
raise BinaryPackageBuildError("Building RPMs failed!", results_dir, logfile=logfile)
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_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_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):
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 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])
def build(cls, spec, sources, patches, results_dir, **kwargs):
"""
Builds the SRPM and RPMs using rpmbuild
:param spec: absolute path to the SPEC file.
:param sources: list with absolute paths to SOURCES
:param patches: list with absolute paths to PATCHES
:param results_dir: absolute path to DIR where results should be stored
:return: dict with:
'srpm' -> absolute path to SRPM
'rpm' -> list with absolute paths to RPMs
'logs' -> list with absolute paths to build_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 RpmbuildTemporaryEnvironment(sources, patches, spec,
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,
builder_options=cls.get_builder_options(**kwargs))
if rpms is None:
cls.logs.extend([
l for l in PathHelper.find_all_files(rpm_results_dir, '*.log')
])
raise BinaryPackageBuildError("Building RPMs failed!")
else:
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.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_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
cls.logs = [
l for l in PathHelper.find_all_files(srpm_results_dir, '*.log')
]
raise SourcePackageBuildError("Building SRPM failed!", logfile=logfile)
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)
cls.logs.extend(
[l for l in PathHelper.find_all_files(rpm_results_dir, '*.log')])
raise BinaryPackageBuildError("Building RPMs failed!",
rpm_results_dir,
logfile=logfile)
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 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
"""
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.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 dict(rpm=rpms, logs=cls.logs)
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 _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 _build_rpm(cls,
srpm,
results_dir,
root=None,
arch=None,
builder_options=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])
if builder_options is not None:
cmd.extend(builder_options)
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_rpm(cls, srpm, workdir, 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.
:return: If build process ends successfully returns list of abs paths
to built RPMs, otherwise 'None'.
"""
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=output)
if ret != 0:
return None
else:
return [f for f in PathHelper.find_all_files(workdir, '*.rpm') if not f.endswith('.src.rpm')]
def _build_rpm(cls, srpm, workdir, 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.
:return: If build process ends successfully returns list of abs paths
to built RPMs, otherwise 'None'.
"""
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=output)
if ret != 0:
return None
else:
return [
f for f in PathHelper.find_all_files(workdir, '*.rpm')
if not f.endswith('.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 _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 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
"""
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.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 dict(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 build(cls, spec, sources, patches, results_dir, **kwargs):
"""
Builds the SRPM and RPMs using rpmbuild
:param spec: absolute path to the SPEC file.
:param sources: list with absolute paths to SOURCES
:param patches: list with absolute paths to PATCHES
:param results_dir: absolute path to DIR where results should be stored
:return: dict with:
'srpm' -> absolute path to SRPM
'rpm' -> list with absolute paths to RPMs
'logs' -> list with absolute paths to build_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 RpmbuildTemporaryEnvironment(sources, patches, spec, 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)
if rpms is None:
cls.logs.extend([l for l in PathHelper.find_all_files(rpm_results_dir, '*.log')])
raise BinaryPackageBuildError("Building RPMs failed!")
else:
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.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_srpm(cls, spec, sources, patches, results_dir):
"""
Builds the SRPM using rpmbuild
:param spec: absolute path to the SPEC file.
:param sources: list with absolute paths to SOURCES
:param patches: list with absolute paths to PATCHES
:param results_dir: absolute path to DIR where results should be stored
:return: absolute path to SRPM, list with absolute paths to logs
"""
# build SRPM
srpm_results_dir = os.path.join(results_dir, "SRPM")
with RpmbuildTemporaryEnvironment(sources, patches, spec,
srpm_results_dir) as tmp_env:
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._do_build_srpm(tmp_spec, tmp_dir, tmp_results_dir)
if srpm is None:
cls.logs = [
l for l in PathHelper.find_all_files(srpm_results_dir, '*.log')
]
raise SourcePackageBuildError("Building SRPM failed!")
else:
logger.info("Building SRPM finished successfully")
# srpm path in results_dir
srpm = os.path.join(srpm_results_dir, os.path.basename(srpm))
logger.debug("Successfully built SRPM: '%s'", str(srpm))
# gather logs
logs = [
l for l in PathHelper.find_all_files(srpm_results_dir, '*.log')
]
logger.debug("logs: '%s'", str(logs))
return srpm, 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
cls.logs = [
l for l in PathHelper.find_all_files(srpm_results_dir, '*.log')
]
raise SourcePackageBuildError("Building SRPM failed!", logfile=logfile)
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 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.debug("Successfully built SRPM: '%s'", str(srpm))
# gather logs
logs = [
l for l in PathHelper.find_all_files(srpm_results_dir, '*.log')
]
logger.debug("logs: '%s'", str(logs))
return dict(srpm=srpm, logs=logs)
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 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,
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)
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 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])
def test_find_file(self):
assert PathHelper.find_first_file(
"dir1", "file") == os.path.abspath(self.files[9])
assert PathHelper.find_first_file(
os.path.curdir, "file") == os.path.abspath(self.files[0])
assert PathHelper.find_first_file("dir1/baz", "file") is None
def test_find_ffile(self):
assert PathHelper.find_first_file(
"dir1", "*le") == os.path.abspath(self.files[9])
assert PathHelper.find_first_file(
"dir1", "ff*") == os.path.abspath(self.files[8])
assert PathHelper.find_first_file("dir1/foo", "ff*") is None
def test_find_pythoon(self):
assert PathHelper.find_first_file(
"dir1", "pythooon") == os.path.abspath(self.files[4])
assert PathHelper.find_first_file(
os.path.curdir, "py*n") == os.path.abspath(self.files[4])
assert PathHelper.find_first_file("dir1/bar", "pythooon") is None
def test_find_without_recursion(self):
assert PathHelper.find_first_file(
os.path.curdir, "*.spec") == os.path.abspath(self.files[-1])