Merge ~twom/launchpad-buildd:add-charm-build into launchpad-buildd:master

[Tom Wardill]

Add charm building

Add building for charms using charmcraft with local network support.

[Colin Watson (cjwatson)]

review: Approve

[Colin Watson (cjwatson)]

review: Approve

diff --git a/debian/changelog b/debian/changelog
index 26c21ed..6543629 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,9 @@
+launchpad-buildd (197) UNRELEASED; urgency=medium
+
+  * Add charm building support
+
+ -- Tom Wardill <[e-mail]>  Mon, 07 Jun 2021 10:22:50 +0100
+
 launchpad-buildd (196) bionic; urgency=medium
 
   * Handle symlinks in OCI image files
diff --git a/lpbuildd/buildd-slave.tac b/lpbuildd/buildd-slave.tac
index 3299b0d..7c1947e 100644
--- a/lpbuildd/buildd-slave.tac
+++ b/lpbuildd/buildd-slave.tac
@@ -23,6 +23,7 @@ from twisted.web import (
 
 from lpbuildd.binarypackage import BinaryPackageBuildManager
 from lpbuildd.builder import XMLRPCBuilder
+from lpbuildd.charm import CharmBuildManager
 from lpbuildd.oci import OCIBuildManager
 from lpbuildd.livefs import LiveFilesystemBuildManager
 from lpbuildd.log import RotatableFileLogObserver
@@ -47,6 +48,7 @@ builder.registerManager(
 builder.registerManager(LiveFilesystemBuildManager, "livefs")
 builder.registerManager(SnapBuildManager, "snap")
 builder.registerManager(OCIBuildManager, "oci")
+builder.registerManager(CharmBuildManager, "charm")
 
 application = service.Application('Builder')
 application.addComponent(
diff --git a/lpbuildd/charm.py b/lpbuildd/charm.py
new file mode 100644
index 0000000..e5c5fe9
--- /dev/null
+++ b/lpbuildd/charm.py
@@ -0,0 +1,94 @@
+# Copyright 2021 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+from __future__ import print_function
+
+__metaclass__ = type
+
+import os
+
+from lpbuildd.debian import (
+    DebianBuildState,
+    DebianBuildManager,
+    )
+
+
+RETCODE_SUCCESS = 0
+RETCODE_FAILURE_INSTALL = 200
+RETCODE_FAILURE_BUILD = 201
+
+
+class CharmBuildState(DebianBuildState):
+    BUILD_CHARM = "BUILD_CHARM"
+
+
+class CharmBuildManager(DebianBuildManager):
+    """Build a charm."""
+
+    backend_name = "lxd"
+    initial_build_state = CharmBuildState.BUILD_CHARM
+
+    @property
+    def needs_sanitized_logs(self):
+        return True
+
+    def initiate(self, files, chroot, extra_args):
+        """Initiate a build with a given set of files and chroot."""
+        self.name = extra_args["name"]
+        self.branch = extra_args.get("branch")
+        self.git_repository = extra_args.get("git_repository")
+        self.git_path = extra_args.get("git_path")
+        self.build_path = extra_args.get("build_path")
+        self.channels = extra_args.get("channels", {})
+
+        super(CharmBuildManager, self).initiate(files, chroot, extra_args)
+
+    def doRunBuild(self):
+        """Run the process to build the charm."""
+        args = []
+        for snap, channel in sorted(self.channels.items()):
+            args.extend(["--channel", "%s=%s" % (snap, channel)])
+        if self.branch is not None:
+            args.extend(["--branch", self.branch])
+        if self.git_repository is not None:
+            args.extend(["--git-repository", self.git_repository])
+        if self.git_path is not None:
+            args.extend(["--git-path", self.git_path])
+        if self.build_path is not None:
+            args.extend(["--build-path", self.build_path])
+        args.append(self.name)
+        self.runTargetSubProcess("build-charm", *args)
+
+    def iterate_BUILD_CHARM(self, retcode):
+        """Finished building the charm."""
+        if retcode == RETCODE_SUCCESS:
+            print("Returning build status: OK")
+            return self.deferGatherResults()
+        elif (retcode >= RETCODE_FAILURE_INSTALL and
+              retcode <= RETCODE_FAILURE_BUILD):
+            if not self.alreadyfailed:
+                self._builder.buildFail()
+                print("Returning build status: Build failed.")
+            self.alreadyfailed = True
+        else:
+            if not self.alreadyfailed:
+                self._builder.builderFail()
+                print("Returning build status: Builder failed.")
+            self.alreadyfailed = True
+        self.doReapProcesses(self._state)
+
+    def iterateReap_BUILD_CHARM(self, retcode):
+        """Finished reaping after building the charm."""
+        self._state = DebianBuildState.UMOUNT
+        self.doUnmounting()
+
+    def gatherResults(self):
+        """Gather the results of the build and add them to the file cache."""
+        output_path = os.path.join("/home/buildd", self.name)
+        if self.backend.path_exists(output_path):
+            for entry in sorted(self.backend.listdir(output_path)):
+                path = os.path.join(output_path, entry)
+                if self.backend.islink(path):
+                    continue
+                if entry.endswith(".charm") or entry.endswith(".manifest"):
+                    self.addWaitingFileFromBackend(path)
diff --git a/lpbuildd/oci.py b/lpbuildd/oci.py
index 7a17939..53198c8 100644
--- a/lpbuildd/oci.py
+++ b/lpbuildd/oci.py
@@ -59,7 +59,7 @@ class OCIBuildManager(SnapBuildProxyMixin, DebianBuildManager):
         super(OCIBuildManager, self).initiate(files, chroot, extra_args)
 
     def doRunBuild(self):
-        """Run the process to build the snap."""
+        """Run the process to build the OCI image."""
         args = []
         args.extend(self.startProxy())
         if self.revocation_endpoint:
diff --git a/lpbuildd/target/backend.py b/lpbuildd/target/backend.py
index 8356542..a7e778e 100644
--- a/lpbuildd/target/backend.py
+++ b/lpbuildd/target/backend.py
@@ -13,6 +13,19 @@ class BackendException(Exception):
     pass
 
 
+class InvalidBuildFilePath(Exception):
+    pass
+
+
+def check_path_escape(buildd_path, path_to_check):
+    """Check the build file path doesn't escape the build directory."""
+    build_file_path = os.path.realpath(
+        os.path.join(buildd_path, path_to_check))
+    common_path = os.path.commonprefix((build_file_path, buildd_path))
+    if common_path != buildd_path:
+        raise InvalidBuildFilePath("Invalid build file path.")
+
+
 class Backend:
     """A backend implementation for the environment where we run builds."""
 
diff --git a/lpbuildd/target/build_charm.py b/lpbuildd/target/build_charm.py
new file mode 100644
index 0000000..6bd29cc
--- /dev/null
+++ b/lpbuildd/target/build_charm.py
@@ -0,0 +1,128 @@
+# Copyright 2021 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+from __future__ import print_function
+import functools
+
+__metaclass__ = type
+
+from collections import OrderedDict
+import logging
+import os
+import sys
+
+from lpbuildd.target.backend import check_path_escape
+from lpbuildd.target.build_snap import SnapChannelsAction
+from lpbuildd.target.operation import Operation
+from lpbuildd.target.snapstore import SnapStoreOperationMixin
+from lpbuildd.target.vcs import VCSOperationMixin
+
+
+RETCODE_FAILURE_INSTALL = 200
+RETCODE_FAILURE_BUILD = 201
+
+
+logger = logging.getLogger(__name__)
+
+
+class BuildCharm(VCSOperationMixin, SnapStoreOperationMixin, Operation):
+
+    description = "Build a charm."
+
+    core_snap_names = ["core", "core16", "core18", "core20"]
+
+    @classmethod
+    def add_arguments(cls, parser):
+        super(BuildCharm, cls).add_arguments(parser)
+        parser.add_argument(
+            "--channel", action=SnapChannelsAction, metavar="SNAP=CHANNEL",
+            dest="channels", default={}, help=(
+                "install SNAP from CHANNEL "
+                "(supported snaps: {}, charmcraft)".format(
+                    ", ".join(cls.core_snap_names))))
+        parser.add_argument(
+            "--build-path", default=".",
+            help="location of charm to build.")
+        parser.add_argument("name", help="name of charm to build")
+
+    def __init__(self, args, parser):
+        super(BuildCharm, self).__init__(args, parser)
+        self.bin = os.path.dirname(sys.argv[0])
+        self.buildd_path = os.path.join("/home/buildd", self.args.name)
+
+    def run_build_command(self, args, env=None, build_path=None, **kwargs):
+        """Run a build command in the target.
+
+        :param args: the command and arguments to run.
+        :param env: dictionary of additional environment variables to set.
+        :param kwargs: any other keyword arguments to pass to Backend.run.
+        """
+        full_env = OrderedDict()
+        full_env["LANG"] = "C.UTF-8"
+        full_env["SHELL"] = "/bin/sh"
+        if env:
+            full_env.update(env)
+        cwd = kwargs.pop('cwd', self.buildd_path)
+        return self.backend.run(
+            args, cwd=cwd, env=full_env, **kwargs)
+
+    def install(self):
+        logger.info("Running install phase")
+        deps = []
+        if self.args.backend == "lxd":
+            # udev is installed explicitly to work around
+            # https://bugs.launchpad.net/snapd/+bug/1731519.
+            for dep in "snapd", "fuse", "squashfuse", "udev":
+                if self.backend.is_package_available(dep):
+                    deps.append(dep)
+        deps.extend(self.vcs_deps)
+        self.backend.run(["apt-get", "-y", "install"] + deps)
+        if self.args.backend in ("lxd", "fake"):
+            self.snap_store_set_proxy()
+        for snap_name in self.core_snap_names:
+            if snap_name in self.args.channels:
+                self.backend.run(
+                    ["snap", "install",
+                     "--channel=%s" % self.args.channels[snap_name],
+                     snap_name])
+        if "charmcraft" in self.args.channels:
+            self.backend.run(
+                ["snap", "install",
+                 "--channel=%s" % self.args.channels["charmcraft"],
+                 "charmcraft"])
+        else:
+            self.backend.run(["snap", "install", "charmcraft"])
+        # The charmcraft snap can't see /build, so we have to do our work under
+        # /home/buildd instead.  Make sure it exists.
+        self.backend.run(["mkdir", "-p", "/home/buildd"])
+
+    def repo(self):
+        """Collect git or bzr branch."""
+        logger.info("Running repo phase...")
+        self.vcs_fetch(self.args.name, cwd="/home/buildd")
+        self.save_status(self.buildd_path)
+
+    def build(self):
+        logger.info("Running build phase...")
+        build_context_path = os.path.join(
+            "/home/buildd",
+            self.args.name,
+            self.args.build_path)
+        check_path_escape(self.buildd_path, build_context_path)
+        args = ["charmcraft", "build", "-f", build_context_path]
+        self.run_build_command(args)
+
+    def run(self):
+        try:
+            self.install()
+        except Exception:
+            logger.exception('Install failed')
+            return RETCODE_FAILURE_INSTALL
+        try:
+            self.repo()
+            self.build()
+        except Exception:
+            logger.exception('Build failed')
+            return RETCODE_FAILURE_BUILD
+        return 0
+
diff --git a/lpbuildd/target/build_oci.py b/lpbuildd/target/build_oci.py
index af56671..5615325 100644
--- a/lpbuildd/target/build_oci.py
+++ b/lpbuildd/target/build_oci.py
@@ -12,6 +12,7 @@ import sys
 import tempfile
 from textwrap import dedent
 
+from lpbuildd.target.backend import check_path_escape
 from lpbuildd.target.operation import Operation
 from lpbuildd.target.snapbuildproxy import SnapBuildProxyOperationMixin
 from lpbuildd.target.snapstore import SnapStoreOperationMixin
@@ -25,10 +26,6 @@ RETCODE_FAILURE_BUILD = 201
 logger = logging.getLogger(__name__)
 
 
-class InvalidBuildFilePath(Exception):
-    pass
-
-
 class BuildOCI(SnapBuildProxyOperationMixin, VCSOperationMixin,
                SnapStoreOperationMixin, Operation):
 
@@ -47,7 +44,7 @@ class BuildOCI(SnapBuildProxyOperationMixin, VCSOperationMixin,
             help="A docker build ARG in the format of key=value. "
                  "This option can be repeated many times. For example: "
                  "--build-arg VAR1=A --build-arg VAR2=B")
-        parser.add_argument("name", help="name of snap to build")
+        parser.add_argument("name", help="name of image to build")
 
     def __init__(self, args, parser):
         super(BuildOCI, self).__init__(args, parser)
@@ -72,14 +69,6 @@ class BuildOCI(SnapBuildProxyOperationMixin, VCSOperationMixin,
                 systemd_file.flush()
                 self.backend.copy_in(systemd_file.name, file_path)
 
-    def _check_path_escape(self, path_to_check):
-        """Check the build file path doesn't escape the build directory."""
-        build_file_path = os.path.realpath(
-            os.path.join(self.buildd_path, path_to_check))
-        common_path = os.path.commonprefix((build_file_path, self.buildd_path))
-        if common_path != self.buildd_path:
-            raise InvalidBuildFilePath("Invalid build file path.")
-
     def run_build_command(self, args, env=None, **kwargs):
         """Run a build command in the target.
 
@@ -130,7 +119,7 @@ class BuildOCI(SnapBuildProxyOperationMixin, VCSOperationMixin,
         if self.args.build_file is not None:
             build_file_path = os.path.join(
                 self.args.build_path, self.args.build_file)
-            self._check_path_escape(build_file_path)
+            check_path_escape(self.buildd_path, build_file_path)
             args.extend(["--file", build_file_path])
 
         # Keep this at the end, so we give the user a chance to override any
@@ -140,7 +129,7 @@ class BuildOCI(SnapBuildProxyOperationMixin, VCSOperationMixin,
 
         build_context_path = os.path.join(
             self.buildd_path, self.args.build_path)
-        self._check_path_escape(build_context_path)
+        check_path_escape(self.buildd_path, build_context_path)
         args.append(build_context_path)
         self.run_build_command(args)
 
diff --git a/lpbuildd/target/build_snap.py b/lpbuildd/target/build_snap.py
index 50fab7a..8b08cfa 100644
--- a/lpbuildd/target/build_snap.py
+++ b/lpbuildd/target/build_snap.py
@@ -99,17 +99,6 @@ class BuildSnap(SnapBuildProxyOperationMixin, VCSOperationMixin,
             full_env.update(env)
         return self.backend.run(args, env=full_env, **kwargs)
 
-    def save_status(self, status):
-        """Save a dictionary of status information about this build.
-
-        This will be picked up by the build manager and included in XML-RPC
-        status responses.
-        """
-        status_path = os.path.join(self.backend.build_path, "status")
-        with open("%s.tmp" % status_path, "w") as status_file:
-            json.dump(status, status_file)
-        os.rename("%s.tmp" % status_path, status_path)
-
     def install_svn_servers(self):
         proxy = urlparse(self.args.proxy_url)
         svn_servers = dedent("""\
@@ -173,23 +162,7 @@ class BuildSnap(SnapBuildProxyOperationMixin, VCSOperationMixin,
         logger.info("Running repo phase...")
         env = self.build_proxy_environment(proxy_url=self.args.proxy_url)
         self.vcs_fetch(self.args.name, cwd="/build", env=env)
-        status = {}
-        if self.args.branch is not None:
-            status["revision_id"] = self.run_build_command(
-                ["bzr", "revno"],
-                cwd=os.path.join("/build", self.args.name),
-                get_output=True, universal_newlines=True).rstrip("\n")
-        else:
-            rev = (
-                self.args.git_path
-                if self.args.git_path is not None else "HEAD")
-            status["revision_id"] = self.run_build_command(
-                # The ^{} suffix copes with tags: we want to peel them
-                # recursively until we get an actual commit.
-                ["git", "rev-parse", rev + "^{}"],
-                cwd=os.path.join("/build", self.args.name),
-                get_output=True, universal_newlines=True).rstrip("\n")
-        self.save_status(status)
+        self.save_status(os.path.join("/build", self.args.name))
 
     @property
     def image_info(self):
diff --git a/lpbuildd/target/cli.py b/lpbuildd/target/cli.py
index 94b291b..85e5b26 100644
--- a/lpbuildd/target/cli.py
+++ b/lpbuildd/target/cli.py
@@ -14,6 +14,7 @@ from lpbuildd.target.apt import (
     OverrideSourcesList,
     Update,
     )
+from lpbuildd.target.build_charm import BuildCharm
 from lpbuildd.target.build_oci import BuildOCI
 from lpbuildd.target.build_livefs import BuildLiveFS
 from lpbuildd.target.build_snap import BuildSnap
@@ -51,6 +52,7 @@ def configure_logging():
 operations = {
     "add-trusted-keys": AddTrustedKeys,
     "build-oci": BuildOCI,
+    "build-charm": BuildCharm,
     "buildlivefs": BuildLiveFS,
     "buildsnap": BuildSnap,
     "generate-translation-templates": GenerateTranslationTemplates,
diff --git a/lpbuildd/target/operation.py b/lpbuildd/target/operation.py
index 2f9fe64..7020786 100644
--- a/lpbuildd/target/operation.py
+++ b/lpbuildd/target/operation.py
@@ -5,6 +5,8 @@ from __future__ import print_function
 
 __metaclass__ = type
 
+import os
+
 from lpbuildd.target.backend import make_backend
 
 
diff --git a/lpbuildd/target/tests/test_build_charm.py b/lpbuildd/target/tests/test_build_charm.py
new file mode 100644
index 0000000..2900879
--- /dev/null
+++ b/lpbuildd/target/tests/test_build_charm.py
@@ -0,0 +1,427 @@
+# Copyright 2019 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+__metaclass__ = type
+
+import json
+import os
+import subprocess
+from textwrap import dedent
+
+from fixtures import (
+    FakeLogger,
+    TempDir,
+    )
+import responses
+from testtools.matchers import (
+    AnyMatch,
+    Equals,
+    Is,
+    MatchesAll,
+    MatchesDict,
+    MatchesListwise,
+    )
+from testtools.testcase import TestCase
+
+from lpbuildd.target.backend import InvalidBuildFilePath
+from lpbuildd.target.build_charm import (
+    RETCODE_FAILURE_BUILD,
+    RETCODE_FAILURE_INSTALL,
+    )
+from lpbuildd.tests.fakebuilder import FakeMethod
+from lpbuildd.target.tests.test_build_snap import (
+    FakeRevisionID,
+    RanSnap,
+    )
+from lpbuildd.target.cli import parse_args
+
+
+class RanCommand(MatchesListwise):
+
+    def __init__(self, args, echo=None, cwd=None, input_text=None,
+                 get_output=None, universal_newlines=None, **env):
+        kwargs_matcher = {}
+        if echo is not None:
+            kwargs_matcher["echo"] = Is(echo)
+        if cwd:
+            kwargs_matcher["cwd"] = Equals(cwd)
+        if input_text:
+            kwargs_matcher["input_text"] = Equals(input_text)
+        if get_output is not None:
+            kwargs_matcher["get_output"] = Is(get_output)
+        if universal_newlines is not None:
+            kwargs_matcher["universal_newlines"] = Is(universal_newlines)
+        if env:
+            kwargs_matcher["env"] = MatchesDict(
+                {key: Equals(value) for key, value in env.items()})
+        super(RanCommand, self).__init__(
+            [Equals((args,)), MatchesDict(kwargs_matcher)])
+
+
+class RanAptGet(RanCommand):
+
+    def __init__(self, *args):
+        super(RanAptGet, self).__init__(["apt-get", "-y"] + list(args))
+
+
+class RanBuildCommand(RanCommand):
+
+    def __init__(self, args, **kwargs):
+        kwargs.setdefault("LANG", "C.UTF-8")
+        kwargs.setdefault("SHELL", "/bin/sh")
+        super(RanBuildCommand, self).__init__(args, **kwargs)
+
+
+class TestBuildCharm(TestCase):
+
+    def test_run_build_command_no_env(self):
+        args = [
+            "build-charm",
+            "--backend=fake", "--series=xenial", "--arch=amd64", "1",
+            "--branch", "lp:foo", "test-image",
+            ]
+        build_charm = parse_args(args=args).operation
+        build_charm.run_build_command(["echo", "hello world"])
+        self.assertThat(build_charm.backend.run.calls, MatchesListwise([
+            RanBuildCommand(
+                ["echo", "hello world"],
+                cwd="/home/buildd/test-image"),
+            ]))
+
+    def test_run_build_command_env(self):
+        args = [
+            "build-charm",
+            "--backend=fake", "--series=xenial", "--arch=amd64", "1",
+            "--branch", "lp:foo", "test-image",
+            ]
+        build_charm = parse_args(args=args).operation
+        build_charm.run_build_command(
+            ["echo", "hello world"], env={"FOO": "bar baz"})
+        self.assertThat(build_charm.backend.run.calls, MatchesListwise([
+            RanBuildCommand(
+                ["echo", "hello world"],
+                FOO="bar baz",
+                cwd="/home/buildd/test-image")
+            ]))
+
+    def test_install_channels(self):
+        args = [
+            "build-charm",
+            "--backend=fake", "--series=xenial", "--arch=amd64", "1",
+            "--channel=core=candidate", "--channel=core18=beta",
+            "--channel=charmcraft=edge",
+            "--branch", "lp:foo", "test-snap",
+            ]
+        build_snap = parse_args(args=args).operation
+        build_snap.install()
+        self.assertThat(build_snap.backend.run.calls, MatchesListwise([
+            RanAptGet("install", "bzr"),
+            RanSnap("install", "--channel=candidate", "core"),
+            RanSnap("install", "--channel=beta", "core18"),
+            RanSnap("install", "--channel=edge", "charmcraft"),
+            RanCommand(["mkdir", "-p", "/home/buildd"]),
+            ]))
+
+    def test_install_bzr(self):
+        args = [
+            "build-charm",
+            "--backend=fake", "--series=xenial", "--arch=amd64", "1",
+            "--branch", "lp:foo", "test-image"
+            ]
+        build_charm = parse_args(args=args).operation
+        build_charm.install()
+        self.assertThat(build_charm.backend.run.calls, MatchesListwise([
+            RanAptGet("install", "bzr"),
+            RanCommand(["snap", "install", "charmcraft"]),
+            RanCommand(["mkdir", "-p", "/home/buildd"]),
+            ]))
+
+    def test_install_git(self):
+        args = [
+            "build-charm",
+            "--backend=fake", "--series=xenial", "--arch=amd64", "1",
+            "--git-repository", "lp:foo", "test-image"
+            ]
+        build_charm = parse_args(args=args).operation
+        build_charm.install()
+        self.assertThat(build_charm.backend.run.calls, MatchesListwise([
+            RanAptGet("install", "git"),
+            RanCommand(["snap", "install", "charmcraft"]),
+            RanCommand(["mkdir", "-p", "/home/buildd"]),
+            ]))
+
+    @responses.activate
+    def test_install_snap_store_proxy(self):
+        store_assertion = dedent("""\
+            type: store
+            store: store-id
+            url: http://snap-store-proxy.example
+
+            body
+            """)
+
+        def respond(request):
+            return 200, {"X-Assertion-Store-Id": "store-id"}, store_assertion
+
+        responses.add_callback(
+            "GET", "http://snap-store-proxy.example/v2/auth/store/assertions",
+            callback=respond)
+        args = [
+            "build-charm",
+            "--backend=fake", "--series=xenial", "--arch=amd64", "1",
+            "--git-repository", "lp:foo",
+            "--snap-store-proxy-url", "http://snap-store-proxy.example/",
+            "test-snap",
+            ]
+        build_snap = parse_args(args=args).operation
+        build_snap.install()
+        self.assertThat(build_snap.backend.run.calls, MatchesListwise([
+            RanAptGet("install", "git"),
+            RanCommand(
+                ["snap", "ack", "/dev/stdin"], input_text=store_assertion),
+            RanCommand(["snap", "set", "core", "proxy.store=store-id"]),
+            RanSnap("install", "charmcraft"),
+            RanCommand(["mkdir", "-p", "/home/buildd"]),
+            ]))
+
+    def test_repo_bzr(self):
+        args = [
+            "build-charm",
+            "--backend=fake", "--series=xenial", "--arch=amd64", "1",
+            "--branch", "lp:foo", "test-image",
+            ]
+        build_charm = parse_args(args=args).operation
+        build_charm.backend.build_path = self.useFixture(TempDir()).path
+        build_charm.backend.run = FakeRevisionID("42")
+        build_charm.repo()
+        self.assertThat(build_charm.backend.run.calls, MatchesListwise([
+            RanBuildCommand(
+                ["bzr", "branch", "lp:foo", "test-image"], cwd="/home/buildd"),
+            RanBuildCommand(
+                ["bzr", "revno"],
+                cwd="/home/buildd/test-image", get_output=True,
+                universal_newlines=True),
+            ]))
+        status_path = os.path.join(build_charm.backend.build_path, "status")
+        with open(status_path) as status:
+            self.assertEqual({"revision_id": "42"}, json.load(status))
+
+    def test_repo_git(self):
+        args = [
+            "build-charm",
+            "--backend=fake", "--series=xenial", "--arch=amd64", "1",
+            "--git-repository", "lp:foo", "test-image",
+            ]
+        build_charm = parse_args(args=args).operation
+        build_charm.backend.build_path = self.useFixture(TempDir()).path
+        build_charm.backend.run = FakeRevisionID("0" * 40)
+        build_charm.repo()
+        self.assertThat(build_charm.backend.run.calls, MatchesListwise([
+            RanBuildCommand(
+                ["git", "clone", "lp:foo", "test-image"], cwd="/home/buildd"),
+            RanBuildCommand(
+                ["git", "submodule", "update", "--init", "--recursive"],
+                cwd="/home/buildd/test-image"),
+            RanBuildCommand(
+                ["git", "rev-parse", "HEAD^{}"],
+                cwd="/home/buildd/test-image",
+                get_output=True, universal_newlines=True),
+            ]))
+        status_path = os.path.join(build_charm.backend.build_path, "status")
+        with open(status_path) as status:
+            self.assertEqual({"revision_id": "0" * 40}, json.load(status))
+
+    def test_repo_git_with_path(self):
+        args = [
+            "build-charm",
+            "--backend=fake", "--series=xenial", "--arch=amd64", "1",
+            "--git-repository", "lp:foo", "--git-path", "next", "test-image",
+            ]
+        build_charm = parse_args(args=args).operation
+        build_charm.backend.build_path = self.useFixture(TempDir()).path
+        build_charm.backend.run = FakeRevisionID("0" * 40)
+        build_charm.repo()
+        self.assertThat(build_charm.backend.run.calls, MatchesListwise([
+            RanBuildCommand(
+                ["git", "clone", "-b", "next", "lp:foo", "test-image"],
+                cwd="/home/buildd"),
+            RanBuildCommand(
+                ["git", "submodule", "update", "--init", "--recursive"],
+                cwd="/home/buildd/test-image"),
+            RanBuildCommand(
+                ["git", "rev-parse", "next^{}"],
+                cwd="/home/buildd/test-image", get_output=True,
+                universal_newlines=True),
+            ]))
+        status_path = os.path.join(build_charm.backend.build_path, "status")
+        with open(status_path) as status:
+            self.assertEqual({"revision_id": "0" * 40}, json.load(status))
+
+    def test_repo_git_with_tag_path(self):
+        args = [
+            "build-charm",
+            "--backend=fake", "--series=xenial", "--arch=amd64", "1",
+            "--git-repository", "lp:foo", "--git-path", "refs/tags/1.0",
+            "test-image",
+            ]
+        build_charm = parse_args(args=args).operation
+        build_charm.backend.build_path = self.useFixture(TempDir()).path
+        build_charm.backend.run = FakeRevisionID("0" * 40)
+        build_charm.repo()
+        self.assertThat(build_charm.backend.run.calls, MatchesListwise([
+            RanBuildCommand(
+                ["git", "clone", "-b", "1.0", "lp:foo", "test-image"],
+                cwd="/home/buildd"),
+            RanBuildCommand(
+                ["git", "submodule", "update", "--init", "--recursive"],
+                cwd="/home/buildd/test-image"),
+            RanBuildCommand(
+                ["git", "rev-parse", "refs/tags/1.0^{}"],
+                cwd="/home/buildd/test-image", get_output=True,
+                universal_newlines=True),
+            ]))
+        status_path = os.path.join(build_charm.backend.build_path, "status")
+        with open(status_path) as status:
+            self.assertEqual({"revision_id": "0" * 40}, json.load(status))
+
+    def test_build(self):
+        args = [
+            "build-charm",
+            "--backend=fake", "--series=xenial", "--arch=amd64", "1",
+            "--branch", "lp:foo", "test-image",
+            ]
+        build_charm = parse_args(args=args).operation
+        build_charm.backend.add_dir('/build/test-directory')
+        build_charm.build()
+        self.assertThat(build_charm.backend.run.calls, MatchesListwise([
+            RanBuildCommand(
+                ["charmcraft", "build", "-f",
+                 "/home/buildd/test-image/."],
+                cwd="/home/buildd/test-image"),
+            ]))
+
+    def test_build_with_path(self):
+        args = [
+            "build-charm",
+            "--backend=fake", "--series=xenial", "--arch=amd64", "1",
+            "--branch", "lp:foo", "--build-path", "build-aux/",
+            "test-image",
+            ]
+        build_charm = parse_args(args=args).operation
+        build_charm.backend.add_dir('/build/test-directory')
+        build_charm.build()
+        self.assertThat(build_charm.backend.run.calls, MatchesListwise([
+            RanBuildCommand(
+                ["charmcraft", "build", "-f",
+                 "/home/buildd/test-image/build-aux/"],
+                cwd="/home/buildd/test-image"),
+            ]))
+
+    def test_run_succeeds(self):
+        args = [
+            "build-charm",
+            "--backend=fake", "--series=xenial", "--arch=amd64", "1",
+            "--branch", "lp:foo", "test-image",
+            ]
+        build_charm = parse_args(args=args).operation
+        build_charm.backend.build_path = self.useFixture(TempDir()).path
+        build_charm.backend.run = FakeRevisionID("42")
+        self.assertEqual(0, build_charm.run())
+        self.assertThat(build_charm.backend.run.calls, MatchesAll(
+            AnyMatch(RanAptGet("install", "bzr"),),
+            AnyMatch(RanBuildCommand(
+                ["bzr", "branch", "lp:foo", "test-image"],
+                cwd="/home/buildd")),
+            AnyMatch(RanBuildCommand(
+                ["charmcraft", "build", "-f",
+                 "/home/buildd/test-image/."],
+                cwd="/home/buildd/test-image")),
+            ))
+
+    def test_run_install_fails(self):
+        class FailInstall(FakeMethod):
+            def __call__(self, run_args, *args, **kwargs):
+                super(FailInstall, self).__call__(run_args, *args, **kwargs)
+                if run_args[0] == "apt-get":
+                    raise subprocess.CalledProcessError(1, run_args)
+
+        self.useFixture(FakeLogger())
+        args = [
+            "build-charm",
+            "--backend=fake", "--series=xenial", "--arch=amd64", "1",
+            "--branch", "lp:foo", "test-image",
+            ]
+        build_charm = parse_args(args=args).operation
+        build_charm.backend.run = FailInstall()
+        self.assertEqual(RETCODE_FAILURE_INSTALL, build_charm.run())
+
+    def test_run_repo_fails(self):
+        class FailRepo(FakeMethod):
+            def __call__(self, run_args, *args, **kwargs):
+                super(FailRepo, self).__call__(run_args, *args, **kwargs)
+                if run_args[:2] == ["bzr", "branch"]:
+                    raise subprocess.CalledProcessError(1, run_args)
+
+        self.useFixture(FakeLogger())
+        args = [
+            "build-charm",
+            "--backend=fake", "--series=xenial", "--arch=amd64", "1",
+            "--branch", "lp:foo", "test-image",
+            ]
+        build_charm = parse_args(args=args).operation
+        build_charm.backend.run = FailRepo()
+        self.assertEqual(RETCODE_FAILURE_BUILD, build_charm.run())
+
+    def test_run_build_fails(self):
+        class FailBuild(FakeMethod):
+            def __call__(self, run_args, *args, **kwargs):
+                super(FailBuild, self).__call__(run_args, *args, **kwargs)
+                if run_args[0] == "charmcraft":
+                    raise subprocess.CalledProcessError(1, run_args)
+
+        self.useFixture(FakeLogger())
+        args = [
+            "build-charm",
+            "--backend=fake", "--series=xenial", "--arch=amd64", "1",
+            "--branch", "lp:foo", "test-image",
+            ]
+        build_charm = parse_args(args=args).operation
+        build_charm.backend.build_path = self.useFixture(TempDir()).path
+        build_charm.backend.run = FailBuild()
+        self.assertEqual(RETCODE_FAILURE_BUILD, build_charm.run())
+
+    def test_build_with_invalid_build_path_parent(self):
+        args = [
+            "build-charm",
+            "--backend=fake", "--series=xenial", "--arch=amd64", "1",
+            "--branch", "lp:foo", "--build-path", "../",
+            "test-image",
+            ]
+        build_charm = parse_args(args=args).operation
+        build_charm.backend.add_dir('/build/test-directory')
+        self.assertRaises(InvalidBuildFilePath, build_charm.build)
+
+    def test_build_with_invalid_build_path_absolute(self):
+        args = [
+            "build-charm",
+            "--backend=fake", "--series=xenial", "--arch=amd64", "1",
+            "--branch", "lp:foo", "--build-path", "/etc",
+            "test-image",
+            ]
+        build_charm = parse_args(args=args).operation
+        build_charm.backend.add_dir('/build/test-directory')
+        self.assertRaises(InvalidBuildFilePath, build_charm.build)
+
+    def test_build_with_invalid_build_path_symlink(self):
+        args = [
+            "build-charm",
+            "--backend=fake", "--series=xenial", "--arch=amd64", "1",
+            "--branch", "lp:foo", "--build-path", "build/",
+            "test-image",
+            ]
+        build_charm = parse_args(args=args).operation
+        build_charm.buildd_path = self.useFixture(TempDir()).path
+        os.symlink(
+            '/etc/hosts',
+            os.path.join(build_charm.buildd_path, 'build'))
+        self.assertRaises(InvalidBuildFilePath, build_charm.build)
diff --git a/lpbuildd/target/tests/test_build_oci.py b/lpbuildd/target/tests/test_build_oci.py
index e58344f..3b9966a 100644
--- a/lpbuildd/target/tests/test_build_oci.py
+++ b/lpbuildd/target/tests/test_build_oci.py
@@ -24,8 +24,8 @@ from testtools.matchers import (
     MatchesListwise,
     )
 
+from lpbuildd.target.backend import InvalidBuildFilePath
 from lpbuildd.target.build_oci import (
-    InvalidBuildFilePath,
     RETCODE_FAILURE_BUILD,
     RETCODE_FAILURE_INSTALL,
     )
diff --git a/lpbuildd/target/vcs.py b/lpbuildd/target/vcs.py
index cb9875d..d7c80c3 100644
--- a/lpbuildd/target/vcs.py
+++ b/lpbuildd/target/vcs.py
@@ -6,6 +6,7 @@ from __future__ import print_function
 __metaclass__ = type
 
 from collections import OrderedDict
+import json
 import logging
 import os.path
 import subprocess
@@ -101,3 +102,30 @@ class VCSOperationMixin:
                 logger.error(
                     "'git submodule update --init --recursive failed with "
                     "exit code %s (build may fail later)" % e.returncode)
+
+    def save_status(self, cwd):
+        """Save a dictionary of status information about this build.
+
+        This will be picked up by the build manager and included in XML-RPC
+        status responses.
+        """
+        status = {}
+        if self.args.branch is not None:
+            status["revision_id"] = self.run_build_command(
+                ["bzr", "revno"],
+                cwd=cwd,
+                get_output=True, universal_newlines=True).rstrip("\n")
+        else:
+            rev = (
+                self.args.git_path
+                if self.args.git_path is not None else "HEAD")
+            status["revision_id"] = self.run_build_command(
+                # The ^{} suffix copes with tags: we want to peel them
+                # recursively until we get an actual commit.
+                ["git", "rev-parse", rev + "^{}"],
+                cwd=cwd,
+                get_output=True, universal_newlines=True).rstrip("\n")
+        status_path = os.path.join(self.backend.build_path, "status")
+        with open("%s.tmp" % status_path, "w") as status_file:
+            json.dump(status, status_file)
+        os.rename("%s.tmp" % status_path, status_path)
diff --git a/lpbuildd/tests/test_charm.py b/lpbuildd/tests/test_charm.py
new file mode 100644
index 0000000..407f732
--- /dev/null
+++ b/lpbuildd/tests/test_charm.py
@@ -0,0 +1,139 @@
+# Copyright 2021 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+__metaclass__ = type
+
+import os
+
+from fixtures import (
+    EnvironmentVariable,
+    TempDir,
+    )
+from testtools import TestCase
+from testtools.deferredruntest import AsynchronousDeferredRunTest
+from twisted.internet import defer
+
+from lpbuildd.charm import CharmBuildManager, CharmBuildState
+from lpbuildd.tests.fakebuilder import FakeBuilder
+from lpbuildd.tests.matchers import HasWaitingFiles
+
+
+class MockBuildManager(CharmBuildManager):
+    def __init__(self, *args, **kwargs):
+        super(MockBuildManager, self).__init__(*args, **kwargs)
+        self.commands = []
+        self.iterators = []
+
+    def runSubProcess(self, path, command, iterate=None, env=None):
+        self.commands.append([path] + command)
+        if iterate is None:
+            iterate = self.iterate
+        self.iterators.append(iterate)
+        return 0
+
+
+class TestCharmBuildManagerIteration(TestCase):
+    """Run CharmBuildManager through its iteration steps."""
+
+    run_tests_with = AsynchronousDeferredRunTest.make_factory(timeout=5)
+
+    def setUp(self):
+        super(TestCharmBuildManagerIteration, self).setUp()
+        self.working_dir = self.useFixture(TempDir()).path
+        builder_dir = os.path.join(self.working_dir, "builder")
+        home_dir = os.path.join(self.working_dir, "home")
+        for dir in (builder_dir, home_dir):
+            os.mkdir(dir)
+        self.useFixture(EnvironmentVariable("HOME", home_dir))
+        self.builder = FakeBuilder(builder_dir)
+        self.buildid = "123"
+        self.buildmanager = MockBuildManager(self.builder, self.buildid)
+        self.buildmanager._cachepath = self.builder._cachepath
+
+    def getState(self):
+        """Retrieve build manager's state."""
+        return self.buildmanager._state
+
+    @defer.inlineCallbacks
+    def startBuild(self, args=None, options=None):
+        # The build manager's iterate() kicks off the consecutive states
+        # after INIT.
+        extra_args = {
+            "series": "xenial",
+            "arch_tag": "i386",
+            "name": "test-charm",
+            }
+        if args is not None:
+            extra_args.update(args)
+        original_backend_name = self.buildmanager.backend_name
+        self.buildmanager.backend_name = "fake"
+        self.buildmanager.initiate({}, "chroot.tar.gz", extra_args)
+        self.buildmanager.backend_name = original_backend_name
+
+        # Skip states that are done in DebianBuildManager to the state
+        # directly before BUILD_CHARM.
+        self.buildmanager._state = CharmBuildState.UPDATE
+
+        # BUILD_CHARM: Run the builder's payload to build the charm.
+        yield self.buildmanager.iterate(0)
+        self.assertEqual(CharmBuildState.BUILD_CHARM, self.getState())
+        expected_command = [
+            "sharepath/bin/in-target", "in-target", "build-charm",
+            "--backend=lxd", "--series=xenial", "--arch=i386", self.buildid,
+            ]
+        if options is not None:
+            expected_command.extend(options)
+        expected_command.append("test-charm")
+        self.assertEqual(expected_command, self.buildmanager.commands[-1])
+        self.assertEqual(
+            self.buildmanager.iterate, self.buildmanager.iterators[-1])
+        self.assertFalse(self.builder.wasCalled("chrootFail"))
+
+    @defer.inlineCallbacks
+    def test_iterate(self):
+        # The build manager iterates a normal build from start to finish.
+        args = {
+            "git_repository": "https://git.launchpad.dev/~example/+git/charm",
+            "git_path": "master",
+            }
+        expected_options = [
+            "--git-repository", "https://git.launchpad.dev/~example/+git/charm",
+            "--git-path", "master",
+            ]
+        yield self.startBuild(args, expected_options)
+
+        log_path = os.path.join(self.buildmanager._cachepath, "buildlog")
+        with open(log_path, "w") as log:
+            log.write("I am a build log.")
+
+        self.buildmanager.backend.add_file(
+            "/home/buildd/test-charm/test-charm_0_all.charm",
+            b"I am charming.")
+
+        # After building the package, reap processes.
+        yield self.buildmanager.iterate(0)
+        expected_command = [
+            "sharepath/bin/in-target", "in-target", "scan-for-processes",
+            "--backend=lxd", "--series=xenial", "--arch=i386", self.buildid,
+            ]
+
+        self.assertEqual(CharmBuildState.BUILD_CHARM, self.getState())
+        self.assertEqual(expected_command, self.buildmanager.commands[-1])
+        self.assertNotEqual(
+            self.buildmanager.iterate, self.buildmanager.iterators[-1])
+        self.assertFalse(self.builder.wasCalled("buildFail"))
+        self.assertThat(self.builder, HasWaitingFiles.byEquality({
+            "test-charm_0_all.charm": b"I am charming.",
+            }))
+
+        # Control returns to the DebianBuildManager in the UMOUNT state.
+        self.buildmanager.iterateReap(self.getState(), 0)
+        expected_command = [
+            "sharepath/bin/in-target", "in-target", "umount-chroot",
+            "--backend=lxd", "--series=xenial", "--arch=i386", self.buildid,
+            ]
+        self.assertEqual(CharmBuildState.UMOUNT, self.getState())
+        self.assertEqual(expected_command, self.buildmanager.commands[-1])
+        self.assertEqual(
+            self.buildmanager.iterate, self.buildmanager.iterators[-1])
+        self.assertFalse(self.builder.wasCalled("buildFail"))
diff --git a/lpbuildd/tests/test_oci.py b/lpbuildd/tests/test_oci.py
index 78b0dbb..7fc0b3a 100644
--- a/lpbuildd/tests/test_oci.py
+++ b/lpbuildd/tests/test_oci.py
@@ -89,7 +89,7 @@ class TestOCIBuildManagerIteration(TestCase):
         # directly before BUILD_OCI.
         self.buildmanager._state = OCIBuildState.UPDATE
 
-        # BUILD_OCI: Run the builder's payload to build the snap package.
+        # BUILD_OCI: Run the builder's payload to build the OCI image.
         yield self.buildmanager.iterate(0)
         self.assertEqual(OCIBuildState.BUILD_OCI, self.getState())
         expected_command = [