def extracted_archive(self, archive, workdir):
a = Archive(archive)
d = os.path.join(workdir, 'dir')
a.extract_archive(d)
if archive == self.GEM:
# append top level dir
d = os.path.join(d, 'archive')
return d
def _get_initial_sources_list(self):
"""Function returns all sources mentioned in SPEC file"""
# get all regular sources
sources = []
tar_sources = []
sources_list = [x for x in self.spc.sources if x[2] == 1]
remote_files_re = re.compile(r'(http:|https:|ftp:)//.*')
for index, src in enumerate(sorted(sources_list, key=lambda source: source[1])):
# src is type of (SOURCE, Index of source, Type of source (PAtch, Source)
# We need to download all archives and only the one
abs_path = os.path.join(self.sources_location, os.path.basename(src[0]).strip())
sources.append(abs_path)
archive = [x for x in Archive.get_supported_archives() if src[0].endswith(x)]
# if the source is a remote file, download it
if archive:
if remote_files_re.search(src[0]) and self.download and not os.path.isfile(abs_path):
logger.debug("Tarball is not in absolute path {} "
"trying to download one from URL {}".format(abs_path, src[0]))
logger.info("Tarball is not in absolute path. Trying to download it from URL")
try:
DownloadHelper.download_file(src[0], abs_path)
except DownloadError as e:
raise RebaseHelperError("Failed to download file from URL {}. "
"Reason: '{}'. ".format(src[0], str(e)))
tar_sources.append(abs_path)
return sources, tar_sources
def _prepare_spec_objects(self):
"""
Prepare spec files and initialize objects
:return:
"""
self.rebase_spec_file_path = get_rebase_name(self.results_dir,
self.spec_file_path)
self.spec_file = SpecFile(self.spec_file_path,
self.execution_dir,
download=not self.conf.not_download_sources)
# Check whether test suite is enabled at build time
if not self.spec_file.is_test_suite_enabled():
results_store.set_info_text(
'WARNING', 'Test suite is not enabled at build time.')
# create an object representing the rebased SPEC file
self.rebase_spec_file = self.spec_file.copy(self.rebase_spec_file_path)
# check if argument passed as new source is a file or just a version
if [
True for ext in Archive.get_supported_archives()
if self.conf.sources.endswith(ext)
]:
logger.debug("argument passed as a new source is a file")
self.rebase_spec_file.set_version_using_archive(self.conf.sources)
else:
logger.debug("argument passed as a new source is a version")
version, extra_version, separator = SpecFile.split_version_string(
self.conf.sources)
self.rebase_spec_file.set_version(version)
self.rebase_spec_file.set_extra_version_separator(separator)
self.rebase_spec_file.set_extra_version(extra_version)
def _prepare_spec_objects(self):
"""
Prepare spec files and initialize objects
:return:
"""
self.rebase_spec_file_path = get_rebase_name(self.spec_file_path)
self.spec_file = SpecFile(self.spec_file_path,
self.execution_dir,
download=not self.conf.not_download_sources)
# Check whether test suite is enabled at build time
if not self.spec_file.is_test_suite_enabled():
OutputLogger.set_info_text('WARNING', 'Test suite is not enabled at build time.')
# create an object representing the rebased SPEC file
self.rebase_spec_file = self.spec_file.copy(self.rebase_spec_file_path)
# check if argument passed as new source is a file or just a version
if [True for ext in Archive.get_supported_archives() if self.conf.sources.endswith(ext)]:
logger.debug("argument passed as a new source is a file")
self.rebase_spec_file.set_version_using_archive(self.conf.sources)
else:
logger.debug("argument passed as a new source is a version")
version, extra_version = SpecFile.split_version_string(self.conf.sources)
self.rebase_spec_file.set_version(version)
if extra_version:
self.rebase_spec_file.set_extra_version(extra_version)
def extract_version_from_archive_name(archive_path: str, main_source: str) -> str:
"""Extracts version string from source archive name.
Args:
archive_path: Path to the main sources archive.
main_source: Value of Source0 tag.
Returns:
Extracted version string.
Raises:
RebaseHelperError in case version can't be determined.
"""
fallback_regex = r'\w*[-_]?v?([.\d]+.*)({0})'.format(
'|'.join([re.escape(a) for a in Archive.get_supported_archives()]))
source = os.path.basename(main_source)
regex = re.sub(r'%({)?version(?(1)})(.*%(\w+|{.+}))?', 'PLACEHOLDER', source, flags=re.IGNORECASE)
regex = MacroHelper.expand(regex, regex)
regex = re.escape(regex).replace('PLACEHOLDER', r'(.+)')
if regex == re.escape(MacroHelper.expand(source, source)):
# no substitution was made, use the fallback regex
regex = fallback_regex
logger.debug('Extracting version from archive name using %s', regex)
archive_name = os.path.basename(archive_path)
m = re.match(regex, archive_name)
if m:
logger.debug('Extracted version %s', m.group(1))
return m.group(1)
if regex != fallback_regex:
m = re.match(fallback_regex, archive_name)
if m:
logger.debug('Extracted version %s', m.group(1))
return m.group(1)
raise RebaseHelperError('Unable to extract version from archive name')
def prepare_sources(self):
"""
Function prepares a sources.
:return:
"""
old_dir = Application.extract_sources(self.old_sources,
os.path.join(self.execution_dir, settings.OLD_SOURCES_DIR))
new_dir = Application.extract_sources(self.new_sources,
os.path.join(self.execution_dir, settings.NEW_SOURCES_DIR))
# determine top-level directory in new_sources archive
toplevel_dir = os.path.relpath(new_dir,
os.path.join(self.execution_dir, settings.NEW_SOURCES_DIR))
if toplevel_dir != '.':
self.rebase_spec_file.update_setup_dirname(toplevel_dir)
# This copies other sources to extracted sources marked as 0
for rest in self.rest_sources:
for source_dir in [old_dir, new_dir]:
archive = [x for x in Archive.get_supported_archives() if rest.endswith(x)]
# if the source is a remote file, download it
if archive:
Application.extract_sources(rest, os.path.join(self.execution_dir, source_dir))
return [old_dir, new_dir]
def prepare_sources(self):
"""
Function prepares a sources.
:return:
"""
old_dir = Application.extract_sources(self.old_sources,
os.path.join(self.execution_dir, settings.OLD_SOURCES_DIR))
new_dir = Application.extract_sources(self.new_sources,
os.path.join(self.execution_dir, settings.NEW_SOURCES_DIR))
# determine top-level directory in new_sources archive
toplevel_dir = os.path.relpath(new_dir,
os.path.join(self.execution_dir, settings.NEW_SOURCES_DIR))
if toplevel_dir != '.':
self.rebase_spec_file.update_setup_dirname(toplevel_dir)
# extract rest of source archives to correct paths
rest_sources = [self.old_rest_sources, self.new_rest_sources]
spec_files = [self.spec_file, self.rebase_spec_file]
sources_dirs = [settings.OLD_SOURCES_DIR, settings.NEW_SOURCES_DIR]
for sources, spec_file, sources_dir in zip(rest_sources, spec_files, sources_dirs):
for rest in sources:
archive = [x for x in Archive.get_supported_archives() if rest.endswith(x)]
if archive:
dest_dir = spec_file.find_archive_target_in_prep(rest)
if dest_dir:
Application.extract_sources(rest, os.path.join(self.execution_dir, sources_dir, dest_dir))
return [old_dir, new_dir]
def extraction_test(self, archive):
"""
Generic test for extraction of all types of archives
"""
EXTRACT_DIR = os.path.join(os.getcwd(), 'dir')
EXTRACTED_FILE = os.path.join(EXTRACT_DIR, self.ARCHIVED_FILE)
archive = Archive(archive)
archive.extract_archive(EXTRACT_DIR)
# check if the dir was created
assert os.path.isdir(EXTRACT_DIR)
# check if the file was extracted
assert os.path.isfile(EXTRACTED_FILE)
# check the content
with open(EXTRACTED_FILE) as f:
assert f.read().strip() == self.ARCHIVED_FILE_CONTENT
def _prepare_spec_objects(self):
"""
Prepare spec files and initialize objects
:return:
"""
self.rebase_spec_file_path = get_rebase_name(self.rebased_sources_dir, self.spec_file_path)
self.spec_file = SpecFile(self.spec_file_path,
self.conf.changelog_entry,
self.execution_dir,
download=not self.conf.not_download_sources)
# Check whether test suite is enabled at build time
if not self.spec_file.is_test_suite_enabled():
results_store.set_info_text('WARNING', 'Test suite is not enabled at build time.')
# create an object representing the rebased SPEC file
self.rebase_spec_file = self.spec_file.copy(self.rebase_spec_file_path)
if not self.conf.sources:
self.conf.sources = versioneers_runner.run(self.conf.versioneer,
self.spec_file.get_package_name(),
self.spec_file.category,
self.conf.versioneer_blacklist)
if self.conf.sources:
logger.info("Determined latest upstream version '%s'", self.conf.sources)
else:
raise RebaseHelperError('Could not determine latest upstream version '
'and no SOURCES argument specified!')
# Prepare rebased_sources_dir
self.rebased_repo = self._prepare_rebased_repository(self.spec_file.patches,
self.execution_dir,
self.rebased_sources_dir)
# check if argument passed as new source is a file or just a version
if [True for ext in Archive.get_supported_archives() if self.conf.sources.endswith(ext)]:
logger.debug("argument passed as a new source is a file")
self.rebase_spec_file.set_version_using_archive(self.conf.sources)
else:
logger.debug("argument passed as a new source is a version")
version, extra_version, separator = SpecFile.split_version_string(self.conf.sources)
self.rebase_spec_file.set_version(version)
self.rebase_spec_file.set_extra_version_separator(separator)
self.rebase_spec_file.set_extra_version(extra_version)
if not self.conf.skip_version_check and parse_version(self.rebase_spec_file.get_version()) \
<= parse_version(self.spec_file.get_version()):
raise RebaseHelperError("Current version is equal to or newer than the requested version, nothing to do.")
# run spec hooks
spec_hooks_runner.run_spec_hooks(self.spec_file, self.rebase_spec_file, **self.kwargs)
# spec file object has been sanitized downloading can proceed
for spec_file in [self.spec_file, self.rebase_spec_file]:
if spec_file.download:
spec_file.download_remote_sources()
# parse spec again with sources downloaded to properly expand %prep section
spec_file._update_data() # pylint: disable=protected-access
def extract_version_from_archive_name(archive_path, source_string=''):
"""
Method extracts the version from archive name based on the source string from SPEC file.
It extracts also an extra version such as 'b1', 'rc1', ...
:param archive_path: archive name or path with archive name from which to extract the version
:param source_string: Source string from SPEC file used to construct version extraction regex
:return: tuple of strings with (extracted version, extra version) or (None, None) if extraction failed
"""
# https://regexper.com/#(%5B.0-9%5D%2B%5B-_%5D%3F%5Cw*)
version_regex_str = r'([.0-9]+[-_]?\w*)'
fallback_regex_str = r'^\w+[-_]?v?{0}({1})'.format(
version_regex_str, '|'.join(Archive.get_supported_archives()))
# match = re.search(regex, tarball_name)
name = os.path.basename(archive_path)
url_base = os.path.basename(source_string).strip()
logger.debug("Extracting version from '%s' using '%s'", name, url_base)
# expect that the version macro can be followed by another macros
regex_str = re.sub(r'%{version}(%{.+})?',
version_regex_str,
url_base,
flags=re.IGNORECASE)
# if no substitution was made, use the fallback regex
if regex_str == url_base:
logger.debug(
'Using fallback regex to extract version from archive name.')
regex_str = fallback_regex_str
else:
regex_str = rpm.expandMacro(regex_str)
logger.debug("Extracting version using regex '%s'", regex_str)
regex = re.compile(regex_str)
match = regex.search(name)
if match:
version = match.group(1)
logger.debug("Extracted version '%s'", version)
return SpecFile.split_version_string(version)
else:
logger.debug('Failed to extract version from archive name!')
# TODO: look at this if it could be rewritten in a better way!
# try fallback regex if not used this time
if regex_str != fallback_regex_str:
logger.debug(
"Trying to extracting version using fallback regex '%s'",
fallback_regex_str)
regex = re.compile(fallback_regex_str)
match = regex.search(name)
if match:
version = match.group(1)
logger.debug("Extracted version '%s'", version)
return SpecFile.split_version_string(version)
else:
logger.debug(
'Failed to extract version from archive name using fallback regex!'
)
return SpecFile.split_version_string('')
def _prepare_spec_objects(self):
"""
Prepare spec files and initialize objects
:return:
"""
self.rebase_spec_file_path = get_rebase_name(self.rebased_sources_dir, self.spec_file_path)
self.spec_file = SpecFile(self.spec_file_path, self.execution_dir)
# Check whether test suite is enabled at build time
if not self.spec_file.is_test_suite_enabled():
results_store.set_info_text('WARNING', 'Test suite is not enabled at build time.')
# create an object representing the rebased SPEC file
self.rebase_spec_file = self.spec_file.copy(self.rebase_spec_file_path)
if not self.conf.sources:
self.conf.sources = plugin_manager.versioneers.run(self.conf.versioneer,
self.spec_file.get_package_name(),
self.spec_file.category,
self.conf.versioneer_blacklist)
if self.conf.sources:
logger.info("Determined latest upstream version '%s'", self.conf.sources)
else:
raise RebaseHelperError('Could not determine latest upstream version '
'and no SOURCES argument specified!')
# Prepare rebased_sources_dir
self.rebased_repo = self._prepare_rebased_repository(self.spec_file.patches,
self.execution_dir,
self.rebased_sources_dir)
# check if argument passed as new source is a file or just a version
if [True for ext in Archive.get_supported_archives() if self.conf.sources.endswith(ext)]:
logger.verbose("argument passed as a new source is a file")
self.rebase_spec_file.set_version_using_archive(self.conf.sources)
else:
logger.verbose("argument passed as a new source is a version")
version, extra_version, separator = SpecFile.split_version_string(self.conf.sources)
self.rebase_spec_file.set_version(version)
self.rebase_spec_file.set_extra_version_separator(separator)
self.rebase_spec_file.set_extra_version(extra_version)
if not self.conf.skip_version_check and parse_version(self.rebase_spec_file.get_version()) \
<= parse_version(self.spec_file.get_version()):
raise RebaseHelperError("Current version is equal to or newer than the requested version, nothing to do.")
self.rebase_spec_file.update_changelog(self.conf.changelog_entry)
# run spec hooks
plugin_manager.spec_hooks.run(self.spec_file, self.rebase_spec_file, **self.kwargs)
# spec file object has been sanitized downloading can proceed
if not self.conf.not_download_sources:
for spec_file in [self.spec_file, self.rebase_spec_file]:
spec_file.download_remote_sources()
# parse spec again with sources downloaded to properly expand %prep section
spec_file._update_data() # pylint: disable=protected-access
def extract_archive(archive_path, destination):
"""
Extracts given archive into the destination and handle all exceptions.
:param archive_path: path to the archive to be extracted
:param destination: path to a destination, where the archive should be extracted to
:return:
"""
archive = Archive(archive_path)
try:
archive.extract_archive(destination)
except IOError as e:
raise RebaseHelperError("Archive '{}' can not be extracted".format(
archive_path)) from e
except (EOFError, SystemError) as e:
raise RebaseHelperError(
"Archive '{}' is damaged".format(archive_path)) from e
def extract_archive(archive_path, destination):
"""
Extracts given archive into the destination and handle all exceptions.
:param archive_path: path to the archive to be extracted
:param destination: path to a destination, where the archive should be extracted to
:return:
"""
try:
archive = Archive(archive_path)
except NotImplementedError as ni_e:
raise RebaseHelperError('%s. Supported archives are %s', ni_e.message, Archive.get_supported_archives())
try:
archive.extract_archive(destination)
except IOError:
raise RebaseHelperError("Archive '%s' can not be extracted", archive_path)
except (EOFError, SystemError):
raise RebaseHelperError("Archive '%s' is damaged", archive_path)
def extract_archive(archive_path, destination):
"""
Extracts given archive into the destination and handle all exceptions.
:param archive_path: path to the archive to be extracted
:param destination: path to a destination, where the archive should be extracted to
:return:
"""
try:
archive = Archive(archive_path)
except NotImplementedError as ni_e:
raise RebaseHelperError('%s. Supported archives are %s' % (six.text_type(ni_e),
Archive.get_supported_archives()))
try:
archive.extract_archive(destination)
except IOError:
raise RebaseHelperError("Archive '%s' can not be extracted" % archive_path)
except (EOFError, SystemError):
raise RebaseHelperError("Archive '%s' is damaged" % archive_path)
def prepare_sources(self):
"""
Function prepares a sources.
:return:
"""
old_sources_dir = os.path.join(self.execution_dir,
settings.OLD_SOURCES_DIR)
new_sources_dir = os.path.join(self.execution_dir,
settings.NEW_SOURCES_DIR)
old_dir = Application.extract_sources(self.old_sources,
old_sources_dir)
new_dir = Application.extract_sources(self.new_sources,
new_sources_dir)
old_tld = os.path.relpath(old_dir, old_sources_dir)
new_tld = os.path.relpath(new_dir, new_sources_dir)
dirname = self.spec_file.get_setup_dirname()
if dirname and os.sep in dirname:
dirs = os.path.split(dirname)
if old_tld == dirs[0]:
old_dir = os.path.join(old_dir, *dirs[1:])
if new_tld == dirs[0]:
new_dir = os.path.join(new_dir, *dirs[1:])
new_dirname = os.path.relpath(new_dir, new_sources_dir)
if new_dirname != '.':
self.rebase_spec_file.update_setup_dirname(new_dirname)
# extract rest of source archives to correct paths
rest_sources = [self.old_rest_sources, self.new_rest_sources]
spec_files = [self.spec_file, self.rebase_spec_file]
sources_dirs = [settings.OLD_SOURCES_DIR, settings.NEW_SOURCES_DIR]
for sources, spec_file, sources_dir in zip(rest_sources, spec_files,
sources_dirs):
for rest in sources:
archive = [
x for x in Archive.get_supported_archives()
if rest.endswith(x)
]
if archive:
dest_dir = spec_file.find_archive_target_in_prep(rest)
if dest_dir:
Application.extract_sources(
rest,
os.path.join(self.execution_dir, sources_dir,
dest_dir))
return [old_dir, new_dir]
def extract_version_from_archive_name(archive_path, source_string=''):
"""
Method extracts the version from archive name based on the source string from SPEC file.
It extracts also an extra version such as 'b1', 'rc1', ...
:param archive_path: archive name or path with archive name from which to extract the version
:param source_string: Source string from SPEC file used to construct version extraction regex
:return: tuple of strings with (extracted version, extra version) or (None, None) if extraction failed
"""
# https://regexper.com/#(%5B.0-9%5D%2B%5B-_%5D%3F%5Cw*)
version_regex_str = '([.0-9]+[-_]?\w*)'
fallback_regex_str = '^\w+[-_]?v?{0}({1})'.format(version_regex_str,
'|'.join(Archive.get_supported_archives()))
# match = re.search(regex, tarball_name)
name = os.path.basename(archive_path)
url_base = os.path.basename(source_string).strip()
logger.debug("Extracting version from '%s' using '%s'", name, url_base)
# expect that the version macro can be followed by another macros
regex_str = re.sub(r'%{version}(%{.+})?', version_regex_str, url_base, flags=re.IGNORECASE)
# if no substitution was made, use the fallback regex
if regex_str == url_base:
logger.debug('Using fallback regex to extract version from archive name.')
regex_str = fallback_regex_str
else:
regex_str = rpm.expandMacro(regex_str)
logger.debug("Extracting version using regex '%s'", regex_str)
regex = re.compile(regex_str)
match = regex.search(name)
if match:
version = match.group(1)
logger.debug("Extracted version '%s'", version)
return SpecFile.split_version_string(version)
else:
logger.debug('Failed to extract version from archive name!')
# TODO: look at this if it could be rewritten in a better way!
# try fallback regex if not used this time
if regex_str != fallback_regex_str:
logger.debug("Trying to extracting version using fallback regex '%s'", fallback_regex_str)
regex = re.compile(fallback_regex_str)
match = regex.search(name)
if match:
version = match.group(1)
logger.debug("Extracted version '%s'", version)
return SpecFile.split_version_string(version)
else:
logger.debug('Failed to extract version from archive name using fallback regex!')
return SpecFile.split_version_string('')
def prepare_sources(self):
"""
Function prepares a sources.
:return:
"""
old_sources_dir = os.path.join(self.execution_dir, constants.WORKSPACE_DIR, constants.OLD_SOURCES_DIR)
new_sources_dir = os.path.join(self.execution_dir, constants.WORKSPACE_DIR, constants.NEW_SOURCES_DIR)
old_dir = Application.extract_sources(self.old_sources, old_sources_dir)
new_dir = Application.extract_sources(self.new_sources, new_sources_dir)
old_tld = os.path.relpath(old_dir, old_sources_dir)
new_tld = os.path.relpath(new_dir, new_sources_dir)
dirname = self.spec_file.get_setup_dirname()
if dirname and os.sep in dirname:
dirs = os.path.split(dirname)
if old_tld == dirs[0]:
old_dir = os.path.join(old_dir, *dirs[1:])
if new_tld == dirs[0]:
new_dir = os.path.join(new_dir, *dirs[1:])
new_dirname = os.path.relpath(new_dir, new_sources_dir)
if new_dirname != '.':
self.rebase_spec_file.update_setup_dirname(new_dirname)
# extract rest of source archives to correct paths
rest_sources = [self.old_rest_sources, self.new_rest_sources]
spec_files = [self.spec_file, self.rebase_spec_file]
sources_dirs = [
os.path.join(constants.WORKSPACE_DIR, constants.OLD_SOURCES_DIR),
os.path.join(constants.WORKSPACE_DIR, constants.NEW_SOURCES_DIR),
]
for sources, spec_file, sources_dir in zip(rest_sources, spec_files, sources_dirs):
for rest in sources:
archive = [x for x in Archive.get_supported_archives() if rest.endswith(x)]
if archive:
dest_dir = spec_file.find_archive_target_in_prep(rest)
if dest_dir:
Application.extract_sources(rest, os.path.join(self.execution_dir, sources_dir, dest_dir))
return [old_dir, new_dir]
def prepare_sources(self):
"""
Function prepares a sources.
:return:
"""
old_dir = Application.extract_sources(self.old_sources,
os.path.join(self.execution_dir, settings.OLD_SOURCES_DIR))
new_dir = Application.extract_sources(self.new_sources,
os.path.join(self.execution_dir, settings.NEW_SOURCES_DIR))
# This copies other sources to extracted sources marked as 0
for rest in self.rest_sources:
for source_dir in [old_dir, new_dir]:
archive = [x for x in Archive.get_supported_archives() if rest.endswith(x)]
# if the source is a remote file, download it
if archive:
Application.extract_sources(rest, os.path.join(self.execution_dir, source_dir))
return [old_dir, new_dir]
def _get_initial_sources_list(self):
"""Function returns all sources mentioned in SPEC file"""
# get all regular sources
sources = []
tar_sources = []
sources_list = [x for x in self.spc.sources if x[2] == 1]
remote_files_re = re.compile(r'(http:|https:|ftp:)//.*')
for index, src in enumerate(sorted(sources_list, key=lambda source: source[1])):
# src is type of (SOURCE, Index of source, Type of source (PAtch, Source)
# We need to download all archives and only the one
abs_path = os.path.join(self.sources_location, os.path.basename(src[0]).strip())
sources.append(abs_path)
archive = [x for x in Archive.get_supported_archives() if src[0].endswith(x)]
# if the source is a remote file, download it
if archive:
if remote_files_re.search(src[0]) and self.download:
DownloadHelper.download_file(src[0], abs_path)
tar_sources.append(abs_path)
return sources, tar_sources
def prepare_sources(self):
"""
Function prepares a sources.
:return:
"""
old_dir = Application.extract_sources(
self.old_sources,
os.path.join(self.execution_dir, settings.OLD_SOURCES_DIR))
new_dir = Application.extract_sources(
self.new_sources,
os.path.join(self.execution_dir, settings.NEW_SOURCES_DIR))
# determine top-level directory in new_sources archive
toplevel_dir = os.path.relpath(
new_dir, os.path.join(self.execution_dir,
settings.NEW_SOURCES_DIR))
if toplevel_dir != '.':
self.rebase_spec_file.update_setup_dirname(toplevel_dir)
# extract rest of source archives to correct paths
rest_sources = [self.old_rest_sources, self.new_rest_sources]
spec_files = [self.spec_file, self.rebase_spec_file]
sources_dirs = [settings.OLD_SOURCES_DIR, settings.NEW_SOURCES_DIR]
for sources, spec_file, sources_dir in zip(rest_sources, spec_files,
sources_dirs):
for rest in sources:
archive = [
x for x in Archive.get_supported_archives()
if rest.endswith(x)
]
if archive:
dest_dir = spec_file.find_archive_target_in_prep(rest)
if dest_dir:
Application.extract_sources(
rest,
os.path.join(self.execution_dir, sources_dir,
dest_dir))
return [old_dir, new_dir]
def extensions():
archives = Archive.get_supported_archives()
return [a.lstrip('.') for a in archives]
def extracted_archive(self, archive, workdir):
a = Archive(archive)
d = os.path.join(workdir, 'dir')
a.extract_archive(d)
return d
def test_invalid_archive(self, archive, workdir):
a = Archive(archive)
d = os.path.join(workdir, 'dir')
with pytest.raises(IOError):
a.extract_archive(d)
def extracted_archive(self, archive, workdir):
a = Archive(archive)
d = os.path.join(workdir, 'dir')
a.extract_archive(d)
return d
def _extract_sources(self, archive, dir_name):
archive = Archive(archive)
archive.extract_archive(dir_name)
def _prepare_spec_objects(self):
"""
Prepare spec files and initialize objects
:return:
"""
self.spec_file = SpecFile(self.spec_file_path, self.execution_dir,
self.kwargs['rpmmacros'])
# Check whether test suite is enabled at build time
if not self.spec_file.is_test_suite_enabled():
results_store.set_info_text(
'WARNING', 'Test suite is not enabled at build time.')
# create an object representing the rebased SPEC file
self.rebase_spec_file = self.spec_file.copy(
get_rebase_name(self.rebased_sources_dir, self.spec_file_path))
if not self.conf.sources:
self.conf.sources = plugin_manager.versioneers.run(
self.conf.versioneer, self.spec_file.header.name,
self.spec_file.category, self.conf.versioneer_blacklist)
if self.conf.sources:
logger.info("Determined latest upstream version '%s'",
self.conf.sources)
else:
raise RebaseHelperError(
'Could not determine latest upstream version '
'and no SOURCES argument specified!')
# Prepare rebased_sources_dir
self.rebased_repo = self._prepare_rebased_repository()
# check if argument passed as new source is a file or just a version
if [
True for ext in Archive.get_supported_archives()
if self.conf.sources.endswith(ext)
]:
logger.verbose("argument passed as a new source is a file")
version_string = self.spec_file.extract_version_from_archive_name(
self.conf.sources, self.spec_file.get_main_source())
else:
logger.verbose("argument passed as a new source is a version")
version_string = self.conf.sources
version, extra_version = SpecFile.split_version_string(
version_string, self.spec_file.header.version)
self.rebase_spec_file.set_version(version)
self.rebase_spec_file.set_extra_version(
extra_version, version != self.spec_file.header.version)
oldver = parse_version(self.spec_file.header.version)
newver = parse_version(self.rebase_spec_file.header.version)
oldex = self.spec_file.parse_release()[2]
newex = extra_version
if not self.conf.skip_version_check and (newver < oldver or
(newver == oldver
and newex == oldex)):
raise RebaseHelperError(
"Current version is equal to or newer than the requested version, nothing to do."
)
self.rebase_spec_file.update_changelog(self.conf.changelog_entry)
# run spec hooks
plugin_manager.spec_hooks.run(self.spec_file, self.rebase_spec_file,
**self.kwargs)
# spec file object has been sanitized downloading can proceed
if not self.conf.not_download_sources:
for spec_file in [self.spec_file, self.rebase_spec_file]:
spec_file.download_remote_sources()
# parse spec again with sources downloaded to properly expand %prep section
spec_file.update()
# all local sources have been downloaded; we can check for name changes
self._sanitize_sources()
def test_invalid_archive(self, archive, workdir):
a = Archive(archive)
d = os.path.join(workdir, 'dir')
with pytest.raises(IOError):
a.extract_archive(d)
def extensions():
archives = Archive.get_supported_archives()
return [a.lstrip('.') for a in archives]
