DRAFT: List logically bound images

For now this is just the implementation, but it does not contain the
important bug fix for #846
which is to allow this command to run inside a container and not just on
a bootc booted host

Signed-off-by: Omer Tuchfeld <[email protected]>

lib/Cargo.toml

@@ -46,6 +46,8 @@ toml = "0.8.12"
 xshell = { version = "0.2.6", optional = true }
 uuid = { version = "1.8.0", features = ["v4"] }
 tini = "1.3.0"
+tabled = "0.16.0"
+csv = "1.3.0"
 
 [dev-dependencies]
 indoc = { workspace = true }

lib/src/cli.rs

@@ -21,6 +21,7 @@ use ostree_ext::container as ostree_container;
 use ostree_ext::keyfileext::KeyFileExt;
 use ostree_ext::ostree;
 use schemars::schema_for;
+use serde::{Deserialize, Serialize};
 
 use crate::deploy::RequiredHostSpec;
 use crate::lints;
@@ -235,13 +236,56 @@ pub(crate) enum ImageCmdOpts {
     },
 }
 
+#[derive(ValueEnum, Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[serde(rename_all = "kebab-case")]
+pub(crate) enum ImageListType {
+    /// List all images
+    #[default]
+    All,
+    /// List only logically bound images
+    Logical,
+    /// List only host images
+    Host,
+}
+
+impl std::fmt::Display for ImageListType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.to_possible_value().unwrap().get_name().fmt(f)
+    }
+}
+
+#[derive(ValueEnum, Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[serde(rename_all = "kebab-case")]
+pub(crate) enum ImageListFormat {
+    /// Human readable table format
+    #[default]
+    Table,
+    /// JSON format
+    Json,
+    /// CSV format
+    Csv,
+}
+impl std::fmt::Display for ImageListFormat {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.to_possible_value().unwrap().get_name().fmt(f)
+    }
+}
+
 /// Subcommands which operate on images.
 #[derive(Debug, clap::Subcommand, PartialEq, Eq)]
 pub(crate) enum ImageOpts {
     /// List fetched images stored in the bootc storage.
     ///
     /// Note that these are distinct from images stored via e.g. `podman`.
-    List,
+    List {
+        /// Type of image to list
+        #[clap(long)]
+        #[arg(default_value_t)]
+        list_type: ImageListType,
+        #[clap(long)]
+        #[arg(default_value_t)]
+        list_format: ImageListFormat,
+    },
     /// Copy a container image from the bootc storage to `containers-storage:`.
     ///
     /// The source and target are both optional; if both are left unspecified,
@@ -876,7 +920,10 @@ async fn run_from_opt(opt: Opt) -> Result<()> {
             }
         },
         Opt::Image(opts) => match opts {
-            ImageOpts::List => crate::image::list_entrypoint().await,
+            ImageOpts::List {
+                list_type,
+                list_format,
+            } => crate::image::list_entrypoint(list_type, list_format).await,
             ImageOpts::CopyToStorage { source, target } => {
                 crate::image::push_entrypoint(source.as_deref(), target.as_deref()).await
             }

lib/src/image.rs

@@ -2,33 +2,119 @@
 //!
 //! APIs for operating on container images in the bootc storage.
 
-use anyhow::{Context, Result};
+use anyhow::{ensure, Context, Result};
 use bootc_utils::CommandRunExt;
+use clap::ValueEnum;
 use fn_error_context::context;
 use ostree_ext::container::{ImageReference, Transport};
+use serde::Serialize;
+use tabled::{settings::Style, Tabled};
 
-use crate::imgstorage::Storage;
+use crate::cli::{ImageListFormat, ImageListType};
 
 /// The name of the image we push to containers-storage if nothing is specified.
 const IMAGE_DEFAULT: &str = "localhost/bootc";
 
+#[derive(Clone, Tabled, Serialize, ValueEnum)]
+enum ImageListTypeColumn {
+    Host,
+    Logical,
+}
+
+impl std::fmt::Display for ImageListTypeColumn {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.to_possible_value().unwrap().get_name().fmt(f)
+    }
+}
+
+#[derive(Tabled, Serialize)]
+struct ImageOutput {
+    #[tabled(rename = "IMAGE TYPE")]
+    image_type: ImageListTypeColumn,
+
+    #[tabled(rename = "IMAGE")]
+    image: String,
+    // TODO: Add hash, size, etc? Difficult because [`ostree_ext::container::store::list_images`]
+    // only gives us the pullspec.
+}
+
+#[context("Listing host images")]
+fn list_host_images(sysroot: &crate::store::Storage) -> Result<Vec<ImageOutput>> {
+    let repo = sysroot.repo();
+    let images = ostree_ext::container::store::list_images(&repo).context("Querying images")?;
+
+    Ok(images
+        .iter()
+        .map(|x| ImageOutput {
+            image: x.to_string(),
+            image_type: ImageListTypeColumn::Host,
+        })
+        .collect())
+}
+
+#[context("Listing logical images")]
+fn list_logical_images(sysroot: &crate::store::Storage) -> Result<Vec<ImageOutput>> {
+    let output = sysroot
+        .get_ensure_imgstore()?
+        .new_image_cmd()?
+        .arg("list")
+        .arg("--format={{.Repository}}:{{.Tag}}")
+        .log_debug()
+        .output()?;
+
+    ensure!(
+        output.status.success(),
+        "Failed to list images: {}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+
+    let stdout = String::from_utf8(output.stdout)?;
+
+    let images = stdout
+        .lines()
+        .map(|x| ImageOutput {
+            image: x.to_string(),
+            image_type: ImageListTypeColumn::Logical,
+        })
+        .collect();
+
+    Ok(images)
+}
+
 #[context("Listing images")]
-pub(crate) async fn list_entrypoint() -> Result<()> {
-    let sysroot = crate::cli::get_storage().await?;
-    let repo = &sysroot.repo();
+pub(crate) async fn list_entrypoint(
+    list_type: ImageListType,
+    list_format: ImageListFormat,
+) -> Result<()> {
+    // TODO: Get the storage from the container image, not the booted storage
+    let sysroot: crate::store::Storage = crate::cli::get_storage().await?;
 
-    let images = ostree_ext::container::store::list_images(repo).context("Querying images")?;
+    let images = match list_type {
+        ImageListType::All => {
+            let images = list_host_images(&sysroot)?;
+            let images = images.into_iter().chain(list_logical_images(&sysroot)?);
+            images.collect()
+        }
+        ImageListType::Host => list_host_images(&sysroot)?,
+        ImageListType::Logical => list_logical_images(&sysroot)?,
+    };
 
-    println!("# Host images");
-    for image in images {
-        println!("{image}");
+    match list_format {
+        ImageListFormat::Table => {
+            println!("{}", tabled::Table::new(images).with(Style::blank()));
+        }
+        ImageListFormat::Json => {
+            let json = serde_json::to_string_pretty(&images)?;
+            println!("{}", json);
+        }
+        ImageListFormat::Csv => {
+            let mut wtr = csv::Writer::from_writer(std::io::stdout());
+            for image in images {
+                wtr.serialize(image)?;
+            }
+            wtr.flush()?;
+        }
     }
-    println!();
-
-    println!("# Logically bound images");
-    let mut listcmd = sysroot.get_ensure_imgstore()?.new_image_cmd()?;
-    listcmd.arg("list");
-    listcmd.run()?;
 
     Ok(())
 }
@@ -79,7 +165,7 @@ pub(crate) async fn push_entrypoint(source: Option<&str>, target: Option<&str>)
 /// Thin wrapper for invoking `podman image <X>` but set up for our internal
 /// image store (as distinct from /var/lib/containers default).
 pub(crate) async fn imgcmd_entrypoint(
-    storage: &Storage,
+    storage: &crate::imgstorage::Storage,
     arg: &str,
     args: &[std::ffi::OsString],
 ) -> std::result::Result<(), anyhow::Error> {