Merge ~mwhudson/ubuntu-cdimage:deb822-sources into ubuntu-cdimage:main

[Michael Hudson-Doyle]

This changes ubuntu-cdimage to set up a chdist-like apt environment for each architecture, adds code to use that for germination (although that cannot be used until https://code.launchpad.net/~mwhudson/germinate/+git/germinate-1/+merge/456723 is in place) and tells debian-cd about it via an environment variable (although the debian-cd branches to make use of this are not even in review yet).

As such this should be harmless if a little wasteful to merge and deploy at this point. But it would be still interesting to have a review of it!

[Steve Langasek (vorlon)]

appears that this currently fails CI, holding review until resolved https://code.launchpad.net/~mwhudson/ubuntu-cdimage/+git/ubuntu-cdimage-1/+build/67241

[Michael Hudson-Doyle (mwhudson)]

I fixed that a while ago now...

[Michael Hudson-Doyle (mwhudson)]

I think this is ready for review. I think it will be slightly wasteful (basically it will download the package lists an extra time) but not change behaviour at all in its current form.

[Michael Hudson-Doyle (mwhudson)]

So to expand:

1) This can be landed now safely (I think!)
2) Then we can land https://code.launchpad.net/~mwhudson/debian-cd/+git/ubuntu/+merge/460372 which will use the apt configs this branch makes to fetch packages from the pool.
3) The final step is to use the apt configs this branch makes for germination too. The relevant germinate branch has landed now but I don't know if the checkout on the ftpmaster machine has been updated yet.

[Michael Hudson-Doyle (mwhudson)]

One thing I am not 100% sure I've got right is handling a build with non-trivial subarch. I should try one of those locally at some point.

[Łukasz Zemczak (sil2100)]

I think this is good enough. Conceptually, of course, I am not entirely sure if cdimage is the right place for generation of such configuration. Conceptually cdimage should only care about triggering builds, packing them up, publishing, cleaning up... Conceptually... But in reality right now it doesn't.

So I'm fine with merging this as-is, since I assume it's better to do it here in cdimage than debian-cd as we're running germinate here. That being said, actually I'm curious why we're calling germinate here, since I think the only consumer so far is debian-cd? So many questions, so little answers.

I think subarch handling should work fine, since if it does not then it means cpuarches was broken (which I don't know if we actually use that much anyway).

review: Approve

[Michael Hudson-Doyle (mwhudson)]

I think eventually the bulk of this should move into livecd-rootfs or ubuntu-image or imagecraft or whatever. But one step at a time!

[Michael Hudson-Doyle (mwhudson)]

Thanks for the review btw!

diff --git a/.launchpad.yaml b/.launchpad.yaml
index bef522b..bb396c1 100644
--- a/.launchpad.yaml
+++ b/.launchpad.yaml
@@ -5,7 +5,17 @@ jobs:
     run-tests:
         series: jammy
         architectures: amd64
-        packages: [dctrl-tools, python3, python3, python3-mock, python3-simplestreams, procmail, squashfs-tools, file, pycodestyle, pyflakes3]
+        packages:
+          - dctrl-tools
+          - file
+          - procmail
+          - pycodestyle
+          - pyflakes3
+          - python3
+          - python3-apt
+          - python3-mock
+          - python3-simplestreams
+          - squashfs-tools
         run: ./run-tests >output
         output:
             paths: [output]
diff --git a/lib/cdimage/build.py b/lib/cdimage/build.py
index b3b296e..02e59ee 100644
--- a/lib/cdimage/build.py
+++ b/lib/cdimage/build.py
@@ -40,7 +40,7 @@ from cdimage.livefs import (
 )
 from cdimage.log import logger, reset_logging
 from cdimage.mail import get_notify_addresses, send_mail
-from cdimage.mirror import trigger_mirrors
+from cdimage.mirror import AptStateManager, trigger_mirrors
 from cdimage.tracker import tracker_set_rebuild_status
 from cdimage.tree import Publisher, Tree
 
@@ -532,10 +532,13 @@ def configure_splash(config):
             config[key] = generic_image
 
 
-def run_debian_cd(config):
+def run_debian_cd(config, apt_state_mgr):
     log_marker("Building %s daily CDs" % config.capproject)
     debian_cd_dir = os.path.join(config.root, "debian-cd")
-    subprocess.call(["./build_all.sh"], cwd=debian_cd_dir, env=config.export())
+    env = config.export()
+    for cpuarch in config.cpuarches:
+        env["APT_CONFIG_" + cpuarch] = apt_state_mgr.apt_conf_for_arch(cpuarch)
+    subprocess.call(["./build_all.sh"], cwd=debian_cd_dir, env=env)
 
 
 def fix_permissions(config):
@@ -652,7 +655,14 @@ def build_image_set_locked(config, options):
         else:
             assert not config["CDIMAGE_PREINSTALLED"]
 
+            apt_state_mgr = AptStateManager(config)
+            apt_state_mgr.setup()
+
             log_marker("Germinating")
+            # Cannot use apt_state_mgr for germination until
+            # https://code.launchpad.net/~mwhudson/germinate/+git/
+            #     germinate-1/+merge/456723
+            # is merged.
             germination = Germination(config)
             germination.run()
 
@@ -669,7 +679,7 @@ def build_image_set_locked(config, options):
 
             configure_splash(config)
 
-            run_debian_cd(config)
+            run_debian_cd(config, apt_state_mgr)
             copy_netboot_tarballs(config)
             fix_permissions(config)
 
diff --git a/lib/cdimage/config.py b/lib/cdimage/config.py
index 3de5c65..1c263cc 100644
--- a/lib/cdimage/config.py
+++ b/lib/cdimage/config.py
@@ -288,6 +288,7 @@ _allowed_keys = (
     "EXTRA_PPAS",
     "CHANNEL",
     "SIMPLESTREAMS",
+    "APT_PROXY",
 )
 
 
diff --git a/lib/cdimage/germinate.py b/lib/cdimage/germinate.py
index f33ef6a..dcc5e88 100644
--- a/lib/cdimage/germinate.py
+++ b/lib/cdimage/germinate.py
@@ -39,10 +39,11 @@ class GerminateNotInstalled(Exception):
 
 
 class Germination:
-    def __init__(self, config, prefer_vcs=True):
+    def __init__(self, config, prefer_vcs=True, apt_state_mgr=None):
         self.config = config
         # Set to False to use old-style seed checkouts.
         self.prefer_vcs = prefer_vcs
+        self.apt_state_mgr = apt_state_mgr
 
     @property
     def germinate_path(self):
@@ -152,13 +153,20 @@ class Germination:
         command = [
             self.germinate_path,
             "--seed-source", ",".join(self.seed_sources()),
-            "--mirror", find_mirror(self.config.project, arch),
             "--seed-dist", self.seed_dist(),
-            "--dist", ",".join(self.germinate_dists),
             "--arch", cpuarch,
-            "--components", ",".join(self.components),
             "--no-rdepends",
         ]
+        if self.apt_state_mgr is not None:
+            command.extend([
+                "--apt-config", self.apt_state_mgr.apt_conf_for_arch(cpuarch),
+                ])
+        else:
+            command.extend([
+                "--mirror", find_mirror(self.config.project, arch),
+                "--components", ",".join(self.components),
+                "--dist", ",".join(self.germinate_dists),
+                ])
         if self.use_vcs:
             command.append("--vcs=git")
         proxy_check_call(
diff --git a/lib/cdimage/mirror.py b/lib/cdimage/mirror.py
index c02bda6..3d0d2b5 100644
--- a/lib/cdimage/mirror.py
+++ b/lib/cdimage/mirror.py
@@ -22,6 +22,7 @@ import os
 import subprocess
 
 from cdimage.log import logger
+from cdimage import osextras
 
 __metaclass__ = type
 
@@ -124,3 +125,129 @@ def trigger_mirrors(config):
 
     for host in _get_mirrors_async(config):
         _trigger_mirror(config, key, "archvsync", host, background=True)
+
+
+APT_CONF_TMPL = """\
+Apt {{
+   Architecture "{ARCH}";
+   Architectures "{OTHERARCH}";
+}};
+
+Dir "{DIR}";
+Dir::state::status "/dev/null";
+"""
+
+SOURCES_TMPL = """\
+Types: deb deb-src
+URIs: {MIRROR}
+Suites: {SUITES}
+Components: {COMPONENTS}
+Signed-By: {KEYRING}
+"""
+
+
+class AptStateManager:
+    def __init__(self, config):
+        self.config = config
+        self._apt_conf_per_arch = {}
+
+    def _output_dir(self, arch):
+        return os.path.join(
+            self.config.root, "scratch", self.config.subtree,
+            self.config.project, self.config.full_series,
+            self.config.image_type, "apt-state", arch)
+
+    def _otherarch(self, arch):
+        # XXX should probably move this knowledge into ubuntu-cdimage
+        # once debian-cd no longer cares.
+        debian_cd_dir = os.path.join(self.config.root, "debian-cd")
+        archlist_file = os.path.join(
+            debian_cd_dir, "data", self.config.series, "multiarch", arch)
+        if os.path.exists(archlist_file):
+            with open(archlist_file) as f:
+                return f.read().strip()
+        return arch
+
+    def _components(self):
+        components = ["main"]
+        if not self.config["CDIMAGE_ONLYFREE"]:
+            components.append("restricted")
+        if self.config["CDIMAGE_UNSUPPORTED"]:
+            components.append("universe")
+            if not self.config["CDIMAGE_ONLYFREE"]:
+                components.append("multiverse")
+        return " ".join(components)
+
+    def _suites(self):
+        suite_patterns = ["%s", "%s-security", "%s-updates"]
+        if self.config.get("PROPOSED", "0") not in ("", "0"):
+            suite_patterns.append("%s-proposed")
+        return " ".join(
+            [pattern % self.config.series for pattern in suite_patterns])
+
+    def _get_sources_text(self, arch):
+        if self.config["CDIMAGE_POOL_SOURCES"]:
+            with open(self.config["CDIMAGE_POOL_SOURCES"]) as fp:
+                return fp.read()
+
+        keyring = "/etc/apt/trusted.gpg.d/ubuntu-keyring-2018-archive.gpg"
+
+        return SOURCES_TMPL.format(
+            MIRROR=find_mirror(self.config, arch),
+            SUITES=self._suites(),
+            COMPONENTS=self._components(),
+            KEYRING=keyring)
+
+    def _setup_arch(self, arch):
+        state_dir = self._output_dir(arch)
+        osextras.mkemptydir(state_dir)
+
+        conf_path = os.path.join(state_dir, 'base.conf')
+        with open(conf_path, 'w') as conf:
+            conf.write(APT_CONF_TMPL.format(
+                ARCH=arch,
+                OTHERARCH=self._otherarch(arch),
+                DIR=state_dir))
+
+        needed_dirs = [
+            'etc/apt/sources.list.d',
+            'etc/apt/apt.conf.d',
+            'etc/apt/preferences.d',
+            'var/lib/apt/lists/partial',
+            ]
+
+        for path in needed_dirs:
+            osextras.mkemptydir(os.path.join(state_dir, path))
+
+        sources_path = os.path.join(
+            state_dir, 'etc/apt/sources.list.d/default.sources')
+
+        with open(sources_path, 'w') as sources:
+            sources.write(self._get_sources_text(arch))
+
+        if self.config["APT_PROXY"]:
+            proxy_conf_path = os.path.join(
+                state_dir, "etc/apt/apt.conf.d/proxy.conf")
+            with open(proxy_conf_path, "w") as proxy_conf:
+                proxy_conf.write(
+                    'Acquire::http::Proxy "{PROXY}";\n'.format(
+                        PROXY=self.config["APT_PROXY"]))
+                proxy_conf.write(
+                    'Acquire::https::Proxy "{PROXY}";\n'.format(
+                        PROXY=self.config["APT_PROXY"]))
+
+        subprocess.check_call(
+            ['apt-get', 'update'],
+            env=dict(os.environ, APT_CONFIG=conf_path))
+
+        return conf_path
+
+    def setup(self):
+        for arch in self.config.cpuarches:
+            logger.info(
+                "Setting up apt state for %s/%s ...",
+                self.config.series, arch)
+            self._apt_conf_per_arch[arch] = self._setup_arch(arch)
+
+    def apt_conf_for_arch(self, arch):
+        return self._apt_conf_per_arch[arch]
diff --git a/lib/cdimage/tests/helpers.py b/lib/cdimage/tests/helpers.py
index 5e107ce..d1d9db5 100644
--- a/lib/cdimage/tests/helpers.py
+++ b/lib/cdimage/tests/helpers.py
@@ -145,3 +145,8 @@ def touch(path):
 def date_to_time(date):
     """Return UTC seconds-since-epoch for a string in the form "20130321"."""
     return calendar.timegm(time.strptime(date, "%Y%m%d"))
+
+
+class StubAptStateManager:
+    def apt_conf_for_arch(self, arch):
+        return arch + "/apt.conf"
diff --git a/lib/cdimage/tests/test_build.py b/lib/cdimage/tests/test_build.py
index c893613..d38a91c 100644
--- a/lib/cdimage/tests/test_build.py
+++ b/lib/cdimage/tests/test_build.py
@@ -59,7 +59,7 @@ from cdimage.build import (
 from cdimage.config import Config
 from cdimage.log import logger
 from cdimage.mail import text_file_type
-from cdimage.tests.helpers import TestCase, mkfile, touch
+from cdimage.tests.helpers import TestCase, mkfile, touch, StubAptStateManager
 
 __metaclass__ = type
 
@@ -687,8 +687,10 @@ class TestBuildImageSet(TestCase):
     @mock.patch("subprocess.call", return_value=0)
     def test_run_debian_cd(self, mock_call):
         self.config["CAPPROJECT"] = "Ubuntu"
+        self.config["ARCHES"] = "amd64 arm64"
+        self.config.set_default_cpuarches()
         self.capture_logging()
-        run_debian_cd(self.config)
+        run_debian_cd(self.config, StubAptStateManager())
         self.assertLogEqual([
             "===== Building Ubuntu daily CDs =====",
             self.epoch_date,
@@ -696,6 +698,9 @@ class TestBuildImageSet(TestCase):
         expected_cwd = os.path.join(self.temp_dir, "debian-cd")
         mock_call.assert_called_once_with(
             ["./build_all.sh"], cwd=expected_cwd, env=mock.ANY)
+        env = mock_call.call_args.kwargs["env"]
+        self.assertEqual("amd64/apt.conf", env["APT_CONFIG_amd64"])
+        self.assertEqual("arm64/apt.conf", env["APT_CONFIG_arm64"])
 
     @mock.patch("subprocess.call", return_value=0)
     def test_run_debian_cd_reexports_config(self, mock_call):
@@ -712,7 +717,7 @@ class TestBuildImageSet(TestCase):
         os.environ["CDIMAGE_ROOT"] = self.temp_dir
         config = Config()
         self.capture_logging()
-        run_debian_cd(config)
+        run_debian_cd(config, StubAptStateManager())
         self.assertLogEqual([
             "===== Building Ubuntu daily CDs =====",
             self.epoch_date,
@@ -914,18 +919,20 @@ class TestBuildImageSet(TestCase):
                     return mock.call([
                         germinate_path,
                         "--seed-source", mock.ANY,
-                        "--mirror", "http://ftpmaster.internal/ubuntu/",
                         "--seed-dist", "ubuntu.bionic",
-                        "--dist", "bionic,bionic-security,bionic-updates",
                         "--arch", arch,
-                        "--components", "main,restricted",
                         "--no-rdepends",
+                        "--mirror", "http://ftpmaster.internal/ubuntu/",
+                        "--components", "main,restricted",
+                        "--dist", "bionic,bionic-security,bionic-updates",
                         "--vcs=git",
                     ], cwd=os.path.join(germinate_output, arch), env=mock.ANY)
 
                 mock_call.assert_has_calls([
                     mock.call([
                         "make", "-C", os.path.dirname(britney_makefile)]),
+                    mock.call(["apt-get", "update"], env=mock.ANY),
+                    mock.call(["apt-get", "update"], env=mock.ANY),
                     germinate_command("amd64"),
                     germinate_command("i386"),
                     mock.call(
@@ -964,6 +971,8 @@ class TestBuildImageSet(TestCase):
                     DATE
                     ===== Building britney =====
                     DATE
+                    Setting up apt state for bionic/amd64 ...
+                    Setting up apt state for bionic/i386 ...
                     ===== Germinating =====
                     DATE
                     Germinating for bionic/amd64 ...
diff --git a/lib/cdimage/tests/test_germinate.py b/lib/cdimage/tests/test_germinate.py
index dd409e1..f567eae 100644
--- a/lib/cdimage/tests/test_germinate.py
+++ b/lib/cdimage/tests/test_germinate.py
@@ -37,7 +37,7 @@ from cdimage.germinate import (
     NoMasterSeeds,
 )
 from cdimage.mail import text_file_type
-from cdimage.tests.helpers import TestCase, mkfile, touch
+from cdimage.tests.helpers import TestCase, mkfile, touch, StubAptStateManager
 
 __metaclass__ = type
 
@@ -190,12 +190,47 @@ class TestGermination(TestCase):
             germinate_path,
             "--seed-source",
             "https://git.launchpad.net/~ubuntu-core-dev/ubuntu-seeds/+git/",
-            "--mirror", "http://ftpmaster.internal/ubuntu/",
             "--seed-dist", "ubuntu.bionic",
-            "--dist", "bionic,bionic-security,bionic-updates",
             "--arch", "amd64",
+            "--no-rdepends",
+            "--mirror", "http://ftpmaster.internal/ubuntu/",
             "--components", "main,restricted",
+            "--dist", "bionic,bionic-security,bionic-updates",
+            "--vcs=git",
+        ]
+        self.assertEqual(1, mock_check_call.call_count)
+        self.assertEqual(expected_command, mock_check_call.call_args[0][0])
+        self.assertEqual(
+            "%s/amd64" % output_dir, mock_check_call.call_args[1]["cwd"])
+
+    @mock.patch("subprocess.check_call")
+    def test_germinate_arch_with_apt_state_manager(self, mock_check_call):
+        self.config.root = self.use_temp_dir()
+        germinate_path = os.path.join(
+            self.temp_dir, "germinate", "bin", "germinate")
+        touch(germinate_path)
+        os.chmod(germinate_path, 0o755)
+        self.config["DIST"] = "bionic"
+        self.config["IMAGE_TYPE"] = "daily"
+        self.config["PROJECT"] = "ubuntu"
+
+        output_dir = "%s/scratch/ubuntu/bionic/daily/germinate" % self.temp_dir
+
+        def check_call_side_effect(*args, **kwargs):
+            touch(os.path.join(output_dir, "amd64", "structure"))
+
+        mock_check_call.side_effect = check_call_side_effect
+
+        self.germination.apt_state_mgr = StubAptStateManager()
+        self.germination.germinate_arch("amd64")
+        expected_command = [
+            germinate_path,
+            "--seed-source",
+            "https://git.launchpad.net/~ubuntu-core-dev/ubuntu-seeds/+git/",
+            "--seed-dist", "ubuntu.bionic",
+            "--arch", "amd64",
             "--no-rdepends",
+            "--apt-config", "amd64/apt.conf",
             "--vcs=git",
         ]
         self.assertEqual(1, mock_check_call.call_count)
diff --git a/lib/cdimage/tests/test_mirror.py b/lib/cdimage/tests/test_mirror.py
index b3b913d..56b00fe 100644
--- a/lib/cdimage/tests/test_mirror.py
+++ b/lib/cdimage/tests/test_mirror.py
@@ -19,7 +19,10 @@
 
 from __future__ import print_function, with_statement
 
+import glob
 import os
+import subprocess
+import sys
 
 try:
     from unittest import mock
@@ -28,6 +31,7 @@ except ImportError:
 
 from cdimage.config import Config, all_series
 from cdimage.mirror import (
+    AptStateManager,
     UnknownManifestFile,
     _get_mirror_key,
     _get_mirrors,
@@ -220,3 +224,157 @@ class TestTriggerMirrors(TestCase):
                   "w"):
             trigger_mirrors(self.config)
             mock_trigger_mirror.assert_not_called()
+
+
+class TestAptStateManager(TestCase):
+    def test_output_dir(self):
+        config = Config(read=False)
+        config.root = "/cdimage"
+        config["PROJECT"] = "ubuntu"
+        config["DIST"] = "noble"
+        config["IMAGE_TYPE"] = "daily"
+        mgr = AptStateManager(config)
+        self.assertEqual(
+            "/cdimage/scratch/ubuntu/noble/daily/apt-state/amd64",
+            mgr._output_dir("amd64"))
+
+    def test_otherarch_no_foreign_arch(self):
+        config = Config(read=False)
+        config.root = self.use_temp_dir()
+        mgr = AptStateManager(config)
+        self.assertEqual("arm64", mgr._otherarch("arm64"))
+
+    def test_otherarch_with_foreign_arch(self):
+        config = Config(read=False)
+        config.root = self.use_temp_dir()
+        config["DIST"] = "noble"
+        # This is duplicating the implementation a bit too much to be
+        # a truly useful tests. But really this information should be
+        # moved into ubuntu-cdimage somewhere.
+        archlist_path = os.path.join(
+            config.root, "debian-cd", "data", config.series,
+            "multiarch", "arm64")
+        os.makedirs(os.path.dirname(archlist_path))
+        with open(archlist_path, 'w') as fp:
+            fp.write("armhf\n")
+        mgr = AptStateManager(config)
+        self.assertEqual("armhf", mgr._otherarch("arm64"))
+
+    def test_components(self):
+        config = Config(read=False)
+        mgr = AptStateManager(config)
+        self.assertEqual("main restricted", mgr._components())
+        config["CDIMAGE_ONLYFREE"] = "1"
+        self.assertEqual("main", mgr._components())
+        config["CDIMAGE_UNSUPPORTED"] = "1"
+        self.assertEqual("main universe", mgr._components())
+        del config["CDIMAGE_ONLYFREE"]
+        self.assertEqual(
+            "main restricted universe multiverse", mgr._components())
+
+    def test_suites(self):
+        config = Config(read=False)
+        config["DIST"] = "noble"
+        mgr = AptStateManager(config)
+        self.assertEqual("noble noble-security noble-updates", mgr._suites())
+        config["PROPOSED"] = "1"
+        self.assertEqual(
+            "noble noble-security noble-updates noble-proposed", mgr._suites())
+
+    @mock.patch("cdimage.mirror.find_mirror")
+    @mock.patch("cdimage.mirror.AptStateManager._components")
+    @mock.patch("cdimage.mirror.AptStateManager._suites")
+    def test_get_sources_text(self, m_suites, m_components, m_find_mirror):
+        m_find_mirror.return_value = "MIRROR"
+        m_components.return_value = "COMPONENTS"
+        m_suites.return_value = "SUITES"
+        config = Config(read=False)
+        config["DIST"] = "noble"
+        mgr = AptStateManager(config)
+        expected = """\
+Types: deb deb-src
+URIs: MIRROR
+Suites: SUITES
+Components: COMPONENTS
+Signed-By: /etc/apt/trusted.gpg.d/ubuntu-keyring-2018-archive.gpg
+"""
+        self.assertEqual(expected, mgr._get_sources_text("s390x"))
+
+    def test_get_sources_text_override(self):
+        config = Config(read=False)
+        sources_path = os.path.join(self.use_temp_dir(), "my.sources")
+        content = "# content\n"
+        with open(sources_path, 'w') as fp:
+            fp.write(content)
+        config["CDIMAGE_POOL_SOURCES"] = sources_path
+        mgr = AptStateManager(config)
+        self.assertEqual(content, mgr._get_sources_text("s390x"))
+
+    def _get_apt_config(self, apt_config, var, meth='find'):
+        env = dict(os.environ, APT_CONFIG=apt_config)
+        cmd = [
+            sys.executable,
+            "-c",
+            "import apt_pkg, sys; apt_pkg.init_config()\n"
+            "print(apt_pkg.config.{}(sys.argv[1]))".format(meth),
+            var
+            ]
+        cp = subprocess.run(
+            cmd, env=env, encoding='utf-8', stdout=subprocess.PIPE, check=True)
+        return cp.stdout.strip()
+
+    @mock.patch("cdimage.mirror.AptStateManager._output_dir")
+    @mock.patch("cdimage.mirror.AptStateManager._get_sources_text")
+    @mock.patch("cdimage.mirror.AptStateManager._otherarch")
+    def test_setup_arch(self, m_otherarch, m_get_sources_text, m_output_dir):
+        m_otherarch.return_value = "OTHERARCH"
+        # We *could* create a local apt repo with apt-ftparchive and
+        # arrange to point the apt update call _setup_arch does to it
+        # but that seems like a lot of effort.
+        m_get_sources_text.return_value = "# Our content\n"
+        m_output_dir.return_value = self.use_temp_dir()
+        config = Config(read=False)
+        config["DIST"] = "noble"
+        mgr = AptStateManager(config)
+        apt_conf = mgr._setup_arch("ARCH")
+        self.assertEqual(
+            "ARCH",
+            self._get_apt_config(apt_conf, "Apt::Architecture"))
+        self.assertEqual(
+            "OTHERARCH",
+            self._get_apt_config(apt_conf, "Apt::Architectures"))
+        sources_list_d = self._get_apt_config(
+            apt_conf, "Dir::Etc::sourceparts", meth='find_dir')
+        sources_files = glob.glob(os.path.join(sources_list_d, "*.sources"))
+        self.assertEqual(1, len(sources_files))
+        with open(sources_files[0]) as fp:
+            self.assertEqual("# Our content\n", fp.read())
+
+    @mock.patch("subprocess.check_call")
+    def test_setup_arch_proxy(self, m_check_call):
+        config = Config(read=False)
+        config["DIST"] = "noble"
+        config["APT_PROXY"] = "http://localhost:3128"
+        mgr = AptStateManager(config)
+        apt_conf = mgr._setup_arch("ARCH")
+        self.assertEqual(
+            "http://localhost:3128",
+            self._get_apt_config(apt_conf, "Acquire::http::Proxy"))
+        self.assertEqual(
+            "http://localhost:3128",
+            self._get_apt_config(apt_conf, "Acquire::https::Proxy"))
+
+    @mock.patch("cdimage.mirror.AptStateManager._setup_arch")
+    def test_setup(self, m_setup_arch):
+        self.capture_logging()
+        m_setup_arch.side_effect = lambda arch: arch + 'dir'
+        config = Config(read=False)
+        config["ARCHES"] = (
+            "arch1 arch1+subarch arch2+subarch1 arch2+subarch2 arch3")
+        config.set_default_cpuarches()
+        mgr = AptStateManager(config)
+        mgr.setup()
+        self.assertCountEqual(
+            [mock.call("arch1"), mock.call("arch2"), mock.call("arch3")],
+            m_setup_arch.mock_calls)
+        self.assertEqual('arch1dir', mgr.apt_conf_for_arch('arch1'))