Move target directory to Config

Many different components require the target download path and it is
needed early. Previously code existed to attempt to autodetect its
location and so defining the path was enforced later in the build
process. This created problems with ordering functions based on this
requirement but since the target path is now certain to be defined at
startup (due to previous changes) we can better align the location and
initialization of the data to the Config class.

As part of this change also avoid requiring the temporary working
directory to be setup as part of the Build class. This is done as a
cleanup due to the only real user of this location being the Content
class.

This also drops the stand-alone pkg_integrety main function that was
initially used as a one off test to avoid needing to run autospec to
validate the integrity of a package. This feature was seldom used and
doesn't function well without handling configuration so it was
dropped.

Author: bryteise

autospec/autospec.py

@@ -241,6 +241,7 @@ def main():
             "even number of arguments"))
 
     if args.prep_only:
+        os.makedirs("workingdir", exists_ok=True)
         package(args, url, name, archives, "./workingdir", infile_dict)
     else:
         with tempfile.TemporaryDirectory() as workingdir:
@@ -249,25 +250,25 @@ def main():
 
 def package(args, url, name, archives, workingdir, infile_dict):
     """Entry point for building a package with autospec."""
-    conf = config.Config()
+    conf = config.Config(args.target)
     check_requirements(args.git)
-    package = build.Build(workingdir)
+    package = build.Build()
 
     #
     # First, download the tarball, extract it and then do a set
     # of static analysis on the content of the tarball.
     #
     filemanager = files.FileManager(conf, package)
-    content = tarball.Content(url, name, args.version, archives, conf)
-    content.process(args.target, filemanager)
-    conf.create_versions(package.download_path, content.multi_version)
+    content = tarball.Content(url, name, args.version, archives, conf, workingdir)
+    content.process(filemanager)
+    conf.create_versions(content.multi_version)
     conf.content = content  # hack to avoid recursive dependency on init
     # Search up one level from here to capture multiple versions
     _dir = content.path
 
     if args.license_only:
         try:
-            with open(os.path.join(package.download_path,
+            with open(os.path.join(conf.download_path,
                                    content.name + ".license"), "r") as dotlic:
                 for word in dotlic.read().split():
                     if ":" not in word:
@@ -282,20 +283,20 @@ def package(args, url, name, archives, workingdir, infile_dict):
     conf.config_file = args.config
     requirements = buildreq.Requirements(content.url)
     requirements.set_build_req()
-    conf.parse_config_files(package.download_path, args.bump, filemanager, content.version, requirements)
+    conf.parse_config_files(args.bump, filemanager, content.version, requirements)
     conf.setup_patterns(conf.failed_pattern_dir)
-    conf.parse_existing_spec(package.download_path, content.name)
+    conf.parse_existing_spec(content.name)
 
     if args.prep_only:
         write_prep(conf, workingdir, content)
         exit(0)
 
-    requirements.scan_for_configure(_dir, content.name, package.download_path, conf)
+    requirements.scan_for_configure(_dir, content.name, conf)
     specdescription.scan_for_description(content.name, _dir, conf.license_translations, conf.license_blacklist)
     # Start one directory higher so we scan *all* versions for licenses
     license.scan_for_licenses(os.path.dirname(_dir), conf, content.name)
-    commitmessage.scan_for_changes(package.download_path, _dir, conf.transforms)
-    add_sources(package.download_path, archives, content)
+    commitmessage.scan_for_changes(conf.download_path, _dir, conf.transforms)
+    add_sources(conf.download_path, archives, content)
     check.scan_for_tests(_dir, conf, requirements, content)
 
     #
@@ -323,14 +324,14 @@ def package(args, url, name, archives, workingdir, infile_dict):
 
     if args.integrity:
         interactive_mode = not args.non_interactive
-        pkg_integrity.check(url, package.download_path, conf, interactive=interactive_mode)
+        pkg_integrity.check(url, conf, interactive=interactive_mode)
         pkg_integrity.load_specfile(specfile)
 
-    specfile.write_spec(package.download_path)
+    specfile.write_spec()
     while 1:
         package.package(filemanager, args.mock_config, args.mock_opts, conf, requirements, content, args.cleanup)
         filemanager.load_specfile(specfile)
-        specfile.write_spec(package.download_path)
+        specfile.write_spec()
         filemanager.newfiles_printed = 0
         mock_chroot = "/var/lib/mock/clear-{}/root/builddir/build/BUILDROOT/" \
                       "{}-{}-{}.x86_64".format(package.uniqueext,
@@ -344,12 +345,12 @@ def package(args, url, name, archives, workingdir, infile_dict):
         if package.round > 20 or package.must_restart == 0:
             break
 
-        save_mock_logs(package.download_path, package.round)
+        save_mock_logs(conf.download_path, package.round)
 
-    check.check_regression(package.download_path, conf.config_opts['skip_tests'])
+    check.check_regression(conf.download_path, conf.config_opts['skip_tests'])
 
     if package.success == 0:
-        conf.create_buildreq_cache(package.download_path, content.version, requirements.buildreqs_cache)
+        conf.create_buildreq_cache(content.version, requirements.buildreqs_cache)
         print_fatal("Build failed, aborting")
         sys.exit(1)
     elif os.path.isfile("README.clear"):
@@ -363,20 +364,20 @@ def package(args, url, name, archives, workingdir, infile_dict):
         except Exception:
             pass
 
-    examine_abi(package.download_path, content.name)
+    examine_abi(conf.download_path, content.name)
     if os.path.exists("/var/lib/rpm"):
         pkg_scan.get_whatrequires(content.name, conf.yum_conf)
 
-    write_out(package.download_path + "/release", content.release + "\n")
+    write_out(conf.download_path + "/release", content.release + "\n")
 
     # record logcheck output
-    logcheck(package.download_path)
+    logcheck(conf.download_path)
 
-    commitmessage.guess_commit_message(pkg_integrity.IMPORTED, conf, content, package)
-    conf.create_buildreq_cache(package.download_path, content.version, requirements.buildreqs_cache)
+    commitmessage.guess_commit_message(pkg_integrity.IMPORTED, conf, content)
+    conf.create_buildreq_cache(content.version, requirements.buildreqs_cache)
 
     if args.git:
-        git.commit_to_git(package.download_path, conf, content.name, package.success)
+        git.commit_to_git(conf, content.name, package.success)
     else:
         print("To commit your changes, git add the relevant files and "
               "run 'git commit -F commitmsg'")

autospec/build.py

@@ -82,13 +82,11 @@ def get_mock_cmd():
 class Build(object):
     """Manage package builds."""
 
-    def __init__(self, base_path):
+    def __init__(self):
         """Initialize default build settings."""
         self.success = 0
         self.round = 0
         self.must_restart = 0
-        self.base_path = base_path
-        self.download_path = None
         self.uniqueext = ''
         self.warned_about = set()
 
@@ -272,8 +270,8 @@ def package(self, filemanager, mockconfig, mockopts, config, requirements, conte
         print("{} mock chroot at /var/lib/mock/clear-{}".format(content.name, self.uniqueext))
 
         if self.round == 1:
-            shutil.rmtree('{}/results'.format(self.download_path), ignore_errors=True)
-            os.makedirs('{}/results'.format(self.download_path))
+            shutil.rmtree('{}/results'.format(config.download_path), ignore_errors=True)
+            os.makedirs('{}/results'.format(config.download_path))
 
         cmd_args = [
             mock_cmd,
@@ -287,12 +285,12 @@ def package(self, filemanager, mockconfig, mockopts, config, requirements, conte
             mockopts,
         ]
         util.call(" ".join(cmd_args),
-                  logfile=f"{self.download_path}/results/mock_srpm.log",
-                  cwd=self.download_path)
+                  logfile=f"{config.download_path}/results/mock_srpm.log",
+                  cwd=config.download_path)
 
         # back up srpm mock logs
-        util.call("mv results/root.log results/srpm-root.log", cwd=self.download_path)
-        util.call("mv results/build.log results/srpm-build.log", cwd=self.download_path)
+        util.call("mv results/root.log results/srpm-root.log", cwd=config.download_path)
+        util.call("mv results/build.log results/srpm-build.log", cwd=config.download_path)
 
         srcrpm = f"results/{content.name}-{content.version}-{content.release}.src.rpm"
 
@@ -307,18 +305,18 @@ def package(self, filemanager, mockconfig, mockopts, config, requirements, conte
             mockopts,
         ]
         ret = util.call(" ".join(cmd_args),
-                        logfile=f"{self.download_path}/results/mock_build.log",
+                        logfile=f"{config.download_path}/results/mock_build.log",
                         check=False,
-                        cwd=self.download_path)
+                        cwd=config.download_path)
 
         # sanity check the build log
-        if not os.path.exists(self.download_path + "/results/build.log"):
+        if not os.path.exists(config.download_path + "/results/build.log"):
             util.print_fatal("Mock command failed, results log does not exist. User may not have correct permissions.")
             exit(1)
 
-        is_clean = self.parse_buildroot_log(self.download_path + "/results/root.log", ret)
+        is_clean = self.parse_buildroot_log(config.download_path + "/results/root.log", ret)
         if is_clean:
-            self.parse_build_results(self.download_path + "/results/build.log", ret, filemanager, config, requirements, content)
+            self.parse_build_results(config.download_path + "/results/build.log", ret, filemanager, config, requirements, content)
         if filemanager.has_banned:
             util.print_fatal("Content in banned paths found, aborting build")
             exit(1)

autospec/buildreq.py

@@ -750,7 +750,7 @@ def parse_catkin_deps(self, cmakelists_file, conf32):
             self.extra_cmake.add("-DCATKIN_BUILD_BINARY_PACKAGE=ON")
             self.extra_cmake.add("-DSETUPTOOLS_DEB_LAYOUT=OFF")
 
-    def scan_for_configure(self, dirn, tname, dlpath, config):
+    def scan_for_configure(self, dirn, tname, config):
         """Scan the package directory for build files to determine build pattern."""
         if buildpattern.default_pattern == "distutils36":
             self.add_buildreq("buildreq-distutils36")
@@ -876,7 +876,7 @@ def scan_for_configure(self, dirn, tname, dlpath, config):
         if buildpattern.default_pattern == "distutils3":
             # First look for a local override
             pypi_json = ""
-            pypi_file = os.path.join(dlpath, "pypi.json")
+            pypi_file = os.path.join(config.download_path, "pypi.json")
             if os.path.isfile(pypi_file):
                 with open(pypi_file, "r") as pfile:
                     pypi_json = pfile.read()

autospec/commitmessage.py

@@ -216,7 +216,7 @@ def process_git(giturl, oldversion, newversion, name):
         return shortlog
 
 
-def guess_commit_message(keyinfo, config, content, package):
+def guess_commit_message(keyinfo, config, content):
     """Parse newsfile for a commit message.
 
     Try and find a sane commit message for the newsfile. The commit message defaults to the
@@ -268,14 +268,14 @@ def guess_commit_message(keyinfo, config, content, package):
         newsfiles = ["NEWS", "ChangeLog"]
     for newsfile in newsfiles:
         # parse news files for relevant version updates and cve fixes
-        newcommitmessage, newcves = process_NEWS(newsfile, config.old_version, content.name, content.version, package.download_path)
+        newcommitmessage, newcves = process_NEWS(newsfile, config.old_version, content.name, content.version, config.download_path)
         commitmessage.extend(newcommitmessage)
         cves.update(newcves)
 
     if cves:
         # make the package security sensitive if a CVE was patched
         config.config_opts['security_sensitive'] = True
-        config.rewrite_config_opts(package.base_path)
+        config.rewrite_config_opts()
         # append CVE fixes to end of commit message
         commitmessage.append("CVEs fixed in this build:")
         commitmessage.extend(sorted(list(cves)))
@@ -284,7 +284,7 @@ def guess_commit_message(keyinfo, config, content, package):
     if keyinfo:
         commitmessage.append("Key imported:\n{}".format(keyinfo))
 
-    util.write_out(os.path.join(package.download_path, "commitmsg"),
+    util.write_out(os.path.join(config.download_path, "commitmsg"),
                    "\n".join(commitmessage) + "\n")
 
     print("Guessed commit message:")