def tgz(self):
"""
Override parent behavior, we need a tgz from the upstream spacewalk
project we're based on.
"""
# TODO: Wasteful step here, all we really need is a way to look for a
# spec file at the point in time this release was tagged.
NoTgzBuilder._setup_sources(self)
# If we knew what it was named at that point in time we could just do:
# Export a copy of our spec file at the revision to be built:
# cmd = "git show %s:%s%s > %s" % (self.git_commit_id,
# self.relative_project_dir, self.spec_file_name,
# self.spec_file)
# debug(cmd)
self._create_build_dirs()
self.upstream_version = self._get_upstream_version()
self.upstream_tag = "%s-%s-1" % (self.upstream_name,
self.upstream_version)
print("Building upstream tgz for tag [%s]" % (self.upstream_tag))
if self.upstream_tag != self.build_tag:
check_tag_exists(self.upstream_tag, offline=self.offline)
self.spec_file = os.path.join(self.rpmbuild_sourcedir,
self.spec_file_name)
command = "cp %s %s" % (os.path.join(self.rpmbuild_gitcopy,
self.spec_file_name), self.spec_file)
run_command(command)
# Create the upstream tgz:
prefix = "%s-%s" % (self.upstream_name, self.upstream_version)
tgz_filename = "%s.tar.gz" % prefix
commit = get_build_commit(tag=self.upstream_tag)
relative_dir = get_relative_project_dir(
project_name=self.upstream_name, commit=commit)
tgz_fullpath = os.path.join(self.rpmbuild_sourcedir, tgz_filename)
print("Creating %s from git tag: %s..." % (tgz_filename, commit))
create_tgz(self.git_root, prefix, commit, relative_dir,
tgz_fullpath)
self.ran_tgz = True
self.sources.append(tgz_fullpath)
# If these are equal then the tag we're building was likely created in
# Spacewalk and thus we don't need to do any patching.
if (self.upstream_tag == self.build_tag and not self.test):
return
self.patch_upstream()
def tgz(self):
"""
Override parent behavior, we need a tgz from the upstream spacewalk
project we're based on.
"""
# TODO: Wasteful step here, all we really need is a way to look for a
# spec file at the point in time this release was tagged.
NoTgzBuilder._setup_sources(self)
# If we knew what it was named at that point in time we could just do:
# Export a copy of our spec file at the revision to be built:
# cmd = "git show %s:%s%s > %s" % (self.git_commit_id,
# self.relative_project_dir, self.spec_file_name,
# self.spec_file)
# debug(cmd)
self._create_build_dirs()
self.upstream_version = self._get_upstream_version()
self.upstream_tag = "%s-%s-1" % (self.upstream_name,
self.upstream_version)
print("Building upstream tgz for tag [%s]" % (self.upstream_tag))
if self.upstream_tag != self.build_tag:
check_tag_exists(self.upstream_tag, offline=self.offline)
self.spec_file = os.path.join(self.rpmbuild_sourcedir,
self.spec_file_name)
command = "cp %s %s" % (os.path.join(self.rpmbuild_gitcopy,
self.spec_file_name), self.spec_file)
run_command(command)
# Create the upstream tgz:
prefix = "%s-%s" % (self.upstream_name, self.upstream_version)
tgz_filename = "%s.tar.gz" % prefix
commit = get_build_commit(tag=self.upstream_tag)
relative_dir = get_relative_project_dir(
project_name=self.upstream_name, commit=commit)
tgz_fullpath = os.path.join(self.rpmbuild_sourcedir, tgz_filename)
print("Creating %s from git tag: %s..." % (tgz_filename, commit))
create_tgz(self.git_root, prefix, commit, relative_dir,
tgz_fullpath)
self.ran_tgz = True
self.sources.append(tgz_fullpath)
# If these are equal then the tag we're building was likely created in
# Spacewalk and thus we don't need to do any patching.
if (self.upstream_tag == self.build_tag and not self.test):
return
self.patch_upstream()
def _read_project_config(self):
"""
Read project specific tito config if it exists.
If no tag is specified we use tito.props from the current HEAD.
If a tag is specified, we try to load a tito.props from that
tag.
"""
debug("Determined package name to be: %s" % self.package_name)
# Use the properties file in the current project directory, if it
# exists:
current_props_file = os.path.join(os.getcwd(), TITO_PROPS)
if (os.path.exists(current_props_file)):
self.config.read(current_props_file)
print("Loaded package specific tito.props overrides")
# Check for a tito.props back when this tag was created and use it
# instead. (if it exists)
if self.tag:
relative_dir = get_relative_project_dir(self.package_name, self.tag)
debug("Relative project dir: %s" % relative_dir)
cmd = "git show %s:%s%s" % (self.tag, relative_dir,
TITO_PROPS)
debug(cmd)
(status, output) = getstatusoutput(cmd)
if status == 0:
faux_config_file = FauxConfigFile(output)
self.config.read_fp(faux_config_file)
print("Loaded package specific tito.props overrides from %s" %
self.tag)
return
debug("Unable to locate package specific config for this package.")
def _read_project_config(self):
"""
Read project specific tito config if it exists.
If no tag is specified we use tito.props from the current HEAD.
If a tag is specified, we try to load a tito.props from that
tag.
"""
debug("Determined package name to be: %s" % self.package_name)
# Use the properties file in the current project directory, if it
# exists:
current_props_file = os.path.join(os.getcwd(), TITO_PROPS)
if (os.path.exists(current_props_file)):
self.config.read(current_props_file)
print("Loaded package specific tito.props overrides")
# Check for a tito.props back when this tag was created and use it
# instead. (if it exists)
if self.tag:
relative_dir = get_relative_project_dir(self.package_name,
self.tag)
debug("Relative project dir: %s" % relative_dir)
cmd = "git show %s:%s%s" % (self.tag, relative_dir, TITO_PROPS)
debug(cmd)
(status, output) = getstatusoutput(cmd)
if status == 0:
faux_config_file = FauxConfigFile(output)
self.config.read_fp(faux_config_file)
print("Loaded package specific tito.props overrides from %s" %
self.tag)
return
debug("Unable to locate package specific config for this package.")
def __init__(self, name=None, tag=None, build_dir=None,
config=None, user_config=None,
args=None, **kwargs):
"""
name - Package name that is being built.
version - Version and release being built.
tag - The git tag being built.
build_dir - Temporary build directory where we can safely work.
config - Merged configuration. (global plus package specific)
user_config - User configuration from ~/.titorc.
args - Optional arguments specific to each builder. Can be passed
in explicitly by user on the CLI, or via a release target config
entry. Only for things which vary on invocations of the builder,
avoid using these if possible. *Given in the format of a dictionary
of lists.*
"""
ConfigObject.__init__(self, config=config)
BuilderBase.__init__(self, name=name, build_dir=build_dir, config=config,
user_config=user_config, args=args, **kwargs)
self.build_tag = tag
self.build_version = self._get_build_version()
if kwargs and 'options' in kwargs:
warn_out("'options' no longer a supported builder constructor argument.")
if self.config.has_section("requirements"):
if self.config.has_option("requirements", "tito"):
if loose_version(self.config.get("requirements", "tito")) > \
loose_version(require('tito')[0].version):
error_out([
"tito version %s or later is needed to build this project." %
self.config.get("requirements", "tito"),
"Your version: %s" % require('tito')[0].version
])
self.display_version = self._get_display_version()
with chdir(find_git_root()):
self.git_commit_id = get_build_commit(tag=self.build_tag,
test=self.test)
self.relative_project_dir = get_relative_project_dir(
project_name=self.project_name, commit=self.git_commit_id)
if self.relative_project_dir is None and self.test:
warn_out(".tito/packages/%s doesn't exist "
"in git, using current directory" % self.project_name)
self.relative_project_dir = get_relative_project_dir_cwd(
self.git_root)
tgz_base = self._get_tgz_name_and_ver()
self.tgz_filename = tgz_base + ".tar.gz"
self.tgz_dir = tgz_base
self.artifacts = []
# A copy of the git code from commit we're building:
self.rpmbuild_gitcopy = os.path.join(self.rpmbuild_sourcedir,
self.tgz_dir)
# Used to make sure we only modify the spec file for a test build
# once. The srpm method may be called multiple times during koji
# releases to create the proper disttags, but we only want to modify
# the spec file once.
self.ran_setup_test_specfile = False
# NOTE: These are defined later when/if we actually dump a copy of the
# project source at the tag we're building. Only then can we search for
# a spec file.
self.spec_file_name = None
self.spec_file = None
# Set to path to srpm once we build one.
self.srpm_location = None
def __init__(self, name=None, tag=None, build_dir=None,
config=None, user_config=None,
args=None, **kwargs):
"""
name - Package name that is being built.
version - Version and release being built.
tag - The git tag being built.
build_dir - Temporary build directory where we can safely work.
config - Merged configuration. (global plus package specific)
user_config - User configuration from ~/.titorc.
args - Optional arguments specific to each builder. Can be passed
in explicitly by user on the CLI, or via a release target config
entry. Only for things which vary on invocations of the builder,
avoid using these if possible. *Given in the format of a dictionary
of lists.*
"""
ConfigObject.__init__(self, config=config)
BuilderBase.__init__(self, name=name, build_dir=build_dir, config=config,
user_config=user_config, args=args, **kwargs)
self.build_tag = tag
self.build_version = self._get_build_version()
if kwargs and 'options' in kwargs:
warn_out("'options' no longer a supported builder constructor argument.")
if self.config.has_section("requirements"):
if self.config.has_option("requirements", "tito"):
if loose_version(self.config.get("requirements", "tito")) > \
loose_version(require('tito')[0].version):
error_out([
"tito version %s or later is needed to build this project." %
self.config.get("requirements", "tito"),
"Your version: %s" % require('tito')[0].version
])
self.display_version = self._get_display_version()
with chdir(find_git_root()):
self.git_commit_id = get_build_commit(tag=self.build_tag,
test=self.test)
self.relative_project_dir = get_relative_project_dir(
project_name=self.project_name, commit=self.git_commit_id)
if self.relative_project_dir is None and self.test:
warn_out(".tito/packages/%s doesn't exist "
"in git, using current directory" % self.project_name)
self.relative_project_dir = get_relative_project_dir_cwd(
self.git_root)
tgz_base = self._get_tgz_name_and_ver()
self.tgz_filename = tgz_base + ".tar.gz"
self.tgz_dir = tgz_base
self.artifacts = []
# A copy of the git code from commit we're building:
self.rpmbuild_gitcopy = os.path.join(self.rpmbuild_sourcedir,
self.tgz_dir)
# Used to make sure we only modify the spec file for a test build
# once. The srpm method may be called multiple times during koji
# releases to create the proper disttags, but we only want to modify
# the spec file once.
self.ran_setup_test_specfile = False
# NOTE: These are defined later when/if we actually dump a copy of the
# project source at the tag we're building. Only then can we search for
# a spec file.
self.spec_file_name = None
self.spec_file = None
# Set to path to srpm once we build one.
self.srpm_location = None
def _read_project_config(self, project_name, build_dir, tag, no_cleanup):
"""
Read and return project build properties if they exist.
How to describe this process... we're looking for a tito.props or
build.py.props (legacy name) file in the project directory.
If we're operating on a specific tag, we're looking for these same
file's contents back at the time the tag was created. (which we write
out to a temp file and use instead of the current file contents)
To accomodate older tags prior to build.py, we also check for
the presence of a Makefile with NO_TAR_GZ, and include a hack to
assume build properties in this scenario.
If no project specific config can be found, settings come from the
global tito.props in rel-eng/.
"""
debug("Determined package name to be: %s" % project_name)
properties_file = None
wrote_temp_file = False
# Use the properties file in the current project directory, if it
# exists:
current_props_file = os.path.join(os.getcwd(), BUILD_PROPS_FILENAME)
if (os.path.exists(current_props_file)):
properties_file = current_props_file
else:
# HACK: Check for legacy build.py.props naming, needed to support
# older tags:
current_props_file = os.path.join(os.getcwd(),
"build.py.props")
if (os.path.exists(current_props_file)):
properties_file = current_props_file
# Check for a build.py.props back when this tag was created and use it
# instead. (if it exists)
if tag:
relative_dir = get_relative_project_dir(project_name, tag)
cmd = "git show %s:%s%s" % (tag, relative_dir,
BUILD_PROPS_FILENAME)
debug(cmd)
(status, output) = commands.getstatusoutput(cmd)
if status > 0:
# Give it another try looking for legacy props filename:
cmd = "git show %s:%s%s" % (tag, relative_dir,
"build.py.props")
debug(cmd)
(status, output) = commands.getstatusoutput(cmd)
temp_filename = "%s-%s" % (random.randint(1, 10000),
BUILD_PROPS_FILENAME)
temp_props_file = os.path.join(build_dir, temp_filename)
if status == 0:
properties_file = temp_props_file
f = open(properties_file, 'w')
f.write(output)
f.close()
wrote_temp_file = True
else:
# HACK: No build.py.props found, but to accomodate packages
# tagged before they existed, check for a Makefile with
# NO_TAR_GZ defined and make some assumptions based on that.
cmd = "git show %s:%s%s | grep NO_TAR_GZ" % \
(tag, relative_dir, "Makefile")
debug(cmd)
(status, output) = commands.getstatusoutput(cmd)
if status == 0 and output != "":
properties_file = temp_props_file
debug("Found Makefile with NO_TAR_GZ")
f = open(properties_file, 'w')
f.write(ASSUMED_NO_TAR_GZ_PROPS)
f.close()
wrote_temp_file = True
config = ConfigParser.ConfigParser()
if properties_file != None:
debug("Using build properties: %s" % properties_file)
config.read(properties_file)
else:
debug("Unable to locate custom build properties for this package.")
debug(" Using global.tito.props")
# TODO: Not thrilled with this:
if wrote_temp_file and not no_cleanup:
# Delete the temp properties file we created.
run_command("rm %s" % properties_file)
return config
