Merge ~bowenfan/snapstore-client:SN2487b into snapstore-client:main

[Bowen Fan]

diff --git a/store_admin/cli/charms.py b/store_admin/cli/charms.py
new file mode 100644
index 0000000..f832896
--- /dev/null
+++ b/store_admin/cli/charms.py
@@ -0,0 +1,125 @@
+import logging
+import pathlib
+
+import click
+
+from store_admin.logic import charms
+
+logger = logging.getLogger(__name__)
+
+
[e-mail](name="charms")
[e-mail](
+    "bundle_filepath",
+    required=True,
+    type=click.Path(
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        path_type=pathlib.Path,
+    ),
+)
[e-mail](
+    "--export-dir",
+    multiple=False,
+    help="Directory to export charms to",
+    type=click.Path(
+        exists=True,
+        file_okay=False,
+        dir_okay=True,
+        writable=True,
+        path_type=pathlib.Path,
+    ),
+)
[e-mail](
+    "--series",
+    multiple=False,
+    default=charms.DEFAULT_SERIES,
+    help="Series of the exported charms (jammy by default)",
+)
[e-mail](
+    "--arch",
+    "architecture",
+    multiple=False,
+    default=charms.DEFAULT_ARCHITECTURE,
+    help="Architecture of the exported charms (amd64 by default)",
+)
+def export_charms(bundle_filepath, export_dir, series, architecture):
+    """Download charms, resources, and metadata for importing to an offline store."""
+    export_tar_path = charms.export_charms(
+        bundle_yaml_filepath=bundle_filepath,
+        export_dir_path=export_dir,
+        series=series,
+        architecture=architecture,
+    )
+    logger.info(f"Successfully exported charms to: {export_tar_path}")
+
+
[e-mail](name="bundle")
[e-mail](
+    "bundle_name",
+    required=True,
+)
[e-mail](
+    "--export-dir",
+    multiple=False,
+    help="Directory to export the bundle to",
+    type=click.Path(
+        exists=True,
+        file_okay=False,
+        dir_okay=True,
+        writable=True,
+        path_type=pathlib.Path,
+    ),
+)
[e-mail](
+    "--channel",
+    multiple=False,
+    default="latest/stable",
+    help="Channel of the charm bundle to export (latest/stable by default)",
+)
[e-mail](
+    "--series",
+    multiple=False,
+    default=charms.DEFAULT_SERIES,
+    help="Series for the bundle's charms (jammy by default)",
+)
[e-mail](
+    "--arch",
+    "architecture",
+    multiple=False,
+    default=charms.DEFAULT_ARCHITECTURE,
+    help="Architecture for the bundle's charms (amd64 by default)",
+)
+def export_bundle(bundle_name, export_dir, channel, series, architecture):
+    """Download a charm bundle and its components for offline store import.
+
+    This command is for charm-bundle packages in the Store. It will automatically fetch
+    all component charms and their component resources.
+    """
+    export_bundle_name, export_tar_path = charms.export_charm_bundle(
+        bundle_name=bundle_name,
+        export_dir_path=export_dir,
+        channel=channel,
+        charm_series=series,
+        charm_architecture=architecture,
+    )
+    logger.info(
+        f"Successfully exported charm bundle {export_bundle_name}: {export_tar_path}"
+    )
+
+
[e-mail](name="get-bundle-yaml")  # TODO decide on a better command name
[e-mail](
+    "bundle_name",
+    required=True,
+)
[e-mail](
+    "--channel",
+    multiple=False,
+    default="latest/stable",
+    help="Channel of the charm bundle to export (latest/stable by default)",
+)
+def get_bundle_yaml(bundle_name, channel):
+    """Fetch a charm bundle and print its bundle.yaml to stdout."""
+    charms.get_bundle_yaml(bundle_name, channel)
diff --git a/store_admin/cli/runner.py b/store_admin/cli/runner.py
index 14d88a4..e4090e8 100644
--- a/store_admin/cli/runner.py
+++ b/store_admin/cli/runner.py
@@ -3,7 +3,7 @@ import logging
 import click
 
 from store_admin import defaults, log, version
-from store_admin.cli import common, model_service, overrides, snaps, stores
+from store_admin.cli import common, model_service, overrides, snaps, stores, charms
 
 
 @click.group(
@@ -79,6 +79,7 @@ def export():
 run.add_command(common.login)
 run.add_command(common.register)
 run.add_command(model_service.register_key)
+run.add_command(charms.get_bundle_yaml)
 
 # Commands under create
 create.add_command(model_service.create_model)
@@ -109,3 +110,5 @@ remove.add_command(model_service.remove_serial_policy)
 export.add_command(stores.export_store)
 export.add_command(common.export_token)
 export.add_command(snaps.export_snap)
+export.add_command(charms.export_charms)
+export.add_command(charms.export_bundle)
diff --git a/store_admin/logic/charms.py b/store_admin/logic/charms.py
index 8137f5d..5f65edb 100644
--- a/store_admin/logic/charms.py
+++ b/store_admin/logic/charms.py
@@ -5,6 +5,7 @@ import pathlib
 import shutil
 import tarfile
 import tempfile
+import zipfile
 import yaml
 from store_admin.types import (
     CharmChannel,
@@ -32,6 +33,7 @@ from store_admin.logic.snaps import (
 
 DEFAULT_SERIES = "jammy"
 DEFAULT_ARCHITECTURE = "amd64"
+DEFAULT_CHARMS_EXPORT_FILENAME_PREFIX = "charms-export"
 
 CHARM_INFO_FIELDS = {"type", "id", "name", "result", "channel-map"}
 
@@ -41,7 +43,7 @@ REFRESH_REVISION_NOT_FOUND_CODE = "revision-not-found"
 logger = logging.getLogger(__name__)
 
 
-def parse_charm_bundle_yaml(bundle_yaml_filepath, architecture):
+def parse_charm_bundle_yaml(bundle_yaml_filepath, series, architecture):
     """Parse a bundle.yaml file into a list of CharmImport objects."""
     # Onus is on the user to conform to the yaml spec, i.e. no duplicate keys
     # pyyaml will clobber the previous entries where keys are duplicated
@@ -49,16 +51,30 @@ def parse_charm_bundle_yaml(bundle_yaml_filepath, architecture):
         bundle = yaml.safe_load(bundle_yaml)
 
     applications = bundle["applications"]
-    preferred_series = bundle.get("series", DEFAULT_SERIES)
-    charms = [
-        CharmImport(
-            package_name=config["charm"],
-            channel=config.get("channel"),
-            series=config.get("series", preferred_series),
-            architecture=architecture,
+
+    # The series resolving logic here is rudimentary, but should be aligned with Juju.
+    # It won't work in some cases, e.g. if the series and channel are not
+    # user-specified, where we would fetch from the default track with a default
+    # series of "jammy" (latest LTS). This can fail if the default track does not
+    # support Jammy. We leave it to the user to provide feasible parameters.
+    preferred_series = bundle.get("series", series)
+    # We remap "kubernetes" to "focal", as we do in packagereview
+    # See packagereview.types.CharmBase.from_series_str
+    if preferred_series == "kubernetes":
+        preferred_series = "focal"
+    charms = []
+    for config in applications.values():
+        charm_series = config.get("series", preferred_series)
+        if charm_series == "kubernetes":
+            charm_series = "focal"
+        charms.append(
+            CharmImport(
+                package_name=config["charm"],
+                channel=config.get("channel"),
+                series=charm_series,
+                architecture=architecture,
+            )
         )
-        for config in applications.values()
-    ]
     return charms
 
 
@@ -140,12 +156,12 @@ def make_charm_download_actions(charms_to_import, charms_info):
 def _get_charm_channel_from_name_and_revision(channel_map, channel_name, revision):
     """Helper function to search channel map entries for a given channel entry."""
     if "latest/" in channel_name:
-        channel_name = channel_name.split("/")[1]
+        channel_name_without_track = channel_name.split("/")[1]
     for channel_dict in channel_map:
         if (
             channel_dict["channel"]["name"] == channel_name
-            and channel_dict["revision"]["revision"] == revision
-        ):
+            or channel_dict["channel"]["name"] == channel_name_without_track
+        ) and channel_dict["revision"]["revision"] == revision:
             return channel_dict
     raise StoreRequestError("Inconsistent channel data")
 
@@ -222,10 +238,12 @@ def charm_revisions_from_info(charms_info, charms_download_info):
             binary_sha256=revision["download"]["hash-sha-256"],
         )
         package_id = charm_info["id"]
+        package_type = charm_info["type"]
         charm_revision = CharmRevision(
             channel=channel,
             package_name=charm_name,
             package_id=package_id,
+            package_type=package_type,
             revision=revision["revision"],
             created_at=revision["created-at"],
             architectures=revision["bases"],
@@ -248,10 +266,11 @@ def write_channel_map(charm_info_data, target_dir_path):
 
 
 def download_charm_files(charm_revision, target_dir_path, file_read_cb):
-    """Download charm binaries and its resource binaries from the online Charmhub.
+    """Download a bundle binary, or a charm and its resource binaries from Charmhub.
 
     :param CharmRevision charm_revision: A CharmRevision object that contains download
-        URLs for the charm and the resource(s) that it was released with.
+        URLs for the either the bundle, or the charm and the resource(s) that it was
+        released with.
     :param pathlib.Path target_dir_path: target directory path
     :param callable file_read_cb: Optional callback used for reading in charm and
         resource revision blobs.
@@ -267,7 +286,11 @@ def download_charm_files(charm_revision, target_dir_path, file_read_cb):
             shutil.copyfileobj(raw_response, blob_file)
     logger.debug(f"Downloaded blob to {charm_revision_blob_path}")
 
-    if charm_revision.channel.resource_revisions:
+    # Short circuit bundles here as their resources will always be None
+    if (
+        charm_revision.package_type == "charm"
+        and charm_revision.channel.resource_revisions
+    ):
         resource_dir = target_dir_path / "resources"
         resource_dir.mkdir(parents=True, exist_ok=True)
     for resource in charm_revision.channel.resource_revisions:
@@ -285,17 +308,132 @@ def download_charm_files(charm_revision, target_dir_path, file_read_cb):
         logger.debug(f"Downloaded blob to {resource_revision_blob_path}")
 
 
+def _fetch_store_info_for_packages(packages_to_import):
+    """Helper function for hitting /info and /refresh and parsing the results.
+
+    :param list[CharmImport] packages_to_import: list of charms to fetch
+    """
+    devicegw_root = defaults.get_devicegw_url()
+    packages_info = {
+        pkg.package_name: get_charm_info(devicegw_root, pkg)
+        for pkg in packages_to_import
+    }
+    packages_download_actions = make_charm_download_actions(
+        packages_to_import, packages_info
+    )
+    packages_download_info = {
+        res["name"]: res
+        for res in get_charms_download_info(devicegw_root, packages_download_actions)
+    }
+    packages_revisions = charm_revisions_from_info(
+        packages_info, packages_download_info
+    )
+
+    return (packages_info, packages_revisions)
+
+
 def export_charms(
-    bundle_yaml_filepath, export_dir_path, architecture=DEFAULT_ARCHITECTURE
+    bundle_yaml_filepath,
+    export_dir_path,
+    series=DEFAULT_SERIES,
+    architecture=DEFAULT_ARCHITECTURE,
 ):
     """Orchestrating function for exporting a set of charms given a bundle.yaml.
 
+    Output structure:
+
+    <export_dir_path>/
+    ├─ charms-export-<timestamp>.tar.gz/
+    │  ├─ bundle.yaml
+    |  ├─ <charm-name>.tar.gz/
+    │  │  ├─ <charm-name>_<charm-revision>.charm
+    │  │  ├─ channel-map.json
+    │  │  ├─ resources/
+    │  │  │  ├─ <charm-name>.<resource-name>_<resource-revision>
+
+
     :param pathlib.Path bundle_yaml_filepath: path to the bundle.yaml to be exported
     :param pathlib.Path export_dir_path: export directory path
-    :param str architecture: architecture of the charms to fetch, defaults to amd64
+    :param str series: series of the charms to fetch, default "jammy"
+    :param str architecture: architecture of the charms to fetch, default "amd64"
     """
-    devicegw_root = defaults.get_devicegw_url()
+    if not export_dir_path:
+        snap_user_common_dir = os.getenv("SNAP_USER_COMMON")
+        if snap_user_common_dir:
+            export_dir_path = pathlib.Path(snap_user_common_dir) / "export"
+            export_dir_path.mkdir(exist_ok=True)
+        else:
+            export_dir_path = pathlib.Path(os.getcwd())
 
+    timestamp = (
+        datetime.datetime.utcnow().replace(microsecond=0).strftime("%Y%m%dT%H%M%S")
+    )
+    charms_to_import = parse_charm_bundle_yaml(
+        bundle_yaml_filepath, series, architecture
+    )
+    charms_info, charms_revisions = _fetch_store_info_for_packages(charms_to_import)
+
+    with tempfile.TemporaryDirectory() as bundle_dir_path:
+        bundle_dir_path = pathlib.Path(bundle_dir_path)
+
+        for charm_name, charm_revision in charms_revisions.items():
+            with tempfile.TemporaryDirectory() as charm_dir_path:
+                charm_dir_path = pathlib.Path(charm_dir_path)
+
+                write_channel_map(charms_info[charm_name], charm_dir_path)
+                download_charm_files(
+                    charm_revision,
+                    charm_dir_path,
+                    progress_copy_to_file,
+                )
+                # Pack each charm, its metadata, and resources into a tarball
+                charm_tar_path = bundle_dir_path / f"{charm_name}.tar.gz"
+                with tarfile.open(charm_tar_path, "w:gz", encoding="utf-8") as tar:
+                    for f in charm_dir_path.iterdir():
+                        tar.add(str(f), f.name)
+        # Pack originally supplied bundle.yaml into the final tarball
+        shutil.copyfile(bundle_yaml_filepath, bundle_dir_path / "bundle.yaml")
+        bundle_tar_path = (
+            export_dir_path
+            / f"{DEFAULT_CHARMS_EXPORT_FILENAME_PREFIX}-{timestamp}.tar.gz"
+        )
+        # Pack charm tarballs into a root tarball
+        with tarfile.open(bundle_tar_path, "w:gz", encoding="utf-8") as tar:
+            for f in bundle_dir_path.iterdir():
+                tar.add(str(f), f.name)
+
+    return bundle_tar_path
+
+
+def export_charm_bundle(
+    bundle_name,
+    export_dir_path,
+    channel,
+    charm_series=DEFAULT_SERIES,
+    charm_architecture=DEFAULT_ARCHITECTURE,
+):
+    """Orchestrating function for exporting a charm bundle and its component charms.
+
+    Output structure:
+
+    <export_dir_path>/
+    ├─ <bundle-name>-<timestamp>.tar.gz/
+    │  ├─ bundle.yaml
+    │  ├─ <bundle-name>_<bundle-revision>.bundle
+    │  ├─ channel-map.json
+    │  ├─ charms/
+    │  │  ├─ <charm-name>.tar.gz/
+    │  │  │  ├─ <charm-name>_<charm-revision>.charm
+    │  │  │  ├─ channel-map.json
+    │  │  │  ├─ resources/
+    │  │  │  │  ├─ <charm-name>.<resource-name>_<resource-revision>
+
+    :param str bundle_name: Store package name for the bundle to be exported
+    :param pathlib.Path export_dir_path: export directory path
+    :param str channel: channel of the bundle itself to fetch, default "latest/stable"
+    :param str charm_series: series of the charms to fetch, default "jammy"
+    :param str charm_architecture: architecture of the charms to fetch, default "amd64"
+    """
     if not export_dir_path:
         snap_user_common_dir = os.getenv("SNAP_USER_COMMON")
         if snap_user_common_dir:
@@ -307,36 +445,85 @@ def export_charms(
     timestamp = (
         datetime.datetime.utcnow().replace(microsecond=0).strftime("%Y%m%dT%H%M%S")
     )
+    # Functions calling /info and /refresh are shared with charms, but unlike charms
+    # we would only export 1 bundle at a time.
+    bundle_to_import = CharmImport(
+        package_name=bundle_name, channel=channel, package_type="bundle"
+    )
+    bundle_info, bundle_revision = _fetch_store_info_for_packages([bundle_to_import])
+    # Unpack bundle_revision into the format expected by `download_charm_files`
+    bundle_revision = bundle_revision[bundle_name]
+
+    with tempfile.TemporaryDirectory() as bundle_dir_path:
+        bundle_dir_path = pathlib.Path(bundle_dir_path)
+
+        # TODO bowenfan To format outputs per import requirements,
+        # as opposed to just dumping the /info response
+        write_channel_map(bundle_info[bundle_name], bundle_dir_path)
+        download_charm_files(bundle_revision, bundle_dir_path, progress_copy_to_file)
+
+        # Automatically export all component charms in the bundle
+        # If a user needs to modify the bundle before exporting it, they can use
+        # the get-bundle-yaml command to output bundle.yaml only,
+        # without auto fetching charms
+        with zipfile.ZipFile(
+            bundle_dir_path
+            / f"{bundle_revision.package_name}_{bundle_revision.revision}.bundle"
+        ) as bundle_zip:
+            bundle_zip.extract(member="bundle.yaml", path=bundle_dir_path)
+
+        charms_dir_path = bundle_dir_path / "charms"
+        charms_dir_path.mkdir(parents=True, exist_ok=False)
+        charms_tar_path = export_charms(
+            bundle_dir_path / "bundle.yaml",
+            charms_dir_path,
+            charm_series,
+            charm_architecture,
+        )
 
-    charms_to_import = parse_charm_bundle_yaml(bundle_yaml_filepath, architecture)
-    charms_info = {
-        charm.package_name: get_charm_info(devicegw_root, charm)
-        for charm in charms_to_import
-    }
-    charms_download_actions = make_charm_download_actions(charms_to_import, charms_info)
-    charms_download_info = {
-        res["name"]: res
-        for res in get_charms_download_info(devicegw_root, charms_download_actions)
-    }
-    charms_revisions = charm_revisions_from_info(charms_info, charms_download_info)
-
-    tarball_paths = []
-    for charm_name, charm_revision in charms_revisions.items():
-        with tempfile.TemporaryDirectory() as charm_dir_path:
-            charm_dir_path = pathlib.Path(charm_dir_path)
-
-            write_channel_map(charms_info[charm_name], charm_dir_path)
-            download_charm_files(
-                charm_revision,
-                charm_dir_path,
-                progress_copy_to_file,
-            )
+        # Extract charms
+        with tarfile.open(charms_tar_path, "r:gz") as charms_tar:
+            charms_tar.extractall(charms_dir_path)
+        # Remove extra bundle.yaml from the export_charms function
+        os.remove(charms_dir_path / "bundle.yaml")
+        # Remove the extracted exported charms tarball
+        os.remove(charms_tar_path)
+
+        # Pack what we have into a root tar named after the bundle
+        # (see dir structure in docstring)
+        tarball_path = export_dir_path / f"{bundle_name}-{timestamp}.tar.gz"
+        with tarfile.open(tarball_path, "w:gz", encoding="utf-8") as tar:
+            for f in bundle_dir_path.iterdir():
+                tar.add(str(object=f), f.name)
+
+            return (bundle_name, tarball_path)
 
-            tarball_path = export_dir_path / f"{charm_name}-{timestamp}.tar.gz"
-            with tarfile.open(tarball_path, "w:gz", encoding="utf-8") as tar:
-                for f in charm_dir_path.iterdir():
-                    tar.add(str(f), f.name)
 
-        tarball_paths.append((charm_name, tarball_path))
+def get_bundle_yaml(bundle_name, channel):
+    """Get the bundle.yaml for a given bundle name and channel.
 
-    return tarball_paths
+    :param str bundle_name: Store package name for the bundle to be exported
+    :param str channel: channel of the bundle itself to fetch, default "latest/stable"
+    """
+    bundle_to_import = CharmImport(
+        package_name=bundle_name, channel=channel, package_type="bundle"
+    )
+    _, bundle_revision = _fetch_store_info_for_packages([bundle_to_import])
+    bundle_revision = bundle_revision[bundle_name]
+
+    with tempfile.TemporaryDirectory() as bundle_dir_path:
+        bundle_dir_path = pathlib.Path(bundle_dir_path)
+
+        download_charm_files(bundle_revision, bundle_dir_path, progress_copy_to_file)
+
+        with tempfile.TemporaryDirectory(dir=bundle_dir_path) as zip_dir_path:
+            zip_dir_path = pathlib.Path(zip_dir_path)
+            with zipfile.ZipFile(
+                bundle_dir_path
+                / f"{bundle_revision.package_name}_{bundle_revision.revision}.bundle"
+            ) as bundle_zip:
+                bundle_zip.extractall(path=zip_dir_path)
+            with open(zip_dir_path / "bundle.yaml") as bundle_yaml_file:
+                logger.info("\n-----BEGIN BUNDLE.YAML-----")
+                logger.info(bundle_yaml_file.read())
+                logger.info("-----END BUNDLE.YAML-----")
diff --git a/store_admin/logic/tests/test_charms.py b/store_admin/logic/tests/test_charms.py
index f94a0b1..1d1c349 100644
--- a/store_admin/logic/tests/test_charms.py
+++ b/store_admin/logic/tests/test_charms.py
@@ -1,13 +1,15 @@
 import binascii
 import datetime
+import os
 import pathlib
 import tarfile
 from textwrap import dedent
 from unittest import mock
+import zipfile
 
 import pytest
 import responses
-
+from io import BytesIO
 from store_admin import exceptions
 from store_admin.logic import charms
 from store_admin.types import (
@@ -21,6 +23,7 @@ from store_admin.types import (
 
 PATCH_PREFIX = "store_admin.logic.charms."
 TEST_CHARM_NAME = "charm1"
+TEST_BUNDLE_NAME = "bundle1"
 
 
 @pytest.fixture
@@ -104,10 +107,142 @@ def setup_mock_charm_info():
 
 
 @pytest.fixture
+def setup_mock_bundle_info():
+    def setup(devicegw_root="", requests_mock=None, bundle_name=TEST_BUNDLE_NAME):
+        info_data = {
+            "type": "bundle",
+            "id": f"{bundle_name}Id",
+            "name": bundle_name,
+            "channel-map": [
+                {
+                    "channel": {
+                        "base": None,
+                        "name": "stable",
+                        "released-at": "2024-01-03T14:53:38.952872+00:00",
+                        "risk": "stable",
+                        "track": "latest",
+                    },
+                    "revision": {
+                        "attributes": {},
+                        "bases": [None],
+                        "created-at": "2023-12-07T23:36:15.652705+00:00",
+                        "download": {
+                            "hash-sha-256": binascii.hexlify(b"5555").decode(),
+                            "size": 5555,
+                            "url": f"https://download/{bundle_name}_5.bundle",
+                        },
+                        "revision": 5,
+                        "version": "5",
+                    },
+                },
+            ],
+            "result": {
+                "categories": [],
+                "deployable-on": ["kubernetes"],
+                "description": "A charming charm bundle",
+                "license": "",
+                "links": None,
+                "media": [],
+                "publisher": {"display-name": "Publisher of charming charms"},
+                "store-url": f"https://charmhub.io/{bundle_name}",
+                "summary": "A charming charm bundle",
+                "title": "A charming charm bundle",
+                "unlisted": False,
+            },
+        }
+        if requests_mock:
+            requests_mock.add(
+                "GET",
+                devicegw_root + f"/v2/charms/info/{bundle_name}",
+                match=[
+                    responses.matchers.query_param_matcher(
+                        {"fields": ",".join(charms.CHARM_INFO_FIELDS)}
+                    ),
+                ],
+                json=info_data,
+            )
+        return bundle_name, info_data
+
+    return setup
+
+
+def _make_charm_refresh_results(charm_names):
+    return [
+        {
+            "charm": {
+                "created-at": "2023-12-07T23:36:15.652705+00:00",
+                "download": {
+                    "hash-sha-256": binascii.hexlify(b"5555").decode(),
+                    "size": 5555,
+                    "url": f"https://download/{charm_name}_5.charm",
+                },
+                "id": f"{charm_name}Id",
+                "name": charm_name,
+                "publisher": {
+                    "display-name": "Publisher of charming charms",
+                    "id": "charmpublisherId",
+                    "username": "charm-publisher",
+                    "validation": "unproven",
+                },
+                "resources": [
+                    {
+                        "created-at": "2023-11-28T23:19:59.819552",
+                        "description": "Charm OCI Resource",
+                        "download": {
+                            "hash-sha-256": binascii.hexlify(b"2222").decode(),
+                            "hash-sha-384": binascii.hexlify(b"222").decode(),
+                            "hash-sha-512": binascii.hexlify(b"22").decode(),
+                            "hash-sha3-384": binascii.hexlify(b"2").decode(),
+                            "size": 222,
+                            "url": f"https://download/{charm_name}-image_2",
+                        },
+                        "filename": "",
+                        "name": f"{charm_name}-image",
+                        "revision": 2,
+                        "type": "oci-image",
+                    }
+                ],
+                "revision": 5,
+                "summary": "A charming charm",
+                "type": "charm",
+                "version": "5",
+            },
+            "effective-channel": "stable",
+            "id": f"{charm_name}Id",
+            "instance-key": "random-instance-key",
+            "name": charm_name,
+            "released-at": "2024-01-03T14:53:38.952872+00:00",
+            "result": "download",
+        }
+        for charm_name in charm_names
+    ]
+
+
[e-mail]
 def setup_mock_charm_refresh():
     def setup(devicegw_root="", requests_mock=None, charm_names=None):
         charm_names = charm_names or [TEST_CHARM_NAME]
+        refresh_data = {
+            "error-list": [],
+            "results": _make_charm_refresh_results(charm_names),
+        }
+        if requests_mock:
+            requests_mock.add(
+                "POST", devicegw_root + "/v2/charms/refresh", json=refresh_data
+            )
+        return charm_names, refresh_data
+
+    return setup
+
 
[e-mail]
+def setup_mock_bundle_refresh():
+    def setup(
+        devicegw_root="",
+        requests_mock=None,
+        bundle_name=TEST_BUNDLE_NAME,
+        charm_names=None,
+    ):
         refresh_data = {
             "error-list": [],
             "results": [
@@ -117,54 +252,38 @@ def setup_mock_charm_refresh():
                         "download": {
                             "hash-sha-256": binascii.hexlify(b"5555").decode(),
                             "size": 5555,
-                            "url": f"https://download/{charm_name}_5.charm",
+                            "url": f"https://download/{bundle_name}_5.bundle",
                         },
-                        "id": f"{charm_name}Id",
-                        "name": charm_name,
+                        "id": f"{bundle_name}Id",
+                        "name": bundle_name,
                         "publisher": {
                             "display-name": "Publisher of charming charms",
                             "id": "charmpublisherId",
                             "username": "charm-publisher",
                             "validation": "unproven",
                         },
-                        "resources": [
-                            {
-                                "created-at": "2023-11-28T23:19:59.819552",
-                                "description": "Charm OCI Resource",
-                                "download": {
-                                    "hash-sha-256": binascii.hexlify(b"2222").decode(),
-                                    "hash-sha-384": binascii.hexlify(b"222").decode(),
-                                    "hash-sha-512": binascii.hexlify(b"22").decode(),
-                                    "hash-sha3-384": binascii.hexlify(b"2").decode(),
-                                    "size": 222,
-                                    "url": f"https://download/{charm_name}-image_2",
-                                },
-                                "filename": "",
-                                "name": f"{charm_name}-image",
-                                "revision": 2,
-                                "type": "oci-image",
-                            }
-                        ],
+                        "resources": [],
                         "revision": 5,
-                        "summary": "A charming charm",
-                        "type": "charm",
+                        "summary": "A charming charm bundle",
+                        "type": "bundle",
                         "version": "5",
                     },
                     "effective-channel": "stable",
-                    "id": f"{charm_name}Id",
+                    "id": f"{bundle_name}Id",
                     "instance-key": "random-instance-key",
-                    "name": charm_name,
+                    "name": bundle_name,
                     "released-at": "2024-01-03T14:53:38.952872+00:00",
                     "result": "download",
                 }
-                for charm_name in charm_names
             ],
         }
+        if charm_names:
+            refresh_data["results"].extend(_make_charm_refresh_results(charm_names))
         if requests_mock:
             requests_mock.add(
                 "POST", devicegw_root + "/v2/charms/refresh", json=refresh_data
             )
-        return charm_names, refresh_data
+        return [bundle_name], refresh_data
 
     return setup
 
@@ -199,6 +318,7 @@ def mock_charm_revision_dataclass():
         ),
         package_name=charm_name,
         package_id=f"{charm_name}Id",
+        package_type="charm",
         revision=5,
         created_at="2023-12-07T23:36:15.652705+00:00",
         architectures=[{"architecture": "amd64", "channel": "22.04", "name": "ubuntu"}],
@@ -218,25 +338,72 @@ def mock_charm_revision_dataclass():
     )
 
 
[e-mail]
-def mock_bundle_yaml():
-    yaml_content = dedent(
-        """\
-        bundle: kubernetes
-        applications:
-            charm1:
-                charm: charm1
-                channel: stable
-                series: jammy
-            charm2:
-                charm: charm2
-    """
+def _yaml_content(charm_names):
+    return dedent(
+        f"""\
+            bundle: kubernetes
+            applications:
+                app1:
+                    charm: {charm_names[0]}
+                    channel: stable
+                    series: jammy
+                app2:
+                    charm: {charm_names[1]}
+        """
     )
+
+
[e-mail]
+def setup_mock_bundle_yaml():
+    yaml_content = _yaml_content(["charm1", "charm2"])
     with mock.patch("builtins.open", mock.mock_open(read_data=yaml_content)):
         yield yaml_content
 
 
 @pytest.fixture
+def setup_charm_and_resource_download_mocks():
+    def setup(charm_name, requests_mock):
+        requests_mock.add(
+            "GET",
+            f"https://download/{charm_name}_5.charm",
+            body="charm-blob".encode(),
+            auto_calculate_content_length=True,
+            content_type="application/octet-stream",
+        )
+        requests_mock.add(
+            "GET",
+            f"https://download/{charm_name}-image_2",
+            body="resource-blob".encode(),
+            auto_calculate_content_length=True,
+            content_type="application/octet-stream",
+        )
+
+    return setup
+
+
[e-mail]
+def setup_bundle_download_mock():
+    def setup(requests_mock, bundle_name=TEST_BUNDLE_NAME):
+        yaml_content = _yaml_content(["charm1", "charm2"])
+        # Use an in-memory zip file as the .bundle blob
+        bundle_buf = BytesIO(yaml_content.encode())
+        zip_buf = BytesIO()
+        with zipfile.ZipFile(zip_buf, mode="a") as bundle_file:
+            bundle_file.writestr("bundle.yaml", bundle_buf.getvalue())
+
+        requests_mock.add(
+            "GET",
+            f"https://download/{bundle_name}_5.bundle",
+            body=zip_buf.getvalue(),
+            auto_calculate_content_length=True,
+            content_type="application/octet-stream",
+        )
+        return yaml_content
+
+    return setup
+
+
[e-mail]
 def mock_charm_import():
     charm_import = CharmImport(
         package_name=TEST_CHARM_NAME,
@@ -247,7 +414,7 @@ def mock_charm_import():
     return charm_import
 
 
-def test_parse_charm_bundle_yaml(mock_bundle_yaml):
+def test_parse_charm_bundle_yaml(setup_mock_bundle_yaml):
     expected = [
         CharmImport(
             package_name="charm1",
@@ -262,7 +429,7 @@ def test_parse_charm_bundle_yaml(mock_bundle_yaml):
             architecture="amd64",
         ),
     ]
-    parsed = charms.parse_charm_bundle_yaml("test_bundle.yaml", "amd64")
+    parsed = charms.parse_charm_bundle_yaml("test_bundle.yaml", "jammy", "amd64")
     assert parsed == expected
 
 
@@ -434,6 +601,24 @@ def test_download_charm_files_success(
         assert _file_read_cb.call_count == 2
 
 
+def _assert_charm_tar_contents(charm_tar_paths, tmpdir):
+    for path in charm_tar_paths:
+        charm_name = os.path.basename(path).replace(".tar.gz", "")
+        with tarfile.open(path, "r:gz") as tar:
+            assert set(ti.name for ti in tar.getmembers()) == {
+                "channel-map.json",
+                f"{charm_name}_5.charm",
+                "resources",
+                f"resources/{charm_name}.{charm_name}-image_2",
+            }
+            path = pathlib.Path(tmpdir.mkdir(f"{charm_name}-extract"))
+            tar.extractall(path)
+        assert (path / f"{charm_name}_5.charm").read_text() == "charm-blob"
+        assert (
+            path / f"resources/{charm_name}.{charm_name}-image_2"
+        ).read_text() == "resource-blob"
+
+
 def test_export_charms_success(
     tmpdir,
     devicegw_root,
@@ -441,33 +626,25 @@ def test_export_charms_success(
     utcnow,
     setup_mock_charm_info,
     setup_mock_charm_refresh,
+    setup_charm_and_resource_download_mocks,
 ):
     charm_names = ["charm1", "charm2"]
     for charm_name in charm_names:
-        requests_mock.add(
-            "GET",
-            f"https://download/{charm_name}_5.charm",
-            body="charm-blob".encode(),
-            auto_calculate_content_length=True,
-            content_type="application/octet-stream",
-        )
-        requests_mock.add(
-            "GET",
-            f"https://download/{charm_name}-image_2",
-            body="resource-blob".encode(),
-            auto_calculate_content_length=True,
-            content_type="application/octet-stream",
-        )
-        _ = setup_mock_charm_info(devicegw_root, requests_mock, charm_name)
-    _ = setup_mock_charm_refresh(devicegw_root, requests_mock, charm_names)
+        setup_charm_and_resource_download_mocks(charm_name, requests_mock)
+        setup_mock_charm_info(devicegw_root, requests_mock, charm_name)
+    setup_mock_charm_refresh(devicegw_root, requests_mock, charm_names)
 
     timestamp = utcnow.replace(microsecond=0).strftime("%Y%m%dT%H%M%S")
 
-    def _side_effect(raw_response, target_path, length):
+    def _progress_copy_to_file_side_effect(raw_response, target_path, length):
         data = raw_response.read()
         assert len(data) == length
         target_path.write_bytes(data)
 
+    def _copyfile_side_effect(_, destination):
+        with open(destination, "w") as f:
+            f.write("mocked_bundle.yaml-content-does-not-matter")
+
     _m_parsed_charm_import = [
         CharmImport(
             package_name="charm1",
@@ -484,30 +661,122 @@ def test_export_charms_success(
     ]
 
     with mock.patch(
-        PATCH_PREFIX + "progress_copy_to_file", side_effect=_side_effect
+        PATCH_PREFIX + "progress_copy_to_file",
+        side_effect=_progress_copy_to_file_side_effect,
     ), mock.patch(
         PATCH_PREFIX + "parse_charm_bundle_yaml", return_value=_m_parsed_charm_import
+    ), mock.patch(
+        PATCH_PREFIX + "shutil.copyfile", _copyfile_side_effect
     ):
         export_dir_path = pathlib.Path(tmpdir.mkdir("export-dir"))
-        tarball_paths = charms.export_charms("test_bundle.yaml", export_dir_path)
+        exported_tar_path = charms.export_charms("test_bundle.yaml", export_dir_path)
 
-    assert tarball_paths == [
-        ("charm1", export_dir_path / f"charm1-{timestamp}.tar.gz"),
-        ("charm2", export_dir_path / f"charm2-{timestamp}.tar.gz"),
-    ]
-    assert set(export_dir_path.iterdir()) == {t[1] for t in tarball_paths}
+    assert (
+        exported_tar_path
+        == export_dir_path
+        / f"{charms.DEFAULT_CHARMS_EXPORT_FILENAME_PREFIX}-{timestamp}.tar.gz"
+    )
 
-    for charm_name, tarball_path in tarball_paths:
-        with tarfile.open(tarball_path, "r:gz") as tar:
-            assert set(ti.name for ti in tar.getmembers()) == {
-                "channel-map.json",
-                f"{charm_name}_5.charm",
-                "resources",
-                f"resources/{charm_name}.{charm_name}-image_2",
-            }
-            path = pathlib.Path(tmpdir.mkdir(f"{charm_name}-extract"))
-            tar.extractall(path)
-        assert (path / f"{charm_name}_5.charm").read_text() == "charm-blob"
-        assert (
-            path / f"resources/{charm_name}.{charm_name}-image_2"
-        ).read_text() == "resource-blob"
+    charms_dir_path = export_dir_path / "charms"
+    with tarfile.open(exported_tar_path, "r:gz") as parent_tar:
+        parent_tar.extractall(charms_dir_path)
+
+    root_dir_contents = {
+        pathlib.Path(os.path.join(charms_dir_path, p))
+        for p in os.listdir(charms_dir_path)
+    }
+    assert root_dir_contents == {
+        charms_dir_path / "charm1.tar.gz",
+        charms_dir_path / "charm2.tar.gz",
+        charms_dir_path / "bundle.yaml",
+    }
+
+    _assert_charm_tar_contents(
+        [charms_dir_path / "charm1.tar.gz", charms_dir_path / "charm2.tar.gz"], tmpdir
+    )
+
+
+def test_export_bundle_success(
+    tmpdir,
+    devicegw_root,
+    requests_mock,
+    utcnow,
+    setup_mock_bundle_info,
+    setup_mock_bundle_refresh,
+    setup_mock_charm_info,
+    setup_bundle_download_mock,
+    setup_charm_and_resource_download_mocks,
+):
+    bundle_yaml_contents = setup_bundle_download_mock(requests_mock)
+    charm_names = ["charm1", "charm2"]
+    for charm_name in charm_names:
+        setup_charm_and_resource_download_mocks(charm_name, requests_mock)
+        setup_mock_charm_info(devicegw_root, requests_mock, charm_name)
+
+    setup_mock_bundle_info(devicegw_root, requests_mock, TEST_BUNDLE_NAME)
+    setup_mock_bundle_refresh(
+        devicegw_root, requests_mock, TEST_BUNDLE_NAME, charm_names
+    )
+
+    timestamp = utcnow.replace(microsecond=0).strftime("%Y%m%dT%H%M%S")
+
+    def _side_effect(raw_response, target_path, length):
+        data = raw_response.read()
+        assert len(data) == length
+        target_path.write_bytes(data)
+
+    with mock.patch(PATCH_PREFIX + "progress_copy_to_file", side_effect=_side_effect):
+        export_dir_path = pathlib.Path(tmpdir.mkdir("export-dir"))
+        bundle_name, tarball_path = charms.export_charm_bundle(
+            TEST_BUNDLE_NAME, export_dir_path, "stable"
+        )
+
+    assert bundle_name == TEST_BUNDLE_NAME
+    assert tarball_path == export_dir_path / f"{TEST_BUNDLE_NAME}-{timestamp}.tar.gz"
+
+    with tarfile.open(tarball_path, "r:gz") as tar:
+        assert set(ti.name for ti in tar.getmembers()) == {
+            "bundle.yaml",
+            "channel-map.json",
+            "bundle1_5.bundle",
+            "charms",
+            "charms/charm1.tar.gz",
+            "charms/charm2.tar.gz",
+        }
+        bundle_path = pathlib.Path(tmpdir.mkdir(f"{TEST_BUNDLE_NAME}-extract"))
+        tar.extractall(bundle_path)
+    assert (bundle_path / "bundle.yaml").read_text() == bundle_yaml_contents
+
+    _assert_charm_tar_contents(
+        [
+            bundle_path / "charms" / "charm1.tar.gz",
+            bundle_path / "charms" / "charm2.tar.gz",
+        ],
+        tmpdir,
+    )
+
+
+def test_get_bundle_yaml_success(
+    devicegw_root,
+    requests_mock,
+    caplog,
+    setup_mock_bundle_info,
+    setup_mock_bundle_refresh,
+    setup_bundle_download_mock,
+):
+    bundle_yaml_contents = setup_bundle_download_mock(requests_mock)
+    charm_names = ["charm1", "charm2"]
+    _ = setup_mock_bundle_info(devicegw_root, requests_mock, TEST_BUNDLE_NAME)
+    _ = setup_mock_bundle_refresh(
+        devicegw_root, requests_mock, TEST_BUNDLE_NAME, charm_names
+    )
+
+    def _side_effect(raw_response, target_path, length):
+        data = raw_response.read()
+        assert len(data) == length
+        target_path.write_bytes(data)
+
+    with mock.patch(PATCH_PREFIX + "progress_copy_to_file", side_effect=_side_effect):
+        charms.get_bundle_yaml(TEST_BUNDLE_NAME, "latest/stable")
+
+    assert bundle_yaml_contents in caplog.messages
diff --git a/store_admin/types.py b/store_admin/types.py
index b3fe34f..e8cc1bd 100644
--- a/store_admin/types.py
+++ b/store_admin/types.py
@@ -44,9 +44,10 @@ DEFAULT_OS = "ubuntu"
 @dataclass
 class CharmImport:
     package_name: str
-    series: str
-    architecture: str
+    series: Optional[str] = None
+    architecture: Optional[str] = None
     channel: Optional[str] = None
+    package_type: str = "charm"
 
     def __post_init__(self):
         if self.channel:
@@ -58,22 +59,16 @@ class CharmImport:
     def as_dict(self):
         return {k: v for k, v in asdict(obj=self).items() if v is not None}
 
-    def get_charm_base_dict(self):
-        return {
-            "name": DEFAULT_OS,
-            "channel": self.series,
-            "architecture": self.architecture,
-        }
-
 
 @dataclass
 class CharmDownloadAction:
     package_name: str
     package_id: str
-    series: str
-    architecture: str
+    series: Optional[str] = None
+    architecture: Optional[str] = None
     channel: Optional[str] = None
     action: str = "download"
+    package_type: str = "charm"
 
     @property
     def instance_key(self):
@@ -84,7 +79,7 @@ class CharmDownloadAction:
         """
         return base64.b64encode(str(uuid4()).encode()).decode()
 
-    def get_charm_base_dict(self):
+    def _get_charm_base_dict(self):
         try:
             return {
                 "name": DEFAULT_OS,
@@ -97,7 +92,10 @@ class CharmDownloadAction:
     def to_request_dict(self):
         request_dict = {
             "action": self.action,
-            "base": self.get_charm_base_dict(),
+            # We still need to send {"base": null} for bundles to conform to the API
+            "base": (
+                self._get_charm_base_dict() if self.package_type == "charm" else None
+            ),
             "instance-key": self.instance_key,
             "id": self.package_id,
         }
@@ -157,6 +155,7 @@ class CharmRevision:
     channel: CharmChannel
     package_name: str
     package_id: str
+    package_type: str
     revision: int
     created_at: str
     architectures: List[dict]
@@ -171,7 +170,7 @@ class CharmRevision:
 
     def blob_file_name(self):
         """Name of the downloaded revision blob file."""
-        return f"{self.package_name}_{self.revision}.charm"
+        return f"{self.package_name}_{self.revision}.{self.package_type}"
 
     def resource_blob_file_name(self, resource):
         """Name of the downloaded resource revision blob file."""