def _get_build_version(self):
"""
Figure out the git tag and version-release we're building.
"""
# Determine which package version we should build:
build_version = None
if self.build_tag:
build_version = self.build_tag[len(self.project_name + "-"):]
else:
build_version = get_latest_tagged_version(self.project_name)
if build_version is None:
if not self.test:
error_out([
"Unable to lookup latest package info.",
"Perhaps you need to tag first?"
])
sys.stderr.write("WARNING: unable to lookup latest package "
"tag, building untagged test project\n")
build_version = get_spec_version_and_release(
self.start_dir, find_spec_file(in_dir=self.start_dir))
self.build_tag = "v%s" % (build_version)
if not self.test:
check_tag_exists(self.build_tag, offline=self.offline)
return build_version
def __init__(self,
name=None,
tag=None,
build_dir=None,
config=None,
user_config=None,
args=None,
**kwargs):
BuilderBase.__init__(self,
name=name,
build_dir=build_dir,
config=config,
user_config=user_config,
args=args,
**kwargs)
if tag:
error_out("FetchBuilder does not support building "
"specific tags.")
if not config.has_option("builder", "fetch_strategy"):
print("WARNING: no fetch_strategy specified in tito.props"
", assuming ArgSourceStrategy.")
if not config.has_section("builder"):
config.add_section("builder")
config.set('builder', 'fetch_strategy',
'tito.builder.fetch.ArgSourceStrategy')
self.build_tag = '%s-%s' % (self.project_name,
get_spec_version_and_release(
self.start_dir,
'%s.spec' % self.project_name))
def _bump_version(self, release=False, zstream=False):
"""
Bump up the package version in the spec file.
Set release to True to bump the package release instead.
Checks for the keep version option and if found, won't actually
bump the version or release.
"""
old_version = get_latest_tagged_version(self.project_name)
if old_version is None:
old_version = "untagged"
if not self.keep_version:
version_regex = re.compile("^(version:\s*)(.+)$", re.IGNORECASE)
release_regex = re.compile("^(release:\s*)(.+)$", re.IGNORECASE)
in_f = open(self.spec_file, 'r')
out_f = open(self.spec_file + ".new", 'w')
for line in in_f.readlines():
version_match = re.match(version_regex, line)
release_match = re.match(release_regex, line)
if version_match and not zstream and not release:
current_version = version_match.group(2)
if hasattr(self, '_use_version'):
updated_content = self._use_version
else:
updated_content = increase_version(current_version)
line = "".join([version_match.group(1), updated_content, "\n"])
elif release_match:
current_release = release_match.group(2)
if hasattr(self, '_use_release'):
updated_content = self._use_release
elif release:
updated_content = increase_version(current_release)
elif zstream:
updated_content = increase_zstream(current_release)
else:
updated_content = reset_release(current_release)
line = "".join([release_match.group(1), updated_content, "\n"])
out_f.write(line)
in_f.close()
out_f.close()
shutil.move(self.spec_file + ".new", self.spec_file)
new_version = get_spec_version_and_release(self.full_project_dir,
self.spec_file_name)
if new_version.strip() == "":
msg = "Error getting bumped package version, try: \n"
msg = msg + " 'rpm -q --specfile %s'" % self.spec_file
error_out(msg)
info_out("Tagging new version of %s: %s -> %s" % (self.project_name,
old_version, new_version))
return new_version
def _get_build_version(self):
"""
Figure out the git tag and version-release we're building.
"""
# Determine which package version we should build:
build_version = None
if self.build_tag:
build_version = self.build_tag[len(self.project_name + "-"):]
else:
build_version = get_latest_tagged_version(self.project_name)
if build_version is None:
if not self.test:
error_out(["Unable to lookup latest package info.",
"Perhaps you need to tag first?"])
warn_out("unable to lookup latest package "
"tag, building untagged test project")
build_version = get_spec_version_and_release(self.start_dir,
find_spec_like_file(self.start_dir))
self.build_tag = "%s-%s" % (self.project_name, build_version)
self.spec_version = build_version.split('-')[-2]
self.spec_release = build_version.split('-')[-1]
if not self.test:
check_tag_exists(self.build_tag, offline=self.offline)
return build_version
def _get_build_version(self):
"""
Figure out the git tag and version-release we're building.
"""
# Determine which package version we should build:
build_version = None
if self.build_tag:
build_version = self.build_tag[len(self.project_name + "-"):]
else:
build_version = get_latest_tagged_version(self.project_name)
if build_version is None:
if not self.test:
error_out(["Unable to lookup latest package info.",
"Perhaps you need to tag first?"])
warn_out("unable to lookup latest package "
"tag, building untagged test project")
build_version = get_spec_version_and_release(self.start_dir,
find_spec_like_file(self.start_dir))
self.build_tag = "%s-%s" % (self.project_name, build_version)
self.spec_version = build_version.split('-')[-2]
self.spec_release = build_version.split('-')[-1]
if not self.test:
check_tag_exists(self.build_tag, offline=self.offline)
return build_version
def _bump_version(self, release=False, zstream=False):
"""
Bump up the package version in the spec file.
Set release to True to bump the package release instead.
Checks for the keep version option and if found, won't actually
bump the version or release.
"""
old_version = get_latest_tagged_version(self.project_name)
if old_version is None:
old_version = "untagged"
if not self.keep_version:
version_regex = re.compile("^(version:\s*)(.+)$", re.IGNORECASE)
release_regex = re.compile("^(release:\s*)(.+)$", re.IGNORECASE)
in_f = open(self.spec_file, 'r')
out_f = open(self.spec_file + ".new", 'w')
for line in in_f.readlines():
version_match = re.match(version_regex, line)
release_match = re.match(release_regex, line)
if version_match and not zstream and not release:
current_version = version_match.group(2)
if hasattr(self, '_use_version'):
updated_content = self._use_version
else:
updated_content = increase_version(current_version)
line = "".join([version_match.group(1), updated_content, "\n"])
elif release_match:
current_release = release_match.group(2)
if hasattr(self, '_use_release'):
updated_content = self._use_release
elif release:
updated_content = increase_version(current_release)
elif zstream:
updated_content = increase_zstream(current_release)
else:
updated_content = reset_release(current_release)
line = "".join([release_match.group(1), updated_content, "\n"])
out_f.write(line)
in_f.close()
out_f.close()
shutil.move(self.spec_file + ".new", self.spec_file)
new_version = get_spec_version_and_release(self.full_project_dir,
self.spec_file_name)
if new_version.strip() == "":
msg = "Error getting bumped package version, try: \n"
msg = msg + " 'rpm -q --specfile %s'" % self.spec_file
error_out(msg)
info_out("Tagging new version of %s: %s -> %s" % (self.project_name,
old_version, new_version))
return new_version
def __init__(self,
name=None,
tag=None,
build_dir=None,
config=None,
user_config=None,
args=None,
**kwargs):
BuilderBase.__init__(self,
name=name,
build_dir=build_dir,
config=config,
user_config=user_config,
args=args,
**kwargs)
if tag:
error_out("FetchBuilder does not support building specific tags.")
if not config.has_option('builder', 'fetch_prep_command'):
error_out("NativeFetchBuilder requires fetch_prep_command.")
self.build_tag = '%s-%s' % (self.project_name,
get_spec_version_and_release(
self.start_dir,
'%s.spec' % self.project_name))
def _get_build_version(self):
self.spec_version = ''
self.spec_release = ''
build_version = get_spec_version_and_release(
self.start_dir, find_spec_like_file(self.start_dir))
self.build_tag = build_version
return build_version
def _bump_version(self, release=False, zstream=False):
"""
Bump version in main and Fedora spec file
Version and Release in Fedora spec file are always updated accordingly to main spec file
"""
# Version and Release without dist tag
old_version, old_release = get_spec_version_and_release(
self.full_project_dir, self.spec_file_name).split('-')
old_release += '%{?dist}'
new_version = super(RestraintVersionTagger,
self)._bump_version(release, zstream)
if not self.keep_version:
version_regex = re.compile("^(version:\s*)(.+)$", re.IGNORECASE)
release_regex = re.compile("^(release:\s*)(.+)$", re.IGNORECASE)
in_f = open(self.fedora_spec_file, 'r')
out_f = open(self.fedora_spec_file + ".new", 'w')
for line in in_f.readlines():
version_match = re.match(version_regex, line)
release_match = re.match(release_regex, line)
if version_match and not zstream and not release:
if hasattr(self, '_use_version'):
updated_content = self._use_version
else:
updated_content = increase_version(old_version)
line = "".join(
[version_match.group(1), updated_content, "\n"])
elif release_match:
if hasattr(self, '_use_release'):
updated_content = self._use_release
elif release:
updated_content = increase_version(old_release)
elif zstream:
updated_content = increase_zstream(old_release)
else:
updated_content = reset_release(old_release)
line = "".join(
[release_match.group(1), updated_content, "\n"])
out_f.write(line)
in_f.close()
out_f.close()
shutil.move(self.fedora_spec_file + ".new", self.fedora_spec_file)
return new_version
def _get_build_version(self):
"""
Figure out the git tag and version-release we're building.
"""
# Determine which package version we should build:
build_version = None
if self.build_tag:
build_version = self.build_tag[len(self.project_name + "-"):]
else:
build_version = get_spec_version_and_release(
self.start_dir, find_spec_like_file(self.start_dir))
self.build_tag = self._get_tag_for_version(build_version)
self.spec_version = build_version.split('-')[0]
self.spec_release = build_version.split('-')[-1]
return build_version
def __init__(self, name=None, tag=None, build_dir=None,
config=None, user_config=None,
args=None, **kwargs):
BuilderBase.__init__(self, name=name, build_dir=build_dir,
config=config,
user_config=user_config, args=args, **kwargs)
if tag:
error_out("FetchBuilder does not support building specific tags.")
if not config.has_option('builder', 'fetch_prep_command'):
error_out("NativeFetchBuilder requires fetch_prep_command.")
self.build_tag = '%s-%s' % (
self.project_name,
get_spec_version_and_release(self.start_dir,
'%s.spec' % self.project_name)
)
def __init__(self, name=None, tag=None, build_dir=None, config=None, user_config=None, args=None, **kwargs):
BuilderBase.__init__(
self, name=name, build_dir=build_dir, config=config, user_config=user_config, args=args, **kwargs
)
if tag:
error_out("FetchBuilder does not support building " "specific tags.")
if not config.has_option("builder", "fetch_strategy"):
print("WARNING: no fetch_strategy specified in tito.props" ", assuming ArgSourceStrategy.")
if not config.has_section("builder"):
config.add_section("builder")
config.set("builder", "fetch_strategy", "tito.builder.fetch.ArgSourceStrategy")
self.build_tag = "%s-%s" % (
self.project_name,
get_spec_version_and_release(self.start_dir, "%s.spec" % self.project_name),
)
def _get_build_version(self):
"""
Figure out the git tag and version-release we're building.
"""
# Determine which package version we should build:
build_version = None
if self.build_tag:
build_version = self.build_tag[len(self.project_name + "-") :]
else:
build_version = get_latest_tagged_version(self.project_name)
if build_version is None:
if not self.test:
error_out(["Unable to lookup latest package info.", "Perhaps you need to tag first?"])
sys.stderr.write("WARNING: unable to lookup latest package " "tag, building untagged test project\n")
build_version = get_spec_version_and_release(self.start_dir, find_spec_file(in_dir=self.start_dir))
self.build_tag = "v{0}".format(build_version)
if not self.test:
check_tag_exists(self.build_tag, offline=self.offline)
return build_version
def _get_spec_version_and_release(self):
""" Get the package version from the spec file. """
return get_spec_version_and_release(self.full_project_dir,
self.spec_file_name)
