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 __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