feat(boil): Add new image check command

This command allows users to check that all versions of an image
are available in the specified registry.

Author: Techassi

Cargo.lock

@@ -9,13 +9,15 @@ license = "Apache-2.0"
 
 [workspace.dependencies]
 cap-std = "4.0.2"
-clap = { version = "4.5.41", features = ["derive"] }
+clap = { version = "4.5.41", features = ["derive", "env"] }
 clap_complete = "4.5.55"
 clap_complete_nushell = "4.5.8"
 git2 = "0.20.1"
 glob = "0.3.2"
 oci-spec = "0.9.0"
+reqwest = { version = "0.13.2", features = ["json"] }
 rstest = "0.26.1"
+secrecy = "0.10.3"
 semver = { version = "1.0.26", features = ["serde"] }
 serde = { version = "1.0.217", features = ["derive"] }
 serde_json = "1.0.140"

Cargo.toml

@@ -15,6 +15,8 @@ clap_complete_nushell.workspace = true
 git2.workspace = true
 glob.workspace = true
 oci-spec.workspace = true
+reqwest.workspace = true
+secrecy.workspace = true
 semver.workspace = true
 serde.workspace = true
 serde_json.workspace = true

rust/boil/Cargo.toml

@@ -10,10 +10,13 @@ use snafu::{ResultExt, Snafu, ensure};
 use strum::EnumDiscriminants;
 use url::Host;
 
-use crate::core::{
-    docker::BuildArgument,
-    image::ImageSelector,
-    platform::{Architecture, TargetPlatform},
+use crate::{
+    cli::Cli,
+    core::{
+        docker::BuildArgument,
+        image::ImageSelector,
+        platform::{Architecture, TargetPlatform},
+    },
 };
 
 #[derive(Debug, Args)]
@@ -26,8 +29,8 @@ pub struct BuildArguments {
     /// The image version being built.
     #[arg(
         short, long,
-        value_parser = BuildArguments::parse_image_version,
-        default_value_t = Self::default_image_version(),
+        value_parser = Cli::parse_image_version,
+        default_value_t = Cli::default_image_version(),
         help_heading = "Image Options"
     )]
     pub image_version: Version,
@@ -45,7 +48,7 @@ pub struct BuildArguments {
     /// The format is host[:port].
     #[arg(
         short, long,
-        default_value_t = Self::default_registry(),
+        default_value_t = Cli::default_registry(),
         value_hint = ValueHint::Hostname,
         help_heading = "Registry Options"
     )]
@@ -130,24 +133,6 @@ pub struct BuildArguments {
 }
 
 impl BuildArguments {
-    fn parse_image_version(input: &str) -> Result<Version, ParseImageVersionError> {
-        let version = Version::from_str(input).context(ParseVersionSnafu)?;
-        ensure!(version.build.is_empty(), ContainsBuildMetadataSnafu);
-
-        Ok(version)
-    }
-
-    fn default_image_version() -> Version {
-        "0.0.0-dev".parse().expect("must be a valid SemVer")
-    }
-
-    fn default_registry() -> HostPort {
-        HostPort {
-            host: Host::Domain(String::from("oci.stackable.tech")),
-            port: None,
-        }
-    }
-
     // TODO: Auto-detect this
     fn default_architecture() -> TargetPlatform {
         TargetPlatform::Linux(Architecture::Amd64)
@@ -158,15 +143,6 @@ impl BuildArguments {
     }
 }
 
-#[derive(Debug, Snafu)]
-pub enum ParseImageVersionError {
-    #[snafu(display("failed to parse semantic version"))]
-    ParseVersion { source: semver::Error },
-
-    #[snafu(display("semantic version must not contain build metadata"))]
-    ContainsBuildMetadata,
-}
-
 #[derive(Debug, PartialEq, Snafu, EnumDiscriminants)]
 pub enum ParseHostPortError {
     #[snafu(display("unexpected empty input"))]

rust/boil/src/cli/build.rs

@@ -1,6 +1,7 @@
 use clap::{Args, Subcommand, ValueEnum};
+use semver::Version;
 
-use crate::core::image::ImageSelector;
+use crate::{cli::Cli, core::image::ImageSelector};
 
 #[derive(Debug, Args)]
 pub struct ImageArguments {
@@ -11,6 +12,7 @@ pub struct ImageArguments {
 #[derive(Debug, Subcommand)]
 pub enum ImageCommand {
     List(ImageListArguments),
+    Check(ImageCheckArguments),
 }
 
 #[derive(Debug, Args)]
@@ -23,6 +25,22 @@ pub struct ImageListArguments {
     pub pretty: Pretty,
 }
 
+#[derive(Debug, Args)]
+pub struct ImageCheckArguments {
+    /// Optionally specify one or more images to check. Checks all images by default.
+    pub image: Vec<ImageSelector>,
+
+    // NOTE (@Techassi): Should this maybe be renamed to vendor_version?
+    /// The image version being built.
+    #[arg(
+        short, long,
+        value_parser = Cli::parse_image_version,
+        default_value_t = Cli::default_image_version(),
+        help_heading = "Image Options"
+    )]
+    pub image_version: Version,
+}
+
 // #[derive(Clone, Debug, Default, strum::Display, strum::EnumString)]
 #[derive(Clone, Debug, Default, ValueEnum)]
 pub enum Pretty {

rust/boil/src/cli/image.rs

@@ -1,6 +1,8 @@
-use std::path::PathBuf;
+use std::{path::PathBuf, str::FromStr};
 
 use clap::{Parser, Subcommand};
+use semver::Version;
+use snafu::{ResultExt, Snafu, ensure};
 
 mod build;
 mod completions;
@@ -9,6 +11,16 @@ mod image;
 pub use build::*;
 pub use completions::*;
 pub use image::*;
+use url::Host;
+
+#[derive(Debug, Snafu)]
+pub enum ParseImageVersionError {
+    #[snafu(display("failed to parse semantic version"))]
+    ParseVersion { source: semver::Error },
+
+    #[snafu(display("semantic version must not contain build metadata"))]
+    ContainsBuildMetadata,
+}
 
 #[derive(Debug, Parser)]
 #[command(author, version, about)]
@@ -25,6 +37,26 @@ impl Cli {
     fn default_config_path() -> PathBuf {
         PathBuf::from("./boil.toml")
     }
+
+    pub(super) fn default_image_version() -> Version {
+        "0.0.0-dev"
+            .parse()
+            .expect("static string must be a valid SemVer")
+    }
+
+    pub(super) fn default_registry() -> HostPort {
+        HostPort {
+            host: Host::Domain(String::from("oci.stackable.tech")),
+            port: None,
+        }
+    }
+
+    pub(super) fn parse_image_version(input: &str) -> Result<Version, ParseImageVersionError> {
+        let version = Version::from_str(input).context(ParseVersionSnafu)?;
+        ensure!(version.build.is_empty(), ContainsBuildMetadataSnafu);
+
+        Ok(version)
+    }
 }
 
 #[derive(Debug, Subcommand)]

rust/boil/src/cli/mod.rs

@@ -1,44 +1,154 @@
 use std::{collections::BTreeMap, io::IsTerminal};
 
-use snafu::{ResultExt, Snafu};
+use secrecy::{ExposeSecret, SecretString};
+use snafu::{ResultExt, Snafu, ensure};
 
 use crate::{
-    cli::{ImageListArguments, Pretty},
+    cli::{ImageCheckArguments, ImageListArguments, Pretty},
+    config::Config,
     core::bakefile::{self, Targets, TargetsOptions},
+    models::TagList,
+    utils::format_image_index_manifest_tag,
 };
 
 #[derive(Debug, Snafu)]
 pub enum Error {
     #[snafu(display("failed to serialize list as JSON"))]
-    SerializeList { source: serde_json::Error },
+    SerializeList {
+        source: serde_json::Error,
+    },
 
     #[snafu(display("failed to build list of targets"))]
-    BuildTargets { source: bakefile::TargetsError },
+    BuildTargets {
+        source: bakefile::TargetsError,
+    },
+
+    #[snafu(display("failed to build request client"))]
+    BuildClient {
+        source: reqwest::Error,
+    },
+
+    #[snafu(display("failed to send request"))]
+    SendRequest {
+        source: reqwest::Error,
+    },
+
+    #[snafu(display("failed to deserialize response"))]
+    DeserializeResponse {
+        source: reqwest::Error,
+    },
+
+    MissingVersion {
+        image_name: String,
+    },
 }
 
 /// This is the `boil show images` command handler function.
 pub fn list_images(arguments: ImageListArguments) -> Result<(), Error> {
-    let list: BTreeMap<_, _> = if arguments.image.is_empty() {
-        Targets::all(TargetsOptions { only_entry: true })
-            .context(BuildTargetsSnafu)?
-            .into_iter()
+    let targets = if arguments.image.is_empty() {
+        Targets::all(TargetsOptions {
+            only_entry: true,
+            flat: false,
+        })
+        .context(BuildTargetsSnafu)?
     } else {
-        Targets::set(&arguments.image, TargetsOptions { only_entry: true })
-            .context(BuildTargetsSnafu)?
-            .into_iter()
-    }
-    .map(|(image_name, image_versions)| {
-        let versions: Vec<_> = image_versions
-            .into_iter()
-            .map(|(image_version, (_, _))| image_version)
-            .collect();
-        (image_name, versions)
-    })
-    .collect();
+        Targets::set(
+            &arguments.image,
+            TargetsOptions {
+                only_entry: true,
+                flat: false,
+            },
+        )
+        .context(BuildTargetsSnafu)?
+    };
+
+    let list = targets
+        .into_iter()
+        .map(|(image_name, (image_config, _))| {
+            let versions: Vec<_> = image_config
+                .versions
+                .into_iter()
+                .map(|(image_version, _)| image_version)
+                .collect();
+            (image_name, versions)
+        })
+        .collect();
 
     print_to_stdout(list, arguments.pretty)
 }
 
+pub async fn check_images(arguments: ImageCheckArguments, config: Config) -> Result<(), Error> {
+    let targets = if arguments.image.is_empty() {
+        Targets::all(TargetsOptions {
+            only_entry: true,
+            flat: true,
+        })
+        .context(BuildTargetsSnafu)?
+    } else {
+        Targets::set(
+            &arguments.image,
+            TargetsOptions {
+                only_entry: true,
+                flat: false,
+            },
+        )
+        .context(BuildTargetsSnafu)?
+    };
+
+    let registry_token = std::env::var("REGISTRY_TOKEN").ok().map(SecretString::from);
+    let client = reqwest::ClientBuilder::new()
+        .build()
+        .context(BuildClientSnafu)?;
+
+    for (image_name, (image_config, _)) in targets {
+        // TODO (@Techassi): Do these checks for all registries
+        let Some((registry, registry_options)) = image_config.metadata.registries.first_key_value()
+        else {
+            continue;
+        };
+
+        println!(
+            "Checking for {registry}/{registry_namespace}/{image_name}",
+            registry_namespace = registry_options.namespace,
+        );
+
+        let url = format!(
+            "https://{registry}/v2/{registry_namespace}/{image_name}/tags/list",
+            registry_namespace = registry_options.namespace,
+        );
+        let request = client.get(url);
+
+        let request = match &registry_token {
+            Some(registry_token) => request.bearer_auth(registry_token.expose_secret()),
+            None => request,
+        };
+
+        let tag_list: TagList = request
+            .send()
+            .await
+            .context(SendRequestSnafu)?
+            .json()
+            .await
+            .context(DeserializeResponseSnafu)?;
+
+        ensure!(
+            image_config.versions.iter().all(|(image_version, _)| {
+                let index_manifest_tag = format_image_index_manifest_tag(
+                    image_version,
+                    &config.metadata.vendor_tag_prefix,
+                    &arguments.image_version,
+                );
+
+                println!("- {image_name}:{index_manifest_tag}");
+                tag_list.tags.contains(&index_manifest_tag)
+            }),
+            MissingVersionSnafu { image_name }
+        );
+    }
+
+    Ok(())
+}
+
 fn print_to_stdout(list: BTreeMap<String, Vec<String>>, pretty: Pretty) -> Result<(), Error> {
     let stdout = std::io::stdout();
 

rust/boil/src/cmd/image.rs

@@ -17,7 +17,7 @@ pub enum ConfigError {
 #[serde(rename_all = "kebab-case")]
 pub struct Config {
     pub build_arguments: docker::BuildArguments,
-    pub metadata: Metadata,
+    pub metadata: MetadataOptions,
 }
 
 impl Config {
@@ -31,7 +31,7 @@ impl Config {
 // are optional, the appropriate annotations are only emitted if set.
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "kebab-case")]
-pub struct Metadata {
+pub struct MetadataOptions {
     /// The URL to the documentation page.
     pub documentation: Option<Url>,