fix: allow parallel installations of signed snapcraft snaps (7.5)

snapcraft_legacy/internal/build_providers/_snap.py

@@ -58,9 +58,10 @@ def __init__(
         latest_revision: Optional[str],
         inject_from_host: bool = True
     ) -> None:
-        self.snap_name = snap_name
-        # the local snap name may have a suffix if it was installed with `--name`
-        self.snap_store_name = snap_name.split("_")[0]
+        # name of the snap instance, which may have an alias
+        self.snap_instance_name = snap_name
+        # name of the snap (no alias)
+        self.snap_name = snap_name.split("_")[0]
         self._remote_snap_dir = remote_snap_dir
         self._inject_from_host = inject_from_host
 
@@ -74,7 +75,7 @@ def __init__(
 
     def _get_snap_repo(self):
         if self.__repo is None:
-            self.__repo = repo.snaps.SnapPackage(self.snap_name)
+            self.__repo = repo.snaps.SnapPackage(self.snap_instance_name)
         return self.__repo
 
     def get_op(self) -> _SnapOp:
@@ -125,7 +126,7 @@ def get_op(self) -> _SnapOp:
             # This is a programmatic error
             raise RuntimeError(
                 "Unhandled scenario for {!r} (host installed: {}, latest_revision {})".format(
-                    self.snap_name, is_installed, self._latest_revision
+                    self.snap_instance_name, is_installed, self._latest_revision
                 )
             )
 
@@ -136,9 +137,9 @@ def push_host_snap(self, *, file_pusher: Callable[..., None]) -> None:
         # TODO not being able to lock down on a snap revision can lead to races.
         host_snap_repo = self._get_snap_repo()
         with tempfile.TemporaryDirectory() as temp_dir:
-            snap_file_path = os.path.join(temp_dir, "{}.snap".format(self.snap_name))
+            snap_file_path = os.path.join(temp_dir, "{}.snap".format(self.snap_instance_name))
             assertion_file_path = os.path.join(
-                temp_dir, "{}.assert".format(self.snap_name)
+                temp_dir, "{}.assert".format(self.snap_instance_name)
             )
             host_snap_repo.local_download(
                 snap_path=snap_file_path, assertion_path=assertion_file_path
@@ -169,11 +170,7 @@ def _set_data(self) -> None:
 
             if not snap_revision.startswith("x") and snap_channel:
                 switch_cmd = [
-                    "snap",
-                    "switch",
-                    self.snap_name,
-                    "--channel",
-                    snap_channel,
+                    "snap", "switch", self.snap_name, "--channel", snap_channel
                 ]
 
             if snap_revision.startswith("x"):
@@ -198,17 +195,17 @@ def _set_data(self) -> None:
 
         elif op == _SnapOp.INSTALL or op == _SnapOp.REFRESH:
             install_cmd = ["snap", op.name.lower()]
-            snap_channel = _get_snap_channel(self.snap_store_name)
+            snap_channel = _get_snap_channel(self.snap_name)
 
-            store_snap_info = storeapi.SnapAPI().get_info(self.snap_store_name)
+            store_snap_info = storeapi.SnapAPI().get_info(self.snap_name)
             snap_channel_map = store_snap_info.get_channel_mapping(
                 risk=snap_channel.risk, track=snap_channel.track
             )
             snap_revision = snap_channel_map.revision
             if snap_channel_map.confinement == "classic":
                 install_cmd.append("--classic")
             install_cmd.extend(["--channel", snap_channel_map.channel_details.name])
-            install_cmd.append(self.snap_store_name)
+            install_cmd.append(self.snap_name)
 
         self.__install_cmd = install_cmd
         self.__switch_cmd = switch_cmd
@@ -224,7 +221,7 @@ def get_revision(self) -> str:
             # Shouldn't happen.
             raise RuntimeError(
                 "Unhandled scenario for {!r} (revision {})".format(
-                    self.snap_name, self.__revision
+                    self.snap_instance_name, self.__revision
                 )
             )
 
@@ -238,7 +235,7 @@ def get_snap_install_cmd(self) -> List[str]:
         if self.__install_cmd is None:
             raise RuntimeError(
                 "Unhandled scenario for {!r} (install_cmd {})".format(
-                    self.snap_name, self.__install_cmd
+                    self.snap_instance_name, self.__install_cmd
                 )
             )
 
@@ -259,7 +256,7 @@ def get_assertion_ack_cmd(self) -> List[str]:
         if self.__assertion_ack_cmd is None:
             raise RuntimeError(
                 "Unhandled scenario for {!r} (assertion_ack_cmd {})".format(
-                    self.snap_name, self.__assertion_ack_cmd
+                    self.snap_instance_name, self.__assertion_ack_cmd
                 )
             )
 
@@ -379,7 +376,7 @@ def apply(self) -> None:
             return
 
         # Allow using snapd from the snapd snap to leverage newer snapd features.
-        if any(s.snap_name == "snapd" for s in self._snaps):
+        if any(s.snap_instance_name == "snapd" for s in self._snaps):
             self._enable_snapd_snap()
 
         # Disable refreshes so they do not interfere with installation ops.
@@ -396,6 +393,6 @@ def apply(self) -> None:
             self._runner(snap.get_snap_install_cmd())
             if snap.get_channel_switch_cmd() is not None:
                 self._runner(snap.get_channel_switch_cmd())
-            self._record_revision(snap.snap_store_name, snap.get_revision())
+            self._record_revision(snap.snap_name, snap.get_revision())
 
         _save_registry(self._registry_data, self._registry_filepath)

snapcraft_legacy/internal/repo/snaps.py

@@ -179,7 +179,13 @@ def local_download(self, *, snap_path: str, assertion_path: str) -> None:
         # We write an empty assertions file for dangerous installs to
         # have a consistent interface.
         if self.has_assertions():
-            assertions.append(["snap-declaration", "snap-name={}".format(self.name)])
+            assertions.append(
+                [
+                    "snap-declaration",
+                    # use the snap name without any alias
+                    f"snap-name={self.name.partition('_')[0]}"
+                ]
+            )
             assertions.append(
                 [
                     "snap-revision",

tests/legacy/unit/build_providers/test_snap.py

@@ -162,6 +162,124 @@ def test_snapcraft_installed_on_host_from_store(self):
             ),
         )
 
+    def test_snapcraft_installed_on_host_aliased_from_store(self):
+        self.fake_snapd.snaps_result = [
+            {
+                "name": "snapd",
+                "confinement": "strict",
+                "id": "2kkitQ",
+                "channel": "edge",
+                "revision": "1",
+                "tracking-channel": "latest/edge",
+            },
+            {
+                "name": "core18",
+                "confinement": "strict",
+                "id": "2kkibb",
+                "channel": "stable",
+                "revision": "123",
+                "tracking-channel": "latest/beta",
+            },
+            {
+                "name": "snapcraft_alias",
+                "confinement": "classic",
+                "id": "3lljuR",
+                "channel": "edge",
+                "revision": "345",
+                "tracking-channel": "latest/candidate",
+            },
+        ]
+        self.get_assertion_mock.side_effect = [
+            b"fake-assertion-account-store",
+            b"fake-assertion-declaration-snapd",
+            b"fake-assertion-revision-snapd-1",
+            b"fake-assertion-account-store",
+            b"fake-assertion-declaration-core18",
+            b"fake-assertion-revision-core18-123",
+            b"fake-assertion-account-store",
+            b"fake-assertion-declaration-snapcraft",
+            b"fake-assertion-revision-snapcraft-345",
+        ]
+
+        snap_injector = SnapInjector(
+            registry_filepath=self.registry_filepath,
+            runner=self.provider._run,
+            file_pusher=self.provider._push_file,
+        )
+        snap_injector.add("snapd")
+        snap_injector.add("core18")
+        snap_injector.add("snapcraft_alias")
+        snap_injector.apply()
+
+        get_assertion_calls = [
+            call(
+                [
+                    "account-key",
+                    "public-key-sha3-384=BWDEoaqyr25nF5SNCvEv2v7QnM9QsfCc0PBMYD_i2NGSQ32EF2d4D0hqUel3m8ul",
+                ]
+            ),
+            call(["snap-declaration", "snap-name=snapd"]),
+            call(["snap-revision", "snap-revision=1", "snap-id=2kkitQ"]),
+            call(
+                [
+                    "account-key",
+                    "public-key-sha3-384=BWDEoaqyr25nF5SNCvEv2v7QnM9QsfCc0PBMYD_i2NGSQ32EF2d4D0hqUel3m8ul",
+                ]
+            ),
+            call(["snap-declaration", "snap-name=core18"]),
+            call(["snap-revision", "snap-revision=123", "snap-id=2kkibb"]),
+            call(
+                [
+                    "account-key",
+                    "public-key-sha3-384=BWDEoaqyr25nF5SNCvEv2v7QnM9QsfCc0PBMYD_i2NGSQ32EF2d4D0hqUel3m8ul",
+                ]
+            ),
+            call(["snap-declaration", "snap-name=snapcraft"]),
+            call(["snap-revision", "snap-revision=345", "snap-id=3lljuR"]),
+        ]
+        self.get_assertion_mock.assert_has_calls(get_assertion_calls)
+        self.provider.run_mock.assert_has_calls(
+            [
+                call(["snap", "set", "system", "experimental.snapd-snap=true"]),
+                call(["snap", "set", "system", ANY]),
+                call(["snap", "watch", "--last=auto-refresh?"]),
+                call(["snap", "ack", "/var/tmp/snapd.assert"]),
+                call(["snap", "install", "/var/tmp/snapd.snap"]),
+                call(["snap", "switch", "snapd", "--channel", "latest/edge"]),
+                call(["snap", "ack", "/var/tmp/core18.assert"]),
+                call(["snap", "install", "/var/tmp/core18.snap"]),
+                call(["snap", "switch", "core18", "--channel", "latest/beta"]),
+                call(["snap", "ack", "/var/tmp/snapcraft_alias.assert"]),
+                call(["snap", "install", "--classic", "/var/tmp/snapcraft_alias.snap"]),
+                call(["snap", "switch", "snapcraft", "--channel", "latest/candidate"]),
+            ]
+        )
+        self.provider.push_file_mock.assert_has_calls(
+            [
+                call(source=ANY, destination="/var/tmp/snapd.snap"),
+                call(source=ANY, destination="/var/tmp/snapd.assert"),
+                call(source=ANY, destination="/var/tmp/core18.snap"),
+                call(source=ANY, destination="/var/tmp/core18.assert"),
+                call(source=ANY, destination="/var/tmp/snapcraft_alias.snap"),
+                call(source=ANY, destination="/var/tmp/snapcraft_alias.assert"),
+            ]
+        )
+        self.assertThat(
+            self.registry_filepath,
+            FileContains(
+                dedent(
+                    """\
+                    core18:
+                    - revision: '123'
+                    snapcraft:
+                    - revision: '345'
+                    snapd:
+                    - revision: '1'
+                    """
+                )
+            ),
+        )
+
     def test_snapcraft_installed_on_host_from_store_but_injection_disabled(self):
         self.useFixture(fixture_setup.FakeStore())
 

tests/legacy/unit/repo/test_snaps.py

@@ -348,6 +348,48 @@ def test_download_from_host(self):
             ]
         )
 
+    def test_download_from_host_alias(self):
+        """Download an aliased snap from the host."""
+        fake_get_assertion = fixtures.MockPatch(
+            "snapcraft_legacy.internal.repo.snaps.get_assertion",
+            return_value=b"foo-assert",
+        )
+        self.useFixture(fake_get_assertion)
+
+        self.fake_snapd.snaps_result = [
+            {
+                "id": "fake-snap-id",
+                "name": "fake-snap_alias",
+                "channel": "stable",
+                "revision": "10",
+            }
+        ]
+
+        snap_pkg = snaps.SnapPackage("fake-snap_alias/strict/stable")
+        snap_pkg.local_download(
+            snap_path="fake-snap.snap", assertion_path="fake-snap.assert"
+        )
+
+        self.assertThat("fake-snap.snap", FileExists())
+        self.assertThat(
+            "fake-snap.assert", FileContains("foo-assert\nfoo-assert\nfoo-assert\n")
+        )
+        fake_get_assertion.mock.assert_has_calls(
+            [
+                mock.call(
+                    [
+                        "account-key",
+                        "public-key-sha3-384=BWDEoaqyr25nF5SNCvEv2v7QnM9QsfCc0PBMYD_i2NGSQ32EF2d4D0hqUel3m8ul",
+                    ]
+                ),
+                # uses the non-aliased name
+                mock.call(["snap-declaration", "snap-name=fake-snap"]),
+                mock.call(
+                    ["snap-revision", "snap-revision=10", "snap-id=fake-snap-id"]
+                ),
+            ]
+        )
+
     def test_download_from_host_dangerous(self):
         fake_get_assertion = fixtures.MockPatch(
             "snapcraft_legacy.internal.repo.snaps.get_assertion",