Merge ~mwhudson/ubuntu-cdimage:simplify-germinate into ubuntu-cdimage:main

[Michael Hudson-Doyle]

This strips out I think all of the unnecessary complexity in ubuntu-cdimage's germinate code that can be stripped without making changes to the debian-cd end of things.

It is perhaps too much to land in one big hit but well. Look at that diffstat!!

Probably best to review commit by commit.

[Steve Langasek (vorlon)]

review: Needs Fixing

[Steve Langasek (vorlon)]

review: Approve

diff --git a/bin/cron.daily b/bin/cron.daily
deleted file mode 100755
index d205b69..0000000
--- a/bin/cron.daily
+++ /dev/null
@@ -1,46 +0,0 @@
-#! /usr/bin/python3
-
-# Copyright (C) 2013 Canonical Ltd.
-# Author: Colin Watson <[e-mail]>
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; version 3 of the License.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-"""Build a set of alternate/server images."""
-
-from optparse import OptionParser
-import os
-import sys
-
-sys.path.insert(0, os.path.join(sys.path[0], os.pardir, "lib"))
-
-
-def main():
-    from cdimage.build import build_image_set
-    from cdimage.config import Config
-
-    parser = OptionParser("%prog")
-    parser.add_option(
-        "--live", default=False, action="store_true",
-        help="build live filesystems first")
-    options, _ = parser.parse_args()
-    config = Config(IMAGE_TYPE="daily")
-    config["CDIMAGE_INSTALL"] = "1"
-    project = config.project
-    if project == "ubuntu-server" and not config["CDIMAGE_NO_SQUASHFS_BASE"]:
-        config["CDIMAGE_SQUASHFS_BASE"] = "1"
-    if not build_image_set(config, options):
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/bin/cron.dvd b/bin/cron.dvd
index 3732b09..5566973 100755
--- a/bin/cron.dvd
+++ b/bin/cron.dvd
@@ -36,7 +36,8 @@ def main():
     config = Config(IMAGE_TYPE="dvd")
     project = config.project
     if project not in ("ubuntu", "ubuntustudio"):
-        config["CDIMAGE_INSTALL"] = "1"
+        print("unsupported configuration!")
+        sys.exit(1)
     config["CDIMAGE_LIVE"] = "1"
     config["CDIMAGE_DVD"] = "1"
     if not build_image_set(config, options):
diff --git a/lib/cdimage/build.py b/lib/cdimage/build.py
index cbc07d4..edd53db 100644
--- a/lib/cdimage/build.py
+++ b/lib/cdimage/build.py
@@ -30,7 +30,6 @@ import traceback
 
 from cdimage import osextras
 from cdimage.build_id import next_build_id
-from cdimage.check_installable import check_installable
 from cdimage.germinate import Germination
 from cdimage.livefs import (
     LiveBuildsFailed,
@@ -88,9 +87,6 @@ def configure_for_project(config):
     ):
         config["CDIMAGE_UNSUPPORTED"] = "1"
 
-    if config["CDIMAGE_INSTALL"]:
-        config["CDIMAGE_INSTALL_BASE"] = "1"
-
 
 def open_log(config):
     if config["DEBUG"] or config["CDIMAGE_NOLOG"]:
@@ -661,7 +657,7 @@ def build_image_set_locked(config, options):
             log_marker("Checking for other task changes")
             germinate_output.update_tasks(date)
 
-            if (config["CDIMAGE_LIVE"] or config["CDIMAGE_SQUASHFS_BASE"]):
+            if config["CDIMAGE_LIVE"]:
                 log_marker("Downloading live filesystem images")
                 download_live_filesystems(config, builds)
 
@@ -671,13 +667,6 @@ def build_image_set_locked(config, options):
             copy_netboot_tarballs(config)
             fix_permissions(config)
 
-        # Temporarily turned off for live builds.
-        if (config["CDIMAGE_INSTALL_BASE"] and
-                not config["CDIMAGE_ADDON"] and
-                not config["CDIMAGE_PREINSTALLED"]):
-            log_marker("Producing installability report")
-            check_installable(config)
-
         if not config["DEBUG"] and not config["CDIMAGE_NOPUBLISH"]:
             log_marker("Publishing")
             tree = Tree.get_daily(config)
diff --git a/lib/cdimage/check_installable.py b/lib/cdimage/check_installable.py
index 62cbfc6..0aff60e 100644
--- a/lib/cdimage/check_installable.py
+++ b/lib/cdimage/check_installable.py
@@ -60,23 +60,6 @@ def _prepare_check_installable(config):
 
         packages = os.path.join(data, "Packages_%s" % arch)
         with open(packages, "wb") as packages_file:
-            if config["CDIMAGE_SQUASHFS_BASE"]:
-                squashfs = os.path.join(live, "%s.squashfs" % fullarch)
-                if os.path.exists(squashfs):
-                    _ensure_tempdir()
-                    with open("/dev/null", "w") as devnull:
-                        subprocess.check_call([
-                            "unsquashfs",
-                            "-d", os.path.join(_tempdir, fullarch),
-                            squashfs, "/var/lib/dpkg/status",
-                        ], stdout=devnull)
-                    status_path = os.path.join(
-                        _tempdir, fullarch, "var", "lib", "dpkg", "status")
-                    with open(os.path.join(status_path)) as status:
-                        subprocess.call([
-                            "grep-dctrl", "-XFStatus", "install ok installed",
-                        ], stdin=status, stdout=packages_file)
-
             for component in "main", "restricted", "universe", "multiverse":
                 packages_gz = os.path.join(
                     image_top, "%s-%s" % (config.series, fullarch), "CD1",
diff --git a/lib/cdimage/germinate.py b/lib/cdimage/germinate.py
index dcc5e88..004e2a3 100644
--- a/lib/cdimage/germinate.py
+++ b/lib/cdimage/germinate.py
@@ -17,10 +17,7 @@
 
 from __future__ import print_function
 
-from collections import OrderedDict, defaultdict
-import errno
 import os
-import re
 import shutil
 import subprocess
 import traceback
@@ -47,13 +44,9 @@ class Germination:
 
     @property
     def germinate_path(self):
-        paths = [
-            os.path.join(self.config.root, "germinate", "bin", "germinate"),
-            os.path.join(self.config.root, "germinate", "germinate.py"),
-        ]
-        for path in paths:
-            if os.access(path, os.X_OK):
-                return path
+        path = os.path.join(self.config.root, "germinate", "bin", "germinate")
+        if os.access(path, os.X_OK):
+            return path
         else:
             raise GerminateNotInstalled(
                 "Please check out lp:germinate in %s." %
@@ -192,12 +185,6 @@ class NoMasterSeeds(Exception):
     pass
 
 
-re_not_base = re.compile(
-    r"^(linux-(image|restricted|amd64|386|686|k7|power|"
-    r"imx51|dove|omap).*|"
-    r"nvidia-kernel-common|grub|yaboot|efibootmgr|elilo|silo|palo)$")
-
-
 class GerminateOutput:
     def __init__(self, config, directory):
         self.config = config
@@ -206,102 +193,30 @@ class GerminateOutput:
         self._parse_structure()
 
     def _parse_structure(self):
-        self._seeds = OrderedDict()
+        self._seeds = []
         with open(self.structure) as structure:
             for line in structure:
                 line = line.strip()
                 if not line or line.startswith("#") or ":" not in line:
                     continue
-                seed, inherit = line.split(":", 1)
-                self._seeds[seed] = inherit.split()
-
-    def _expand_inheritance(self, seed, inherit):
-        for s in self._seeds.get(seed, ()):
-            self._expand_inheritance(s, inherit)
-        if seed not in inherit:
-            inherit.append(seed)
-
-    def _inheritance(self, seed):
-        inherit = []
-        self._expand_inheritance(seed, inherit)
-        return inherit
-
-    def _without_inheritance(self, subtract, seeds):
-        subtract_inherit = self._inheritance(subtract)
-        remaining = set(seeds) - set(subtract_inherit)
-        return [seed for seed in seeds if seed in remaining]
-
-    def list_seeds(self, mode):
+                self._seeds.append(line.split(":", 1)[0])
+
+    def pool_seeds(self):
+        if not (self.config["CDIMAGE_DVD"] or self.config["CDIMAGE_LIVE"]):
+            raise NoMasterSeeds("No seeds found for master task!")
         project = self.config.project
-        series = self.config["DIST"]
 
-        if mode == "all":
-            for seed in self._seeds:
-                yield seed
-        elif mode == "tasks":
-            ship = "ship"
-            if "ship-addon" in self._seeds:
-                ship = "ship-addon"
-            in_squashfs = None
-            if project == "ubuntu-server":
-                ship = "server-ship"
-                in_squashfs = ["minimal"]
-            seeds = self._inheritance(ship)
-            if (self.config["CDIMAGE_SQUASHFS_BASE"] and
-                    in_squashfs is not None):
-                for subtract in in_squashfs:
-                    seeds = self._without_inheritance(subtract, seeds)
-            for seed in seeds:
-                yield seed
-            if self.config["CDIMAGE_DVD"]:
-                # TODO cjwatson 2007-04-18: hideous hack to fix DVD tasks
-                yield "dns-server"
-                yield "lamp-server"
-        elif mode == "installer":
-            if self.config["CDIMAGE_INSTALL_BASE"]:
-                yield "installer"
-        elif mode == "debootstrap":
-            yield "required"
-            yield "minimal"
-        elif mode == "base":
-            yield "boot"
-            yield "required"
-            yield "minimal"
-            yield "standard"
-        elif mode == "ship-live":
-            if project == "lubuntu" and series == "bionic":
-                yield "ship-live-gtk"
-                yield "ship-live-share"
-            elif project == "lubuntu-next" and series == "bionic":
-                yield "ship-live-qt"
-                yield "ship-live-share"
-            elif project == "ubuntu-server" and series >= "bionic":
-                yield "server-ship-live"
-            elif project == "ubuntu" and self.config["SUBPROJECT"] == "canary":
-                # ubuntu-desktop-installer
-                yield "canary-ship-live"
-                # TODO: we will probably need a legacy-ship-live seed
-            else:
-                yield "ship-live"
-        elif mode == "addon":
-            ship = self._inheritance("ship")
-            ship_addon = self._inheritance("ship-addon")
-            for seed in ship_addon:
-                if seed not in ship:
-                    yield seed
-        elif mode == "dvd":
-            if project == "ubuntu":
-                # no inheritance; most of this goes on the live filesystem
-                yield "usb-langsupport"
-                yield "usb-ship-live"
-            elif project == "ubuntustudio":
-                # no inheritance; most of this goes on the live filesystem
-                yield "dvd"
-                if series >= "bionic":
-                    yield "ship-live"
-            else:
-                for seed in self._inheritance("dvd"):
-                    yield seed
+        if project == "ubuntustudio":
+            yield "dvd"
+            yield "ship-live"
+        elif project == "ubuntu-server":
+            yield "server-ship-live"
+        elif project == "ubuntu" and self.config["SUBPROJECT"] == "canary":
+            # ubuntu-desktop-installer
+            yield "canary-ship-live"
+            # TODO: will we need a legacy-ship-live seed?
+        else:
+            yield "ship-live"
 
     def seed_path(self, arch, seed):
         return os.path.join(self.directory, arch, seed)
@@ -311,42 +226,12 @@ class GerminateOutput:
             lines = seed_file.read().splitlines()[2:-2]
             return [line.split(None, 1)[0] for line in lines]
 
-    def master_seeds(self):
-        if self.config["CDIMAGE_ADDON"]:
-            for seed in self.list_seeds("addon"):
-                yield seed
-        else:
-            for seed in self.list_seeds("installer"):
-                yield seed
-            if self.config["CDIMAGE_DVD"]:
-                for seed in self.list_seeds("dvd"):
-                    if seed not in ("installer", "casper"):
-                        yield seed
-            elif self.config["CDIMAGE_INSTALL"]:
-                for seed in self.list_seeds("tasks"):
-                    if seed not in ("installer", "casper"):
-                        yield seed
-            else:
-                if self.config.get("CDIMAGE_INSTALL_BASE") == "1":
-                    for seed in self.list_seeds("base"):
-                        if seed not in ("installer", "casper"):
-                            yield seed
-                if self.config.get("CDIMAGE_LIVE") == "1":
-                    for seed in self.list_seeds("ship-live"):
-                        if seed not in ("installer", "casper"):
-                            yield seed
-
     def master_task_entries(self):
         project = self.config.project
         series = self.config.series
 
-        found = False
-        for seed in self.master_seeds():
+        for seed in self.pool_seeds():
             yield "#include <%s/%s/%s>" % (project, series, seed)
-            found = True
-
-        if not found:
-            raise NoMasterSeeds("No seeds found for master task!")
 
     def tasks_output_dir(self):
         return os.path.join(
@@ -354,116 +239,21 @@ class GerminateOutput:
             self.config.project, self.config.full_series,
             self.config.image_type, "tasks")
 
-    def task_packages(self, arch, seed, seedsource):
-        """Like seed_packages, but with various special-case hacks."""
-        installer_seeds = set(self.list_seeds("installer"))
-
-        for package in self.seed_packages(arch, seedsource):
-            # Hackily exclude kernel-image-* from the installer and casper
-            # tasks.  Those udebs only exist to satisfy dependencies when
-            # building the debian-installer package.
-            if seed in installer_seeds and package.startswith("kernel-image-"):
-                continue
-
-            # Force the use of live-installer rather than bootstrap-base on
-            # squashfs-base images.  Seed expansion doesn't do the right
-            # thing here because the installer seed is expanded before
-            # considering server-ship.
-            if self.config["CDIMAGE_SQUASHFS_BASE"]:
-                if package == "bootstrap-base":
-                    package = "live-installer"
-
-            yield package
-
-    def task_project(self):
-        # ubuntu-server really wants ubuntu-* tasks.
-        if self.config.project == "ubuntu-server":
-            return "ubuntu"
-        else:
-            return self.config.project
-
-    def task_headers(self, arch, seed):
-        headers = {}
-        try:
-            with open("%s.seedtext" % self.seed_path(arch, seed)) as seedtext:
-                for line in seedtext:
-                    if not line.lower().startswith("task-"):
-                        continue
-                    line = line.rstrip("\n")
-                    key, value = line.split(":", 1)
-                    key = key[5:].lower()
-                    value = value.lstrip()
-                    headers[key] = value
-        except IOError as e:
-            if e.errno != errno.ENOENT:
-                raise
-        return headers
-
-    def seed_task_mapping(self, arch):
-        task_project = self.task_project()
-        for seed in self.list_seeds("all"):
-            # Tasks implemented via tasksel, with Task-Seeds to indicate
-            # task/seed mapping.
-            task = seed
-            headers = self.task_headers(arch, seed)
-            if not headers:
-                continue
-            input_seeds = [seed] + headers.get("seeds", "").split()
-            if "per-derivative" in headers:
-                task = "%s-%s" % (task_project, task)
-
-            yield input_seeds, task
-
     def write_tasks(self):
         output_dir = self.tasks_output_dir()
         osextras.mkemptydir(self.tasks_output_dir())
 
         for arch in self.config.arches:
-            packages = defaultdict(list)
             cpparch = arch.replace("+", "_").replace("-", "_")
-            for seed in self.list_seeds("all"):
-                if seed == "supported":
-                    seedsource = "%s+build-depends" % seed
-                else:
-                    seedsource = seed
-                seed_path = self.seed_path(arch, seedsource)
-                if not os.path.exists(seed_path):
+            for seed in self._seeds:
+                if not os.path.exists(self.seed_path(arch, seed)):
                     continue
                 with open(os.path.join(output_dir, seed), "a") as task_file:
                     print("#ifdef ARCH_%s" % cpparch, file=task_file)
-                    for package in sorted(
-                            self.task_packages(arch, seed, seedsource)):
-                        packages[seed].append(package)
+                    for package in sorted(self.seed_packages(arch, seed)):
                         print(package, file=task_file)
                     print("#endif /* ARCH_%s */" % cpparch, file=task_file)
 
-            tasks = defaultdict(list)
-            for input_seeds, task in self.seed_task_mapping(arch):
-                for input_seed in input_seeds:
-                    for pkg in packages.get(input_seed, []):
-                        tasks[pkg].append(task)
-
-            # Help debian-cd to regenerate Task headers, to make sure that
-            # we don't accidentally end up out of sync with the archive and
-            # break the package installation step.
-            override_path = os.path.join(output_dir, "override.%s" % arch)
-            with open(override_path, "w") as override:
-                for pkg, tasknames in sorted(tasks.items()):
-                    print(
-                        "%s  Task  %s" % (pkg, ", ".join(tasknames)),
-                        file=override)
-            # Help debian-cd to get priorities in sync with the current base
-            # system, so that debootstrap >= 0.3.1 can work out the correct
-            # set of packages to install.
-            important_path = os.path.join(output_dir, "important.%s" % arch)
-            with open(important_path, "w") as important_file:
-                important = []
-                for seed in self.list_seeds("debootstrap"):
-                    important.extend(packages.get(seed, []))
-                for pkg in sorted(important):
-                    if not re_not_base.match(pkg):
-                        print(pkg, file=important_file)
-
             with open(os.path.join(output_dir, "MASTER"), "w") as master:
                 for entry in self.master_task_entries():
                     print(entry, file=master)
@@ -471,7 +261,7 @@ class GerminateOutput:
     def diff_tasks(self, output=None):
         tasks_dir = self.tasks_output_dir()
         previous_tasks_dir = "%s-previous" % tasks_dir
-        for seed in ["MASTER"] + list(self.list_seeds("all")):
+        for seed in ["MASTER"] + list(self._seeds):
             old = os.path.join(previous_tasks_dir, seed)
             new = os.path.join(tasks_dir, seed)
             if os.path.exists(old) and os.path.exists(new):
diff --git a/lib/cdimage/livefs.py b/lib/cdimage/livefs.py
index c1b475a..f361745 100644
--- a/lib/cdimage/livefs.py
+++ b/lib/cdimage/livefs.py
@@ -724,8 +724,7 @@ def download_live_filesystems(config, builds):
     output_dir = live_output_directory(config)
     osextras.mkemptydir(output_dir)
 
-    if (config["CDIMAGE_LIVE"] or config["CDIMAGE_SQUASHFS_BASE"] or
-            config["CDIMAGE_PREINSTALLED"]):
+    if config["CDIMAGE_LIVE"] or config["CDIMAGE_PREINSTALLED"]:
         got_image = False
         for arch in config.arches:
             if config["CDIMAGE_PREINSTALLED"]:
@@ -780,9 +779,7 @@ def download_live_filesystems(config, builds):
                 got_image = True
             else:
                 continue
-            if (project != "ubuntu-base" and
-                    not config["CDIMAGE_SQUASHFS_BASE"] and
-                    config.subproject != "wubi"):
+            if project != "ubuntu-base" and config.subproject != "wubi":
                 download_live_items(config, builds, arch, "kernel")
                 download_live_items(config, builds, arch, "initrd")
                 download_live_items(config, builds, arch, "kernel-efi-signed")
diff --git a/lib/cdimage/tests/test_build.py b/lib/cdimage/tests/test_build.py
index 1769f09..aac35e1 100644
--- a/lib/cdimage/tests/test_build.py
+++ b/lib/cdimage/tests/test_build.py
@@ -449,16 +449,6 @@ class TestBuildImageSet(TestCase):
             else:
                 self.assertNotIn("CDIMAGE_UNSUPPORTED", config)
 
-    def test_configure_install_base(self):
-        config = Config(read=False)
-        configure_for_project(config)
-        self.assertNotIn("CDIMAGE_INSTALL_BASE", config)
-
-        config = Config(read=False)
-        config["CDIMAGE_INSTALL"] = "1"
-        configure_for_project(config)
-        self.assertEqual("1", config["CDIMAGE_INSTALL_BASE"])
-
     @mock.patch("os.open")
     def test_open_log_debug(self, mock_open):
         self.config["DEBUG"] = "1"
diff --git a/lib/cdimage/tests/test_check_installable.py b/lib/cdimage/tests/test_check_installable.py
index 902771e..a671e96 100644
--- a/lib/cdimage/tests/test_check_installable.py
+++ b/lib/cdimage/tests/test_check_installable.py
@@ -21,8 +21,6 @@ from __future__ import print_function
 
 import gzip
 import os
-import subprocess
-from textwrap import dedent
 
 from cdimage.check_installable import (
     _check_installable_command,
@@ -30,7 +28,7 @@ from cdimage.check_installable import (
     _prepare_check_installable,
 )
 from cdimage.config import Config
-from cdimage.tests.helpers import TestCase, mkfile
+from cdimage.tests.helpers import TestCase
 
 
 class TestCheckInstallable(TestCase):
@@ -86,38 +84,6 @@ class TestCheckInstallable(TestCase):
         with open(os.path.join(data, "Packages_i386")) as packages_file:
             self.assertEqual("Package: foo\n\n", packages_file.read())
 
-    def test_prepare_squashfs_base(self):
-        self.config["CDIMAGE_SQUASHFS_BASE"] = "1"
-        _, image_top, live, data = _check_installable_dirs(self.config)
-        squashfs_dir = os.path.join(self.temp_dir, "squashfs")
-        status_path = os.path.join(
-            squashfs_dir, "var", "lib", "dpkg", "status")
-        fake_packages = dedent("""\
-            Package: base-files
-            Status: install ok installed
-            Version: 6.5
-
-            Package: libc6
-            Status: install ok installed
-            Version: 2.15-1
-            Provides: glibc
-
-            """)
-        with mkfile(status_path) as status:
-            print(fake_packages, end="", file=status)
-        os.makedirs(live)
-        with open("/dev/null", "w") as devnull:
-            subprocess.check_call(
-                ["mksquashfs", squashfs_dir,
-                 os.path.join(live, "i386.squashfs")],
-                stdout=devnull)
-        self.capture_logging()
-        _prepare_check_installable(self.config)
-        self.assertLogEqual([])
-        self.assertCountEqual(["Packages_i386", "Sources"], os.listdir(data))
-        with open(os.path.join(data, "Packages_i386")) as packages_file:
-            self.assertEqual(fake_packages, packages_file.read())
-
     def test_command(self):
         britney, _, _, data = _check_installable_dirs(self.config)
         command = _check_installable_command(self.config)
diff --git a/lib/cdimage/tests/test_germinate.py b/lib/cdimage/tests/test_germinate.py
index f567eae..7b15027 100644
--- a/lib/cdimage/tests/test_germinate.py
+++ b/lib/cdimage/tests/test_germinate.py
@@ -29,7 +29,7 @@ try:
 except ImportError:
     import mock
 
-from cdimage.config import Config, all_series
+from cdimage.config import Config
 from cdimage.germinate import (
     GerminateNotInstalled,
     GerminateOutput,
@@ -55,11 +55,6 @@ class TestGermination(TestCase):
             GerminateNotInstalled, getattr, self.germination, "germinate_path")
 
         germinate_dir = os.path.join(self.temp_dir, "germinate")
-        old_germinate = os.path.join(germinate_dir, "germinate.py")
-        touch(old_germinate)
-        os.chmod(old_germinate, 0o755)
-        self.assertEqual(old_germinate, self.germination.germinate_path)
-
         new_germinate = os.path.join(germinate_dir, "bin", "germinate")
         touch(new_germinate)
         os.chmod(new_germinate, 0o755)
@@ -356,106 +351,6 @@ class TestGerminateOutput(TestCase):
             ["active-ship-live", ["ship-live"]],
         ])
 
-    def test_inheritance_recurses(self):
-        """_inheritance recurses properly."""
-        self.write_structure([["a", []], ["b", ["a"]], ["c", ["b"]]])
-        output = GerminateOutput(self.config, self.temp_dir)
-        self.assertEqual(["a"], output._inheritance("a"))
-        self.assertEqual(["a", "b"], output._inheritance("b"))
-        self.assertEqual(["a", "b", "c"], output._inheritance("c"))
-
-    def test_inheritance_avoids_duplicates(self):
-        """_inheritance avoids adding a seed more than once."""
-        self.write_structure([["a", []], ["b", ["a"]], ["c", ["a", "b"]]])
-        output = GerminateOutput(self.config, self.temp_dir)
-        self.assertEqual(["a", "b", "c"], output._inheritance("c"))
-
-    def test_without_inheritance(self):
-        self.write_structure(
-            [["a", []], ["b", ["a"]], ["c", ["b"]], ["d", ["a", "c"]]])
-        output = GerminateOutput(self.config, self.temp_dir)
-        inheritance = output._inheritance("d")
-        self.assertEqual(["a", "b", "c", "d"], inheritance)
-        self.assertEqual(
-            ["c", "d"], output._without_inheritance("b", inheritance))
-
-    def test_list_seeds_all(self):
-        self.write_structure([["a", []], ["b", ["a"]], ["c", []]])
-        output = GerminateOutput(self.config, self.temp_dir)
-        self.assertEqual(["a", "b", "c"], list(output.list_seeds("all")))
-
-    def test_list_seeds_tasks_ubuntu(self):
-        self.write_ubuntu_structure()
-        output = GerminateOutput(self.config, self.temp_dir)
-        self.config["PROJECT"] = "ubuntu"
-        self.config["DIST"] = "bionic"
-        expected = [
-            "boot", "installer", "required", "minimal", "standard",
-            "desktop-common", "desktop", "d-i-requirements", "ship",
-        ]
-        self.assertEqual(expected, list(output.list_seeds("tasks")))
-        self.config["CDIMAGE_DVD"] = "1"
-        expected.extend(["dns-server", "lamp-server"])
-        self.assertEqual(expected, list(output.list_seeds("tasks")))
-
-    def test_list_seeds_tasks_ubuntu_server(self):
-        self.write_ubuntu_structure()
-        output = GerminateOutput(self.config, self.temp_dir)
-        self.config["PROJECT"] = "ubuntu-server"
-        expected = [
-            "boot", "installer", "required", "minimal", "standard",
-            "dns-server", "lamp-server", "openssh-server", "print-server",
-            "samba-server", "postgresql-server", "mail-server", "server",
-            "tomcat-server", "virt-host", "d-i-requirements", "server-ship",
-        ]
-        for series in all_series[4:]:
-            self.config["DIST"] = series
-            self.assertEqual(expected, list(output.list_seeds("tasks")))
-
-    def test_list_seeds_task_ubuntu_server_squashfs(self):
-        self.write_ubuntu_structure()
-        output = GerminateOutput(self.config, self.temp_dir)
-        self.config["PROJECT"] = "ubuntu-server"
-        self.config["DIST"] = "bionic"
-        self.config["CDIMAGE_SQUASHFS_BASE"] = "1"
-        expected = [
-            "boot", "installer", "standard", "dns-server", "lamp-server",
-            "openssh-server", "print-server", "samba-server",
-            "postgresql-server", "mail-server", "server", "tomcat-server",
-            "virt-host", "d-i-requirements", "server-ship",
-        ]
-        self.assertEqual(expected, list(output.list_seeds("tasks")))
-
-    def test_list_seeds_installer(self):
-        self.write_structure([["installer", []], ["casper", []]])
-        output = GerminateOutput(self.config, self.temp_dir)
-        self.config["CDIMAGE_INSTALL_BASE"] = "1"
-        self.assertEqual(["installer"], list(output.list_seeds("installer")))
-        del self.config["CDIMAGE_INSTALL_BASE"]
-        self.config["CDIMAGE_LIVE"] = "1"
-        self.config["DIST"] = "bionic"
-        self.assertEqual([], list(output.list_seeds("installer")))
-
-    def test_list_seeds_debootstrap(self):
-        self.write_ubuntu_structure()
-        output = GerminateOutput(self.config, self.temp_dir)
-        for series in all_series[6:]:
-            self.config["DIST"] = series
-            self.assertEqual(
-                ["required", "minimal"],
-                list(output.list_seeds("debootstrap")))
-
-    def test_list_seeds_base(self):
-        self.write_ubuntu_structure()
-        output = GerminateOutput(self.config, self.temp_dir)
-        for series in all_series[6:]:
-            self.config["DIST"] = series
-            self.assertEqual(
-                ["boot", "required", "minimal", "standard"],
-                list(output.list_seeds("base")))
-
-    # TODO list_seeds ship-live/addon/dvd untested
-
     def test_seed_path(self):
         self.write_ubuntu_structure()
         output = GerminateOutput(self.config, self.temp_dir)
@@ -495,43 +390,8 @@ class TestGerminateOutput(TestCase):
             ["base-files", "base-passwd"],
             output.seed_packages("i386", "base"))
 
-    # TODO: master_seeds addon untested
-
-    def test_master_seeds_dvd_ubuntu_bionic(self):
-        self.write_ubuntu_structure()
-        output = GerminateOutput(self.config, self.temp_dir)
-        self.config["PROJECT"] = "ubuntu"
-        self.config["DIST"] = "bionic"
-        self.config["CDIMAGE_DVD"] = "1"
-        self.assertEqual(
-            ["usb-langsupport", "usb-ship-live"], list(output.master_seeds()))
-
-    def test_master_seeds_install_ubuntu_bionic(self):
-        self.write_ubuntu_structure()
-        output = GerminateOutput(self.config, self.temp_dir)
-        self.config["PROJECT"] = "ubuntu"
-        self.config["DIST"] = "bionic"
-        self.config["CDIMAGE_INSTALL"] = "1"
-        self.config["CDIMAGE_INSTALL_BASE"] = "1"
-        self.assertEqual([
-            "installer", "boot", "required", "minimal", "standard",
-            "desktop-common", "desktop", "d-i-requirements", "ship",
-        ], list(output.master_seeds()))
-
-    def test_master_seeds_live_ubuntu_bionic(self):
-        self.write_ubuntu_structure()
-        output = GerminateOutput(self.config, self.temp_dir)
-        self.config["PROJECT"] = "ubuntu"
-        self.config["DIST"] = "bionic"
-        self.config["CDIMAGE_INSTALL_BASE"] = "1"
-        self.config["CDIMAGE_LIVE"] = "1"
-        self.assertEqual([
-            "installer", "boot", "required", "minimal", "standard",
-            "ship-live",
-        ], list(output.master_seeds()))
-
-    @mock.patch("cdimage.germinate.GerminateOutput.master_seeds")
-    def test_master_task_entries(self, mock_master_seeds):
+    @mock.patch("cdimage.germinate.GerminateOutput.pool_seeds")
+    def test_master_task_entries(self, mock_pool_seeds):
         def side_effect():
             yield "required"
             yield "minimal"
@@ -540,21 +400,19 @@ class TestGerminateOutput(TestCase):
         output = GerminateOutput(self.config, self.temp_dir)
         self.config["DIST"] = "bionic"
         self.config["PROJECT"] = "ubuntu"
-        mock_master_seeds.side_effect = side_effect
+        mock_pool_seeds.side_effect = side_effect
         self.assertEqual([
             "#include <ubuntu/bionic/required>",
             "#include <ubuntu/bionic/minimal>",
         ], list(output.master_task_entries()))
 
-    @mock.patch(
-        "cdimage.germinate.GerminateOutput.master_seeds", return_value=[])
-    def test_master_task_entries_no_seeds(self, mock_master_seeds):
+    def test_pool_seeds_invalid_config(self):
         self.write_ubuntu_structure()
         output = GerminateOutput(self.config, self.temp_dir)
         self.config["DIST"] = "bionic"
         self.config["PROJECT"] = "ubuntu"
         self.assertRaises(
-            NoMasterSeeds, list, output.master_task_entries())
+            NoMasterSeeds, list, output.pool_seeds())
 
     def test_tasks_output_dir(self):
         self.write_ubuntu_structure()
@@ -568,83 +426,6 @@ class TestGerminateOutput(TestCase):
                 "tasks"),
             output.tasks_output_dir())
 
-    def test_task_packages_plain(self):
-        self.write_structure([["base", []]])
-        self.write_seed_output("i386", "base", ["base-files", "base-passwd"])
-        output = GerminateOutput(self.config, self.temp_dir)
-        self.assertEqual(
-            ["base-files", "base-passwd"],
-            list(output.task_packages("i386", "base", "base")))
-
-    def test_task_packages_installer(self):
-        # kernel-image-* is excluded from the installer seed.
-        self.write_structure([["installer", []]])
-        self.write_seed_output(
-            "i386", "installer", [
-                "block-modules-3.8.0-6-generic-di",
-                "kernel-image-3.8.0-6-generic-di",
-            ])
-        self.config["CDIMAGE_INSTALL_BASE"] = "1"
-        output = GerminateOutput(self.config, self.temp_dir)
-        self.assertEqual(
-            ["block-modules-3.8.0-6-generic-di"],
-            list(output.task_packages("i386", "installer", "installer")))
-
-    def test_task_packages_squashfs(self):
-        self.write_ubuntu_structure()
-        self.config["PROJECT"] = "ubuntu-server"
-        self.config["DIST"] = "bionic"
-        self.write_seed_output(
-            "i386", "installer", ["base-installer", "bootstrap-base"])
-        output = GerminateOutput(self.config, self.temp_dir)
-        self.assertEqual(
-            ["base-installer", "bootstrap-base"],
-            list(output.task_packages("i386", "installer", "installer")))
-        self.config["CDIMAGE_SQUASHFS_BASE"] = "1"
-        self.assertEqual(
-            ["base-installer", "live-installer"],
-            list(output.task_packages("i386", "installer", "installer")))
-
-    # TODO: task_project untested
-
-    def test_task_headers(self):
-        self.write_ubuntu_structure()
-        seedtext_path = os.path.join(self.temp_dir, "i386", "desktop.seedtext")
-        with mkfile(seedtext_path) as seedtext:
-            print(dedent("""\
-                Task-Per-Derivative: 1
-                Task-Key: ubuntu-desktop
-                Task-Seeds: desktop-common
-
-                = Seed text starts here ="""), file=seedtext)
-        output = GerminateOutput(self.config, self.temp_dir)
-        expected = {
-            "per-derivative": "1",
-            "key": "ubuntu-desktop",
-            "seeds": "desktop-common",
-        }
-        self.assertEqual(expected, output.task_headers("i386", "desktop"))
-        self.assertEqual({}, output.task_headers("i386", "missing"))
-
-    def test_seed_task_mapping(self):
-        self.write_ubuntu_structure()
-        seed_dir = os.path.join(self.temp_dir, "i386")
-        with mkfile(os.path.join(seed_dir, "standard.seedtext")) as seedtext:
-            print("Task-Key: ubuntu-standard", file=seedtext)
-        with mkfile(os.path.join(seed_dir, "desktop.seedtext")) as seedtext:
-            print(dedent("""\
-                Task-Per-Derivative: 1
-                Task-Seeds: desktop-common"""), file=seedtext)
-        self.config["DIST"] = "bionic"
-        self.config["PROJECT"] = "ubuntu"
-        output = GerminateOutput(self.config, self.temp_dir)
-        expected = [
-            (["standard"], "standard"),
-            (["desktop", "desktop-common"], "ubuntu-desktop"),
-        ]
-        self.assertEqual(
-            expected, list(output.seed_task_mapping("i386")))
-
     def test_write_tasks(self):
         self.write_ubuntu_structure()
         for arch in "amd64", "i386":
@@ -673,8 +454,6 @@ class TestGerminateOutput(TestCase):
             "tasks")
         self.assertCountEqual([
             "required", "minimal", "desktop", "live",
-            "override.amd64", "override.i386",
-            "important.amd64", "important.i386",
             "MASTER",
         ], os.listdir(output_dir))
         with open(os.path.join(output_dir, "required")) as f:
@@ -723,28 +502,6 @@ class TestGerminateOutput(TestCase):
                     #endif /* ARCH_i386 */
                     """),
                 f.read())
-        with open(os.path.join(output_dir, "override.amd64")) as f:
-            self.assertEqual(
-                dedent("""\
-                    adduser-amd64  Task  minimal
-                    base-files-amd64  Task  minimal
-                    firefox  Task  ubuntu-desktop
-                    xterm  Task  ubuntu-desktop, ubuntu-live
-                    """),
-                f.read())
-        with open(os.path.join(output_dir, "override.i386")) as f:
-            self.assertEqual(
-                dedent("""\
-                    adduser-i386  Task  minimal
-                    base-files-i386  Task  minimal
-                    firefox  Task  ubuntu-desktop
-                    xterm  Task  ubuntu-desktop, ubuntu-live
-                    """),
-                f.read())
-        with open(os.path.join(output_dir, "important.amd64")) as f:
-            self.assertEqual("adduser-amd64\nbase-files-amd64\n", f.read())
-        with open(os.path.join(output_dir, "important.i386")) as f:
-            self.assertEqual("adduser-i386\nbase-files-i386\n", f.read())
         with open(os.path.join(output_dir, "MASTER")) as f:
             self.assertEqual("#include <ubuntu/bionic/ship-live>\n", f.read())
 
diff --git a/lib/cdimage/tests/test_tree.py b/lib/cdimage/tests/test_tree.py
index c5e3665..63a5840 100644
--- a/lib/cdimage/tests/test_tree.py
+++ b/lib/cdimage/tests/test_tree.py
@@ -1866,7 +1866,6 @@ class TestDailyTreePublisher(TestCase):
     @mock.patch("cdimage.tree.DailyTreePublisher.post_qa")
     def test_publish(self, mock_post_qa, *args):
         self.config["ARCHES"] = "i386"
-        self.config["CDIMAGE_INSTALL_BASE"] = "1"
         publisher = self.make_publisher("ubuntu", "daily-live")
         source_dir = publisher.image_output("i386")
         touch(os.path.join(
@@ -1900,7 +1899,6 @@ class TestDailyTreePublisher(TestCase):
             "%s-desktop-i386.iso" % self.config.series,
             "%s-desktop-i386.list" % self.config.series,
             "%s-desktop-i386.manifest" % self.config.series,
-            "report.html",
         ], os.listdir(target_dir))
         self.assertCountEqual(
             [".htaccess", "20120807", "current", "pending"],
@@ -1921,7 +1919,6 @@ class TestDailyTreePublisher(TestCase):
     def test_publish_subtree(self, mock_post_qa, *args):
         self.config.subtree = "subtree/test"
         self.config["ARCHES"] = "i386"
-        self.config["CDIMAGE_INSTALL_BASE"] = "1"
         publisher = self.make_publisher("ubuntu", "daily-live")
         source_dir = publisher.image_output("i386")
         touch(os.path.join(
@@ -1960,7 +1957,6 @@ class TestDailyTreePublisher(TestCase):
             "%s-desktop-i386.iso" % self.config.series,
             "%s-desktop-i386.list" % self.config.series,
             "%s-desktop-i386.manifest" % self.config.series,
-            "report.html",
         ], os.listdir(target_dir))
         self.assertCountEqual(
             [".htaccess", "20120807", "current", "pending"],
diff --git a/lib/cdimage/tree.py b/lib/cdimage/tree.py
index 0e9ad71..6fac63b 100644
--- a/lib/cdimage/tree.py
+++ b/lib/cdimage/tree.py
@@ -2084,13 +2084,7 @@ class DailyTreePublisher(Publisher):
         else:
             osextras.unlink_force("%s.manifest" % target_prefix)
 
-        if (self.config["CDIMAGE_SQUASHFS_BASE"] and
-                os.path.exists("%s.squashfs" % source_prefix)):
-            logger.info("Publishing %s squashfs ..." % arch)
-            shutil.move(
-                "%s.squashfs" % source_prefix, "%s.squashfs" % target_prefix)
-        else:
-            osextras.unlink_force("%s.squashfs" % target_prefix)
+        osextras.unlink_force("%s.squashfs" % target_prefix)
 
         if os.path.exists("%s.custom.tar.gz" % source_prefix):
             logger.info("Publishing %s custom tarball ..." % arch)
@@ -2616,14 +2610,8 @@ class DailyTreePublisher(Publisher):
             logger.warning("No images produced!")
             return
 
-        source_report = os.path.join(
-            self.britney_report, "%s_probs.html" % self.config.series)
         target_report = os.path.join(self.publish_base, date, "report.html")
-        if (self.config["CDIMAGE_INSTALL_BASE"] and
-                os.path.exists(source_report)):
-            shutil.copy2(source_report, target_report)
-        else:
-            osextras.unlink_force(target_report)
+        osextras.unlink_force(target_report)
 
         self.polish_directory(date)
         self.link(date, "pending")