Merge ~mwhudson/ubuntu-cdimage:only-launchpad-builders into ubuntu-cdimage:main

[Michael Hudson-Doyle]

remove support for non launchpad livefs builders

This currently fails tests. Trying to figure out how to usefully test e.g. live_item_paths makes my head hurt so I've stopped for now. I wonder if we can just switch to downloading all the artefacts produced by the livefs, which would clean up the code quite extremely...

Unmerged commits

160bb63... by Michael Hudson-Doyle on 2023-11-22

a start on how this test might work

	run-tests:0 (build)
	lint:0 (build)

1 → 2 of 2 results

First • Previous • Next • Last

393fc48... by Michael Hudson-Doyle on 2023-11-22

test stuff

92c9bbe... by Michael Hudson-Doyle on 2023-11-22

remove tests for functions i just deleted

4cc1f8b... by Michael Hudson-Doyle on 2023-11-22

remove support for non-launchpad livefs builders

diff --git a/lib/cdimage/livefs.py b/lib/cdimage/livefs.py
index c912dc0..e701155 100644
--- a/lib/cdimage/livefs.py
+++ b/lib/cdimage/livefs.py
@@ -23,7 +23,6 @@ from gzip import GzipFile
 import io
 import os
 import re
-import subprocess
 from textwrap import dedent
 import time
 try:
@@ -79,61 +78,6 @@ def split_arch(config, arch):
     return cpuarch, subarch
 
 
-def live_builder(config, arch):
-    cpuarch, subarch = split_arch(config, arch)
-    project = config.project
-
-    path = os.path.join(config.root, "production", "livefs-builders")
-    if os.path.exists(path):
-        with open(path) as f:
-            for line in f:
-                line = line.strip()
-                if not line or line.startswith("#"):
-                    continue
-                try:
-                    f_project, f_series, f_arch, builder = line.split(None, 3)
-                except ValueError:
-                    continue
-                if not fnmatch.fnmatchcase(project, f_project):
-                    continue
-                if not config.match_series(f_series):
-                    continue
-                if "+" in f_arch:
-                    want_arch = arch
-                else:
-                    want_arch = cpuarch
-                if not fnmatch.fnmatchcase(want_arch, f_arch):
-                    continue
-                return builder
-
-    raise UnknownArchitecture("No live filesystem builder known for %s" % arch)
-
-
-def live_build_options(config, arch):
-    options = []
-
-    cpuarch, subarch = split_arch(config, arch)
-    if (cpuarch in ("armel", "armhf") and
-            config.image_type == "daily-preinstalled"):
-        if subarch in ("mx5", "omap", "omap4"):
-            options.extend(["-f", "ext4"])
-        elif subarch in ("ac100", "nexus7"):
-            options.extend(["-f", "plain"])
-
-    if config.project in ("ubuntu-base", "ubuntu-core", "ubuntu-touch"):
-        options.extend(["-f", "plain"])
-
-    if config.subproject == "wubi":
-        if config["DIST"] >= "trusty":
-            # TODO: Turn this back on once Wubi's resize2fs supports it.
-            # options.extend(["-f", "ext4"])
-            options.extend(["-f", "ext3"])
-        else:
-            options.extend(["-f", "ext3"])
-
-    return options
-
-
 def live_project(config, arch):
     liveproject = config.livefs_project_for_arch(arch)
 
@@ -144,37 +88,6 @@ def live_project(config, arch):
     return liveproject
 
 
-def live_build_command(config, arch):
-    command = [
-        "ssh", "-n", "-o", "StrictHostKeyChecking=no", "-o", "BatchMode=yes",
-        "buildd@%s" % live_builder(config, arch),
-        "/home/buildd/bin/BuildLiveCD",
-    ]
-
-    if config["UBUNTU_DEFAULTS_LOCALE"]:
-        command.extend(["-u", config["UBUNTU_DEFAULTS_LOCALE"]])
-    command.append("-l")
-
-    command.extend(live_build_options(config, arch))
-
-    cpuarch, subarch = split_arch(config, arch)
-    if cpuarch:
-        command.extend(["-A", cpuarch])
-    if subarch:
-        command.extend(["-s", subarch])
-
-    if config.get("PROPOSED", "0") not in ("", "0"):
-        command.append("-p")
-    if config.series:
-        command.extend(["-d", config.series])
-
-    if config.subproject:
-        command.extend(["-r", config.subproject])
-    command.append(live_project(config, arch))
-
-    return command
-
-
 def live_build_lp_kwargs(config, lp, lp_livefs, arch):
     cpuarch, subarch = split_arch(config, arch)
     kwargs = {}
@@ -222,8 +135,6 @@ def live_build_lp_kwargs(config, lp, lp_livefs, arch):
     return kwargs
 
 
-# TODO: This is only used for logging, so it might be worth unifying with
-# live_build_notify_failure.
 def live_build_full_name(config, arch):
     bits = [config.project]
     if config.subproject:
@@ -235,7 +146,7 @@ def live_build_full_name(config, arch):
     return "-".join(bits)
 
 
-def live_build_notify_failure(config, arch, lp_build=None):
+def live_build_notify_failure(config, arch, lp_build):
     if config["DEBUG"]:
         return
 
@@ -256,19 +167,13 @@ def live_build_notify_failure(config, arch, lp_build=None):
 
     datestamp = time.strftime("%Y%m%d")
     try:
-        if lp_build is not None:
-            if lp_build.build_log_url is None:
-                raise URLError(
-                    "Failed build %s has no build_log_url" % lp_build.web_link)
-            with closing(urlopen(lp_build.build_log_url, timeout=30)) as comp:
-                with closing(io.BytesIO(comp.read())) as comp_bytes:
-                    with closing(GzipFile(fileobj=comp_bytes)) as f:
-                        body = f.read()
-        else:
-            log_url = "http://%s/~buildd/LiveCD/%s/%s/latest/livecd-%s.out" % (
-                live_builder(config, arch), config.series, livefs_id, cpuarch)
-            with closing(urlopen(log_url, timeout=30)) as f:
-                body = f.read()
+        if lp_build.build_log_url is None:
+            raise URLError(
+                "Failed build %s has no build_log_url" % lp_build.web_link)
+        with closing(urlopen(lp_build.build_log_url, timeout=30)) as comp:
+            with closing(io.BytesIO(comp.read())) as comp_bytes:
+                with closing(GzipFile(fileobj=comp_bytes)) as f:
+                    body = f.read()
     except URLError:
         body = b""
     subject = "LiveFS %s%s/%s/%s failed to build on %s" % (
@@ -323,10 +228,7 @@ def live_lp_info(config, arch):
 
 
 def get_lp_livefs(config, arch):
-    try:
-        lp_info = live_lp_info(config, arch)
-    except UnknownLaunchpadLiveFS:
-        return None, None
+    lp_info = live_lp_info(config, arch)
     if len(lp_info) > 2:
         instance, owner, name = lp_info
     else:
@@ -346,7 +248,6 @@ def get_lp_livefs(config, arch):
 
 
 def run_live_builds(config):
-    builds = {}
     lp_builds = []
     for arch in config.arches:
         if arch == "amd64+mac":
@@ -355,47 +256,38 @@ def run_live_builds(config):
         full_name = live_build_full_name(config, arch)
         timestamp = time.strftime("%F %T")
         lp, lp_livefs = get_lp_livefs(config, arch)
-        if lp_livefs is None:
-            machine = live_builder(config, arch)
-        else:
-            machine = "Launchpad"
-        logger.info(
-            "%s on %s starting at %s" % (full_name, machine, timestamp))
+        logger.info("%s on Launchpad starting at %s" % (full_name, timestamp))
         tracker_set_rebuild_status(config, [0, 1], 2, arch)
-        if lp_livefs is not None:
-            lp_build = None
-            if config["CDIMAGE_REUSE_BUILD"]:
-                cpuarch, subarch = split_arch(config, arch)
-                for build in lp_livefs.builds:
-                    try:
-                        metadata_subarch = build.metadata_override.get(
-                            "subarch", "")
-                    except AttributeError:
-                        metadata_subarch = ""
-                    if (build.distro_arch_series.architecture_tag == cpuarch
-                            and metadata_subarch == subarch
-                            and build.buildstate == "Successfully built"):
-                        logger.info("reusing build %s", build)
-                        lp_build = build
-                        break
-                else:
-                    raise Exception("no build found to reuse for %s" % (arch,))
-            if lp_build is None:
-                lp_kwargs = live_build_lp_kwargs(config, lp, lp_livefs, arch)
-                lp_build = lp_livefs.requestBuild(**lp_kwargs)
-                logger.info("%s: %s" % (full_name, lp_build.web_link))
-            lp_builds.append((lp_build, arch, full_name, machine, None))
-        else:
-            proc = subprocess.Popen(live_build_command(config, arch))
-            builds[proc.pid] = (proc, arch, full_name, machine)
+        lp_build = None
+        if config["CDIMAGE_REUSE_BUILD"]:
+            cpuarch, subarch = split_arch(config, arch)
+            for build in lp_livefs.builds:
+                try:
+                    metadata_subarch = build.metadata_override.get(
+                        "subarch", "")
+                except AttributeError:
+                    metadata_subarch = ""
+                if (build.distro_arch_series.architecture_tag == cpuarch
+                        and metadata_subarch == subarch
+                        and build.buildstate == "Successfully built"):
+                    logger.info("reusing build %s", build)
+                    lp_build = build
+                    break
+            else:
+                raise Exception("no build found to reuse for %s" % (arch,))
+        if lp_build is None:
+            lp_kwargs = live_build_lp_kwargs(config, lp, lp_livefs, arch)
+            lp_build = lp_livefs.requestBuild(**lp_kwargs)
+            print(lp_build)
+            logger.info("%s: %s" % (full_name, lp_build.web_link))
+        lp_builds.append((lp_build, arch, full_name, None))
 
     successful = set()
 
-    def live_build_finished(arch, full_name, machine, status, text_status,
-                            lp_build=None):
+    def live_build_finished(arch, full_name, status, text_status, lp_build):
         timestamp = time.strftime("%F %T")
-        logger.info("%s on %s finished at %s (%s)" % (
-            full_name, machine, timestamp, text_status))
+        logger.info("%s on Launchpad finished at %s (%s)" % (
+            full_name, timestamp, text_status))
         if status == 0:
             tracker_set_rebuild_status(config, [0, 1, 2], 3, arch)
             successful.add(arch)
@@ -405,28 +297,20 @@ def run_live_builds(config):
             tracker_set_rebuild_status(config, [0, 1, 2], 5, arch)
             live_build_notify_failure(config, arch, lp_build=lp_build)
 
-    while builds or lp_builds:
-        # Check for non-Launchpad build results.
-        for pid, (proc, arch, full_name, machine) in list(builds.items()):
-            status = proc.poll()
-            if status is not None:
-                del builds[pid]
-                live_build_finished(
-                    arch, full_name, machine, status,
-                    "success" if status == 0 else "failed")
-
+    while lp_builds:
         # Check for Launchpad build results.
         pending_lp_builds = []
         for lp_item in lp_builds:
-            lp_build, arch, full_name, machine, log_timeout = lp_item
+            lp_build, arch, full_name, log_timeout = lp_item
             lp_build.lp_refresh()
-            if lp_build.buildstate in (
+            bs = lp_build.buildstate
+            if bs in (
                     "Needs building", "Currently building",
                     "Gathering build output", "Uploading build"):
                 pending_lp_builds.append(lp_item)
             elif lp_build.buildstate == "Successfully built":
                 live_build_finished(
-                    arch, full_name, machine, 0, lp_build.buildstate,
+                    arch, full_name, 0, lp_build.buildstate,
                     lp_build=lp_build)
             elif (lp_build.build_log_url is None and
                   (log_timeout is None or time.time() < log_timeout)):
@@ -436,17 +320,15 @@ def run_live_builds(config):
                 if log_timeout is None:
                     log_timeout = time.time() + 300
                 pending_lp_builds.append(
-                    (lp_build, arch, full_name, machine, log_timeout))
+                    (lp_build, arch, full_name, log_timeout))
             else:
                 live_build_finished(
-                    arch, full_name, machine, 1, lp_build.buildstate,
+                    arch, full_name, 1, lp_build.buildstate,
                     lp_build=lp_build)
         lp_builds = pending_lp_builds
 
         if lp_builds:
-            # Wait a while before polling Launchpad again.  If a
-            # non-Launchpad build completes in the meantime, it will
-            # interrupt this sleep with SIGCHLD.
+            # Wait a while before polling Launchpad again.
             time.sleep(15)
 
     if not successful:
@@ -454,29 +336,6 @@ def run_live_builds(config):
     return successful
 
 
-def livecd_base(config, arch):
-    if config["LIVECD_BASE"]:
-        return config["LIVECD_BASE"]
-
-    cpuarch, subarch = split_arch(config, arch)
-    series = config["DIST"]
-
-    if config["LIVECD"]:
-        root = config["LIVECD"]
-    else:
-        root = "http://%s/~buildd/LiveCD" % live_builder(config, arch)
-
-    liveproject = live_project(config, arch)
-    if config["SUBPROJECT"]:
-        liveproject += "-%s" % config["SUBPROJECT"]
-    if subarch:
-        liveproject += "-%s" % subarch
-    if config["UBUNTU_DEFAULTS_LOCALE"]:
-        liveproject += "-%s" % config["UBUNTU_DEFAULTS_LOCALE"]
-
-    return "%s/%s/%s/current" % (root, series, liveproject)
-
-
 def flavours(config, arch):
     cpuarch, subarch = split_arch(config, arch)
     project = config.project
@@ -552,31 +411,18 @@ def live_item_paths(config, arch, item):
 
     lp, lp_livefs = get_lp_livefs(config, arch)
     uris = []
-    root = ""
-    if lp_livefs is not None:
-        lp_kwargs = live_build_lp_kwargs(config, lp, lp_livefs, arch)
-        lp_build = lp_livefs.getLatestBuild(
-            lp_kwargs["distro_arch_series"],
-            unique_key=lp_kwargs.get("unique_key"))
-        uris = list(lp_build.getFileUrls())
-    else:
-        root = livecd_base(config, arch)
-        try:
-            uris = [os.path.join(root, u) for u in os.listdir(root)]
-        except OSError:
-            # fallback to exact given uri (for http://) in url_for as we can't
-            # list content.
-            pass
+    lp_kwargs = live_build_lp_kwargs(config, lp, lp_livefs, arch)
+    lp_build = lp_livefs.getLatestBuild(
+        lp_kwargs["distro_arch_series"],
+        unique_key=lp_kwargs.get("unique_key"))
+    uris = list(lp_build.getFileUrls())
 
     def urls_for(base, item):
-        if uris:
-            for uri in uris:
-                filename = unquote(os.path.basename(uri))
-                if (filename.startswith(base + '.') and
-                        filename.endswith('.' + item)):
-                    yield uri
-        else:
-            yield os.path.join(root, base + '.' + item)
+        for uri in uris:
+            filename = unquote(os.path.basename(uri))
+            if (filename.startswith(base + '.') and
+                    filename.endswith('.' + item)):
+                yield uri
 
     if item in (
         "cloop", "squashfs", "manifest", "manifest-desktop", "manifest-remove",
@@ -775,7 +621,6 @@ def write_autorun(config, arch, name, label):
 
 def download_live_filesystems(config):
     project = config.project
-    series = config["DIST"]
 
     output_dir = live_output_directory(config)
     osextras.mkemptydir(output_dir)
@@ -849,27 +694,6 @@ def download_live_filesystems(config):
                     config.subproject == "wubi"):
                 continue
 
-            if (project not in ("livecd-base", "ubuntu-base", "ubuntu-core",
-                                "ubuntu-core-desktop", "ubuntu-appliance") and
-                    (project != "ubuntukylin" or series <= "trusty")):
-                if series <= "trusty":
-                    # TODO: We still have to do something about not
-                    # including Wubi on the DVDs.
-                    download_live_items(config, arch, "wubi")
-                    wubi_path = os.path.join(output_dir, "%s.wubi.exe" % arch)
-                    if os.path.exists(wubi_path):
-                        # Nicely format the distribution name.
-                        def upper_first(m):
-                            text = m.group(0)
-                            return text[0].upper() + text[1:]
-
-                        autorun_project = re.sub(
-                            r"(\b[a-z])", upper_first,
-                            project.replace("-", " "))
-                        write_autorun(
-                            config, arch, "wubi.exe",
-                            "Install %s" % autorun_project)
-
             if (project in ("ubuntu-core", "ubuntu-core-desktop",
                             "ubuntu-appliance") and
                     config["CDIMAGE_LIVE"]):
@@ -880,31 +704,6 @@ def download_live_filesystems(config):
         if not got_image:
             raise NoFilesystemImages("No filesystem images found.")
 
-    if config.project == "ubuntu-touch":
-        for arch in config.arches:
-            for abootimg in (
-                "boot-%s+%s.img" % (target.ubuntu_arch, target.subarch)
-                    for target in Touch.list_targets_by_ubuntu_arch(arch)
-            ):
-                download_live_items(
-                    config, arch, abootimg
-                )
-            for recoveryimg in (
-                "recovery-%s+%s.img" % (target.android_arch, target.subarch)
-                    for target in Touch.list_targets_by_ubuntu_arch(arch)
-            ):
-                download_live_items(
-                    config, arch, recoveryimg
-                )
-            for systemimg in (
-                "system-%s+%s.img" % (target.android_arch, target.subarch)
-                    for target in Touch.list_targets_by_ubuntu_arch(arch)
-            ):
-                download_live_items(
-                    config, arch, systemimg
-                )
-            download_live_items(config, arch, "custom.tar.gz")
-
     if config.project == "ubuntu-core":
         for arch in config.arches:
             download_live_items(config, arch, "device.tar.gz")
diff --git a/lib/cdimage/tests/test_livefs.py b/lib/cdimage/tests/test_livefs.py
index 6ef8055..a92bb66 100644
--- a/lib/cdimage/tests/test_livefs.py
+++ b/lib/cdimage/tests/test_livefs.py
@@ -20,6 +20,7 @@
 from __future__ import print_function
 
 from collections import defaultdict
+import gzip
 from itertools import chain, repeat
 import os
 import subprocess
@@ -40,19 +41,14 @@ from cdimage import osextras
 from cdimage.config import Config, all_series
 from cdimage.launchpad import get_launchpad, launchpad_available
 from cdimage.livefs import (
-    LiveBuildsFailed,
     download_live_filesystems,
     download_live_items,
     flavours,
-    live_build_command,
     live_build_full_name,
     live_build_notify_failure,
-    live_build_options,
-    live_builder,
     live_item_paths,
     live_output_directory,
     live_project,
-    livecd_base,
     run_live_builds,
     split_arch,
     write_autorun,
@@ -125,7 +121,6 @@ class MockLiveFSBuild(mock.MagicMock):
 class MockLiveFS(mock.MagicMock):
     def requestBuild(self, distro_arch_series=None, **kwargs):
         build = MockLiveFSBuild(distro_arch_series=distro_arch_series)
-        build.buildstate = "Needs building"
         return build
 
 
@@ -233,199 +228,6 @@ def make_livefs_production_config(config):
             """), file=f)
 
 
-class TestLiveBuilder(TestCase):
-    def setUp(self):
-        super(TestLiveBuilder, self).setUp()
-        self.config = Config(read=False)
-        self.config.root = self.use_temp_dir()
-        make_livefs_production_config(self.config)
-
-    def assertBuilderEqual(self, expected, arch, series, project=None):
-        self.config["DIST"] = series
-        if project is not None:
-            self.config["PROJECT"] = project
-        self.assertEqual(expected, live_builder(self.config, arch))
-
-    def test_amd64(self):
-        for series in all_series:
-            self.assertBuilderEqual("kapok.buildd", "amd64", series)
-
-    def test_armel(self):
-        for series in all_series:
-            self.assertBuilderEqual("celbalrai.buildd", "armel", series)
-
-    def test_arm64(self):
-        for series in all_series:
-            self.assertBuilderEqual("magic.buildd", "arm64", series)
-
-    def test_armhf(self):
-        for series in all_series:
-            self.assertBuilderEqual(
-                "kishi00.buildd", "armhf+mx5", series, project="ubuntu")
-            self.assertBuilderEqual(
-                "kishi00.buildd", "armhf+omap", series, project="ubuntu")
-            self.assertBuilderEqual(
-                "kishi00.buildd", "armhf+omap4", series, project="ubuntu")
-            self.assertBuilderEqual(
-                "kishi00.buildd", "armhf+omap", series,
-                project="ubuntu-server")
-            self.assertBuilderEqual(
-                "celbalrai.buildd", "armhf+omap4", series,
-                project="ubuntu-server")
-            self.assertBuilderEqual("celbalrai.buildd", "armhf+ac100", series)
-            self.assertBuilderEqual("celbalrai.buildd", "armhf+nexus7", series)
-            self.assertBuilderEqual(
-                "kishi00.buildd", "armhf+somethingelse", series)
-
-    def test_hppa(self):
-        for series in all_series:
-            self.assertBuilderEqual("castilla.buildd", "hppa", series)
-
-    def test_i386(self):
-        for series in all_series:
-            self.assertBuilderEqual("cardamom.buildd", "i386", series)
-
-    def test_ia64(self):
-        for series in all_series:
-            self.assertBuilderEqual("weddell.buildd", "ia64", series)
-
-    def test_powerpc(self):
-        for series in all_series:
-            self.assertBuilderEqual("royal.buildd", "powerpc", series)
-
-    def test_ppc64el(self):
-        for series in all_series:
-            self.assertBuilderEqual("fisher01.buildd", "ppc64el", series)
-
-    def test_sparc(self):
-        for series in all_series:
-            self.assertBuilderEqual("vivies.buildd", "sparc", series)
-
-
-class TestLiveBuildOptions(TestCase):
-    def setUp(self):
-        super(TestLiveBuildOptions, self).setUp()
-        self.config = Config(read=False)
-
-    def test_armel_preinstalled(self):
-        self.config["IMAGE_TYPE"] = "daily-preinstalled"
-        for subarch, fstype in (
-            ("mx5", "ext4"),
-            ("omap", "ext4"),
-            ("omap4", "ext4"),
-            ("ac100", "plain"),
-            ("nexus7", "plain"),
-        ):
-            self.assertEqual(
-                ["-f", fstype],
-                live_build_options(self.config, "armel+%s" % subarch))
-        self.assertEqual([], live_build_options(self.config, "armel+other"))
-
-    def test_armhf_preinstalled(self):
-        self.config["IMAGE_TYPE"] = "daily-preinstalled"
-        for subarch, fstype in (
-            ("mx5", "ext4"),
-            ("omap", "ext4"),
-            ("omap4", "ext4"),
-            ("ac100", "plain"),
-            ("nexus7", "plain"),
-        ):
-            self.assertEqual(
-                ["-f", fstype],
-                live_build_options(self.config, "armhf+%s" % subarch))
-        self.assertEqual([], live_build_options(self.config, "armhf+other"))
-
-    def test_ubuntu_core(self):
-        self.config["PROJECT"] = "ubuntu-core"
-        self.assertEqual(
-            ["-f", "plain"], live_build_options(self.config, "i386"))
-
-    def test_ubuntu_base(self):
-        self.config["PROJECT"] = "ubuntu-base"
-        self.assertEqual(
-            ["-f", "plain"], live_build_options(self.config, "i386"))
-
-    def test_ubuntu_touch(self):
-        self.config["PROJECT"] = "ubuntu-touch"
-        self.assertEqual(
-            ["-f", "plain"], live_build_options(self.config, "armhf"))
-
-    def test_wubi(self):
-        self.config["SUBPROJECT"] = "wubi"
-        for series, fstype in (
-            ("trusty", "ext3"),  # ext4
-        ):
-            self.config["DIST"] = series
-            self.assertEqual(
-                ["-f", fstype], live_build_options(self.config, "i386"))
-
-
-class TestLiveBuildCommand(TestCase):
-    def setUp(self):
-        super(TestLiveBuildCommand, self).setUp()
-        self.config = Config(read=False)
-        self.config.root = self.use_temp_dir()
-        make_livefs_production_config(self.config)
-        self.base_expected = [
-            "ssh", "-n", "-o", "StrictHostKeyChecking=no",
-            "-o", "BatchMode=yes",
-        ]
-
-    def contains_subsequence(self, haystack, needle):
-        # This is inefficient, but it doesn't matter much here.
-        for i in range(len(haystack) - len(needle) + 1):
-            if haystack[i:i + len(needle)] == needle:
-                return True
-        return False
-
-    def assertCommandContains(self, subsequence, arch):
-        observed = live_build_command(self.config, arch)
-        if not self.contains_subsequence(observed, subsequence):
-            self.fail("%s does not contain %s" % (observed, subsequence))
-
-    def test_basic(self):
-        self.config["PROJECT"] = "ubuntu"
-        self.config["DIST"] = "trusty"
-        expected = self.base_expected + [
-            "[e-mail]", "/home/buildd/bin/BuildLiveCD",
-            "-l", "-A", "i386", "-d", "trusty", "ubuntu",
-        ]
-        self.assertEqual(expected, live_build_command(self.config, "i386"))
-
-    def test_ubuntu_defaults_locale(self):
-        self.config["UBUNTU_DEFAULTS_LOCALE"] = "zh_CN"
-        self.assertCommandContains(["-u", "zh_CN"], "i386")
-
-    def test_pre_live_build(self):
-        self.config["DIST"] = "trusty"
-        self.assertIn("-l", live_build_command(self.config, "i386"))
-
-    @mock.patch(
-        "cdimage.livefs.live_build_options", return_value=["-f", "plain"])
-    def test_uses_live_build_options(self, *args):
-        self.assertCommandContains(["-f", "plain"], "i386")
-
-    def test_subarch(self):
-        self.assertCommandContains(["-s", "omap4"], "armhf+omap4")
-
-    def test_proposed(self):
-        self.config["PROPOSED"] = "1"
-        self.assertIn("-p", live_build_command(self.config, "i386"))
-
-    def test_series(self):
-        self.config["DIST"] = "trusty"
-        self.assertCommandContains(["-d", "trusty"], "i386")
-
-    def test_subproject(self):
-        self.config["SUBPROJECT"] = "wubi"
-        self.assertCommandContains(["-r", "wubi"], "i386")
-
-    def test_project(self):
-        self.config["PROJECT"] = "kubuntu"
-        self.assertEqual(
-            "kubuntu", live_build_command(self.config, "i386")[-1])
-
-
 def mock_strftime(secs):
     original_strftime = time.strftime
     gmtime = time.gmtime(secs)
@@ -472,12 +274,12 @@ class TestRunLiveBuilds(TestCase):
     @mock.patch("cdimage.livefs.get_notify_addresses")
     def test_live_build_notify_failure_debug(self, mock_notify_addresses):
         self.config["DEBUG"] = "1"
-        live_build_notify_failure(self.config, None)
+        live_build_notify_failure(self.config, None, MockLiveFSBuild())
         self.assertEqual(0, mock_notify_addresses.call_count)
 
     @mock.patch("cdimage.livefs.send_mail")
     def test_live_build_notify_failure_no_recipients(self, mock_send_mail):
-        live_build_notify_failure(self.config, None)
+        live_build_notify_failure(self.config, None, MockLiveFSBuild())
         self.assertEqual(0, mock_send_mail.call_count)
 
     @mock.patch("time.strftime", return_value="20130315")
@@ -491,7 +293,7 @@ class TestRunLiveBuilds(TestCase):
         path = os.path.join(self.temp_dir, "production", "notify-addresses")
         with mkfile(path) as notify_addresses:
             print("ALL\[e-mail]", file=notify_addresses)
-        live_build_notify_failure(self.config, "i386")
+        live_build_notify_failure(self.config, "i386", MockLiveFSBuild())
         mock_send_mail.assert_called_once_with(
             "LiveFS ubuntu/trusty/i386 failed to build on 20130315",
             "buildlive", ["[e-mail]"], b"")
@@ -505,178 +307,18 @@ class TestRunLiveBuilds(TestCase):
         path = os.path.join(self.temp_dir, "production", "notify-addresses")
         with mkfile(path) as notify_addresses:
             print("ALL\[e-mail]", file=notify_addresses)
-        mock_urlopen_obj = mock_urlopen(b"Log data\n")
+        mock_urlopen_obj = mock_urlopen(gzip.compress(b"Log data\n"))
+        mock_build = MockLiveFSBuild()
+        mock_build.build_log_url = 'http://log-location'
         with mock.patch("cdimage.livefs.urlopen", mock_urlopen_obj):
-            live_build_notify_failure(self.config, "armhf+omap4")
+            live_build_notify_failure(self.config, "armhf+omap4", mock_build)
         mock_urlopen_obj.assert_called_once_with(
-            "http://kishi00.buildd/~buildd/LiveCD/trusty/kubuntu-omap4/latest/"
-            "livecd-armhf.out", timeout=30)
+            mock_build.build_log_url, timeout=30)
         mock_send_mail.assert_called_once_with(
             "LiveFS kubuntu-omap4/trusty/armhf+omap4 failed to build on "
             "20130315",
             "buildlive", ["[e-mail]"], b"Log data\n")
 
-    @mock_strftime(1363355331)
-    @mock.patch("cdimage.livefs.live_build_command", return_value=["false"])
-    @mock.patch("cdimage.livefs.tracker_set_rebuild_status")
-    @mock.patch("cdimage.livefs.send_mail")
-    def test_run_live_builds_notifies_on_failure(self, mock_send_mail,
-                                                 mock_tracker, *args):
-        self.config["PROJECT"] = "ubuntu"
-        self.config["DIST"] = "trusty"
-        self.config["IMAGE_TYPE"] = "daily"
-        self.config["ARCHES"] = "amd64 i386"
-        path = os.path.join(self.temp_dir, "production", "notify-addresses")
-        with mkfile(path) as notify_addresses:
-            print("ALL\[e-mail]", file=notify_addresses)
-        self.capture_logging()
-        with mock.patch("cdimage.livefs.urlopen", mock_urlopen(b"Log data\n")):
-            self.assertRaisesRegex(
-                LiveBuildsFailed, "No live filesystem builds succeeded.",
-                run_live_builds, self.config)
-        self.assertCountEqual([
-            "ubuntu-amd64 on kapok.buildd starting at 2013-03-15 13:48:51",
-            "ubuntu-i386 on cardamom.buildd starting at 2013-03-15 13:48:51",
-            "ubuntu-amd64 on kapok.buildd finished at 2013-03-15 13:48:51 "
-            "(failed)",
-            "ubuntu-i386 on cardamom.buildd finished at 2013-03-15 13:48:51 "
-            "(failed)",
-        ], self.captured_log_messages())
-        mock_send_mail.assert_has_calls([
-            mock.call(
-                "LiveFS ubuntu/trusty/amd64 failed to build on 20130315",
-                "buildlive", ["[e-mail]"], b"Log data\n"),
-            mock.call(
-                "LiveFS ubuntu/trusty/i386 failed to build on 20130315",
-                "buildlive", ["[e-mail]"], b"Log data\n"),
-        ], any_order=True)
-        mock_tracker.assert_has_calls([
-            mock.call(self.config, [0, 1], 2, "amd64"),
-            mock.call(self.config, [0, 1], 2, "i386"),
-            mock.call(self.config, [0, 1, 2], 5, "amd64"),
-            mock.call(self.config, [0, 1, 2], 5, "i386")
-        ])
-
-    @mock_strftime(1363355331)
-    @mock.patch("cdimage.livefs.tracker_set_rebuild_status")
-    @mock_Popen(["true"])
-    @mock.patch("cdimage.livefs.live_build_notify_failure")
-    def test_run_live_builds(self, mock_live_build_notify_failure, mock_popen,
-                             mock_tracker_set_rebuild_status, *args):
-        self.config["PROJECT"] = "ubuntu"
-        self.config["DIST"] = "trusty"
-        self.config["IMAGE_TYPE"] = "daily"
-        self.config["ARCHES"] = "amd64 i386"
-        self.capture_logging()
-        self.assertCountEqual(["amd64", "i386"], run_live_builds(self.config))
-        self.assertCountEqual([
-            "ubuntu-amd64 on kapok.buildd starting at 2013-03-15 13:48:51",
-            "ubuntu-i386 on cardamom.buildd starting at 2013-03-15 13:48:51",
-            "ubuntu-amd64 on kapok.buildd finished at 2013-03-15 13:48:51 "
-            "(success)",
-            "ubuntu-i386 on cardamom.buildd finished at 2013-03-15 13:48:51 "
-            "(success)",
-        ], self.captured_log_messages())
-        self.assertEqual(4, mock_tracker_set_rebuild_status.call_count)
-        mock_tracker_set_rebuild_status.assert_has_calls([
-            mock.call(self.config, [0, 1], 2, "amd64"),
-            mock.call(self.config, [0, 1], 2, "i386"),
-            mock.call(self.config, [0, 1, 2], 3, "amd64"),
-            mock.call(self.config, [0, 1, 2], 3, "i386"),
-        ])
-        expected_command_base = [
-            "ssh", "-n", "-o", "StrictHostKeyChecking=no",
-            "-o", "BatchMode=yes",
-        ]
-        mock_popen.assert_has_calls([
-            mock.call(
-                expected_command_base + [
-                    "[e-mail]", "/home/buildd/bin/BuildLiveCD",
-                    "-l", "-A", "amd64", "-d", "trusty", "ubuntu",
-                ]),
-            mock.call(
-                expected_command_base + [
-                    "[e-mail]", "/home/buildd/bin/BuildLiveCD",
-                    "-l", "-A", "i386", "-d", "trusty", "ubuntu",
-                ])
-        ])
-        self.assertEqual(0, mock_live_build_notify_failure.call_count)
-
-    @mock.patch("cdimage.livefs.tracker_set_rebuild_status")
-    @mock_Popen(["true"])
-    @mock.patch("cdimage.livefs.live_build_notify_failure")
-    def test_run_live_builds_skips_amd64_mac(self,
-                                             mock_live_build_notify_failure,
-                                             mock_popen, *args):
-        self.config["PROJECT"] = "ubuntu"
-        self.config["DIST"] = "trusty"
-        self.config["IMAGE_TYPE"] = "daily"
-        self.config["ARCHES"] = "amd64 amd64+mac"
-        self.capture_logging()
-        self.assertCountEqual(
-            ["amd64", "amd64+mac"], run_live_builds(self.config))
-        expected_command = [
-            "ssh", "-n", "-o", "StrictHostKeyChecking=no",
-            "-o", "BatchMode=yes",
-            "[e-mail]", "/home/buildd/bin/BuildLiveCD",
-            "-l", "-A", "amd64", "-d", "trusty", "ubuntu",
-        ]
-        mock_popen.assert_called_once_with(expected_command)
-        self.assertEqual(0, mock_live_build_notify_failure.call_count)
-
-    @mock_strftime(1363355331)
-    @mock.patch("cdimage.livefs.urlopen", mock_urlopen(b"Log data\n"))
-    @mock.patch("cdimage.livefs.tracker_set_rebuild_status")
-    @mock.patch("cdimage.livefs.send_mail")
-    def test_run_live_builds_partial_success(self, mock_send_mail, *args):
-        self.config["PROJECT"] = "ubuntu"
-        self.config["DIST"] = "trusty"
-        self.config["IMAGE_TYPE"] = "daily"
-        self.config["ARCHES"] = "amd64 i386"
-        path = os.path.join(self.temp_dir, "production", "notify-addresses")
-        with mkfile(path) as notify_addresses:
-            print("ALL\[e-mail]", file=notify_addresses)
-        self.capture_logging()
-        original_Popen = subprocess.Popen
-        with mock.patch("subprocess.Popen") as mock_popen:
-            def Popen_side_effect(command, *args, **kwargs):
-                if "amd64" in command:
-                    return original_Popen(["true"])
-                else:
-                    return original_Popen(["false"])
-
-            mock_popen.side_effect = Popen_side_effect
-            self.assertCountEqual(["amd64"], run_live_builds(self.config))
-            self.assertCountEqual([
-                "ubuntu-amd64 on kapok.buildd starting at 2013-03-15 13:48:51",
-                "ubuntu-i386 on cardamom.buildd starting at "
-                "2013-03-15 13:48:51",
-                "ubuntu-amd64 on kapok.buildd finished at "
-                "2013-03-15 13:48:51 (success)",
-                "ubuntu-i386 on cardamom.buildd finished at "
-                "2013-03-15 13:48:51 (failed)",
-            ], self.captured_log_messages())
-            expected_command_base = [
-                "ssh", "-n", "-o", "StrictHostKeyChecking=no",
-                "-o", "BatchMode=yes",
-            ]
-            mock_popen.assert_has_calls([
-                mock.call(
-                    expected_command_base + [
-                        "[e-mail]", "/home/buildd/bin/BuildLiveCD",
-                        "-l", "-A", "amd64", "-d", "trusty", "ubuntu",
-                    ]),
-                mock.call(
-                    expected_command_base + [
-                        "[e-mail]",
-                        "/home/buildd/bin/BuildLiveCD",
-                        "-l", "-A", "i386", "-d", "trusty", "ubuntu",
-                    ]),
-            ])
-            mock_send_mail.assert_called_once_with(
-                "LiveFS ubuntu/trusty/i386 failed to build on 20130315",
-                "buildlive", ["[e-mail]"], b"Log data\n")
-
     @skipUnless(launchpad_available, "launchpadlib not available")
     @mock_strftime(1363355331)
     @mock.patch("time.sleep")
@@ -738,128 +380,6 @@ class TestRunLiveBuilds(TestCase):
         self.assertEqual("Successfully built", builds[1].buildstate)
         self.assertEqual(0, mock_live_build_notify_failure.call_count)
 
-    @skipUnless(launchpad_available, "launchpadlib not available")
-    @mock_strftime(1363355331)
-    @mock.patch("time.sleep")
-    @mock.patch("cdimage.livefs.tracker_set_rebuild_status")
-    @mock.patch("cdimage.livefs.live_build_notify_failure")
-    @mock.patch("cdimage.tests.test_livefs.MockLiveFSBuild._iter_buildstate")
-    @mock.patch("cdimage.launchpad.login")
-    def test_run_live_builds_lp_ubuntu_rtm(self, mock_login,
-                                           mock_iter_buildstate,
-                                           mock_live_build_notify_failure,
-                                           mock_tracker_set_rebuild_status,
-                                           mock_sleep, *args):
-        self.config["PROJECT"] = "ubuntu-touch"
-        self.config["DIST"] = "ubuntu-rtm/14.09"
-        self.config["IMAGE_TYPE"] = "daily-preinstalled"
-        self.config["ARCHES"] = "armhf i386"
-        osextras.unlink_force(os.path.join(
-            self.config.root, "production", "livefs-builders"))
-        with mkfile(os.path.join(
-                self.config.root, "production", "livefs-launchpad")) as f:
-            print(
-                "ubuntu-touch\tdaily-preinstalled\tubuntu-rtm/*\t*\t"
-                "dogfood/ubuntu-cdimage/ubuntu-touch", file=f)
-            print(
-                "ubuntu-touch\tdaily-preinstalled\t*\t*\t"
-                "ubuntu-cdimage/ubuntu-touch", file=f)
-        self.capture_logging()
-        mock_login.return_value = MockLaunchpad()
-        mock_iter_buildstate.side_effect = lambda: (
-            chain(["Needs building"] * 3, repeat("Successfully built")))
-        self.assertCountEqual(["armhf", "i386"], run_live_builds(self.config))
-        self.assertCountEqual([
-            "ubuntu-touch-armhf on Launchpad starting at 2013-03-15 13:48:51",
-            "ubuntu-touch-armhf: https://launchpad.example/armhf-build",
-            "ubuntu-touch-i386 on Launchpad starting at 2013-03-15 13:48:51",
-            "ubuntu-touch-i386: https://launchpad.example/i386-build",
-            "ubuntu-touch-armhf on Launchpad finished at 2013-03-15 13:48:51 "
-            "(Successfully built)",
-            "ubuntu-touch-i386 on Launchpad finished at 2013-03-15 13:48:51 "
-            "(Successfully built)",
-        ], self.captured_log_messages())
-        self.assertEqual(4, mock_tracker_set_rebuild_status.call_count)
-        mock_tracker_set_rebuild_status.assert_has_calls([
-            mock.call(self.config, [0, 1], 2, "armhf"),
-            mock.call(self.config, [0, 1], 2, "i386"),
-            mock.call(self.config, [0, 1, 2], 3, "armhf"),
-            mock.call(self.config, [0, 1, 2], 3, "i386"),
-        ])
-        self.assertEqual(3, mock_sleep.call_count)
-        mock_sleep.assert_has_calls([mock.call(15)] * 3)
-        lp = get_launchpad()
-        owner = lp.people["ubuntu-cdimage"]
-        ubuntu_rtm = lp.distributions["ubuntu-rtm"]
-        series = ubuntu_rtm.getSeries(name_or_version="14.09")
-        dases = [
-            series.getDistroArchSeries(archtag)
-            for archtag in ("armhf", "i386")]
-        self.assertEqual(2, len(dases))
-        livefs = lp.livefses.getByName(
-            owner=owner, distro_series=series, name="ubuntu-touch")
-        builds = [
-            livefs.getLatestBuild(distro_arch_series=das) for das in dases]
-        self.assertEqual(2, len(builds))
-        self.assertEqual("Successfully built", builds[0].buildstate)
-        self.assertEqual("Successfully built", builds[1].buildstate)
-        self.assertEqual(0, mock_live_build_notify_failure.call_count)
-
-
-class TestLiveCDBase(TestCase):
-    def setUp(self):
-        super(TestLiveCDBase, self).setUp()
-        self.config = Config(read=False)
-        self.config.root = self.use_temp_dir()
-        make_livefs_production_config(self.config)
-
-    def assertBaseEqual(self, expected, arch, project, series, **kwargs):
-        self.config["PROJECT"] = project
-        self.config["DIST"] = series
-        for key, value in kwargs.items():
-            self.config[key.upper()] = value
-        self.assertEqual(expected, livecd_base(self.config, arch))
-
-    def base(self, builder, project, series):
-        return "http://%s/~buildd/LiveCD/%s/%s/current" % (
-            builder, series, project)
-
-    def test_livecd_base_override(self):
-        self.assertBaseEqual(
-            "ftp://blah", "amd64", "ubuntu", "dapper",
-            livecd_base="ftp://blah")
-
-    def test_livecd_override(self):
-        self.assertBaseEqual(
-            "ftp://blah/trusty/ubuntu/current", "i386", "ubuntu", "trusty",
-            livecd="ftp://blah")
-
-    def test_subproject(self):
-        for series in all_series:
-            self.assertBaseEqual(
-                self.base("cardamom.buildd", "ubuntu-wubi", series),
-                "i386", "ubuntu", series, subproject="wubi")
-
-    def test_no_subarch(self):
-        for series in all_series:
-            self.assertBaseEqual(
-                self.base("cardamom.buildd", "ubuntu", series),
-                "i386", "ubuntu", series)
-
-    def test_subarch(self):
-        self.assertBaseEqual(
-            self.base("royal.buildd", "ubuntu-ps3", "trusty"),
-            "powerpc+ps3", "ubuntu", "trusty")
-        self.assertBaseEqual(
-            self.base("celbalrai.buildd", "ubuntu-server-omap", "trusty"),
-            "armel+omap", "ubuntu-server", "trusty")
-
-    def test_ubuntu_defaults_locale(self):
-        for series in all_series:
-            self.assertBaseEqual(
-                self.base("cardamom.buildd", "ubuntu-zh_CN", series),
-                "i386", "ubuntu", series, ubuntu_defaults_locale="zh_CN")
-
 
 class TestFlavours(TestCase):
     def assertFlavoursEqual(self, expected, arch, project, series):
@@ -941,6 +461,10 @@ class TestLiveItemPaths(TestCase):
         super(TestLiveItemPaths, self).setUp()
         self.config = Config(read=False)
         self.config.root = self.use_temp_dir()
+        _patcher = mock.patch("cdimage.livefs.get_lp_livefs")
+        mock_lp_livefs = _patcher.start()
+        mock_lp_livefs.return_value = None, MockLiveFSBuild()
+        self.addCleanup(_patcher.stop)
         make_livefs_production_config(self.config)
 
     def assertPathsEqual(self, expected, arch, item, project, series):