feat(boil): Support layer caching

Author: Techassi

rust/boil/src/cli/build.rs

@@ -118,6 +118,12 @@ pub struct BuildArguments {
     #[deprecated(since = "0.1.7", note = "Use -- --load instead")]
     pub load: bool,
 
+    #[arg(long, help_heading = "Build Options", group = "cache")]
+    pub cache_registry: Option<HostPort>,
+
+    #[arg(long, help_heading = "Build Options", requires = "cache")]
+    pub cache_namespace: Option<String>,
+
     /// Dry run. This does not build the image(s) but instead prints out the bakefile.
     #[arg(short, long, alias = "dry")]
     pub dry_run: bool,

rust/boil/src/core/bakefile.rs

@@ -340,26 +340,46 @@ impl Bakefile {
 
         for (image_name, (image_config, is_entry)) in targets.into_iter() {
             for (image_version, image_options) in image_config.versions {
-                let image_repository_uri = utils::format_image_repository_uri(
+                let (
+                    image_repository_uri,
+                    image_index_manifest_tag,
+                    image_manifest_tag,
+                    image_manifest_uri,
+                ) = utils::format_image_tag_parts(
                     image_registry,
                     &cli_args.registry_namespace,
                     &image_name,
-                );
-
-                let image_index_manifest_tag = utils::format_image_index_manifest_tag(
-                    &image_version,
+                    &cli_args.image_version,
                     &metadata.vendor_tag_prefix,
                     &cli_args.image_version,
-                );
-
-                let image_manifest_tag = utils::format_image_manifest_tag(
-                    &image_index_manifest_tag,
                     cli_args.target_platform.architecture(),
                     cli_args.strip_architecture,
                 );
 
-                let image_manifest_uri =
-                    utils::format_image_manifest_uri(&image_repository_uri, &image_manifest_tag);
+                let cache_image_manifest_uri =
+                    cli_args.cache_registry.as_ref().map(|cache_registry| {
+                        let uri = utils::format_image_cache_repository_uri(
+                            cache_registry,
+                            cli_args.cache_namespace.as_deref(),
+                            &cli_args.registry_namespace,
+                            &image_name,
+                        );
+
+                        let cache_image_index_manifest_tag =
+                            utils::format_image_cache_index_manifest_tag(
+                                &image_version,
+                                &metadata.vendor_tag_prefix,
+                                &cli_args.image_version,
+                            );
+
+                        let cache_image_manifest_tag = utils::format_image_manifest_tag(
+                            &cache_image_index_manifest_tag,
+                            cli_args.target_platform.architecture(),
+                            cli_args.strip_architecture,
+                        );
+
+                        utils::format_image_manifest_uri(&uri, &cache_image_manifest_tag)
+                    });
 
                 // TODO (@Techassi): Clean this up
                 // TODO (@Techassi): Move the arg formatting into functions
@@ -449,6 +469,23 @@ impl Bakefile {
                     &cli_args.image_version,
                 );
 
+                let cache_to =
+                    cache_image_manifest_uri
+                        .clone()
+                        .map_or_else(Vec::new, |reference| {
+                            vec![CacheStorageBackend::Registry {
+                                reference,
+                                mode: Some(CacheMode::Max),
+                            }]
+                        });
+
+                let cache_from = cache_image_manifest_uri.map_or_else(Vec::new, |reference| {
+                    vec![CacheStorageBackend::Registry {
+                        reference,
+                        mode: None,
+                    }]
+                });
+
                 let target = BakefileTarget {
                     tags: vec![image_manifest_uri],
                     arguments: build_arguments,
@@ -459,6 +496,8 @@ impl Bakefile {
                     inherits: vec![COMMON_TARGET_NAME.to_owned()],
                     annotations,
                     contexts,
+                    cache_from,
+                    cache_to,
                     ..Default::default()
                 };
 
@@ -577,6 +616,12 @@ pub struct BakefileTarget {
     /// Image names and tags to use for the build target.
     #[serde(skip_serializing_if = "Vec::is_empty")]
     pub tags: Vec<String>,
+
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub cache_from: Vec<CacheStorageBackend>,
+
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub cache_to: Vec<CacheStorageBackend>,
 }
 
 impl BakefileTarget {
@@ -668,3 +713,23 @@ impl BakefileTarget {
 pub struct BakefileGroup {
     targets: Vec<String>,
 }
+
+#[derive(Clone, Debug, Serialize)]
+#[serde(tag = "type", rename_all = "lowercase")]
+pub enum CacheStorageBackend {
+    Registry {
+        /// Full name of the cache image to import.
+        #[serde(rename = "ref")]
+        reference: String,
+
+        #[serde(skip_serializing_if = "Option::is_none")]
+        mode: Option<CacheMode>,
+    },
+}
+
+#[derive(Clone, Copy, Debug, Serialize)]
+#[serde(rename_all = "lowercase")]
+pub enum CacheMode {
+    // We currently only support max, because we want to cache every layer
+    Max,
+}

rust/boil/src/utils.rs

@@ -11,6 +11,24 @@ pub fn format_image_repository_uri(
     format!("{image_registry}/{registry_namespace}/{image_name}")
 }
 
+pub fn format_image_cache_repository_uri(
+    image_cache_registry: &HostPort,
+    cache_registry_namespace: Option<&str>,
+    registry_namespace: &str,
+    image_name: &str,
+) -> String {
+    // We don't use .map here because we are unable to borrow the formatted string long enough
+    if let Some(cache_registry_namespace) = cache_registry_namespace {
+        format_image_repository_uri(image_cache_registry, cache_registry_namespace, image_name)
+    } else {
+        format_image_repository_uri(
+            image_cache_registry,
+            &format!("{}-cache", registry_namespace),
+            image_name,
+        )
+    }
+}
+
 /// Formats and returns the image manifest URI, eg. `oci.stackable.tech/sdp/opa:1.4.2-stackable25.7.0-amd64`.
 pub fn format_image_manifest_uri(image_repository_uri: &str, image_manifest_tag: &str) -> String {
     format!("{image_repository_uri}:{image_manifest_tag}")
@@ -25,6 +43,16 @@ pub fn format_image_index_manifest_tag(
     format!("{image_version}-{vendor_tag_prefix}{vendor_image_version}")
 }
 
+pub fn format_image_cache_index_manifest_tag(
+    image_version: &str,
+    vendor_tag_prefix: &str,
+    vendor_image_version: &str,
+) -> String {
+    let tag =
+        format_image_index_manifest_tag(image_version, vendor_tag_prefix, vendor_image_version);
+    format!("{tag}-cache")
+}
+
 /// Formats and returns the image manifest tag, eg. `1.4.2-stackable25.7.0-amd64`.
 ///
 /// The `strip_architecture` parameter controls if the architecture is included in the tag.
@@ -41,6 +69,33 @@ pub fn format_image_manifest_tag(
     }
 }
 
+#[allow(clippy::too_many_arguments)]
+pub fn format_image_tag_parts(
+    image_registry: &HostPort,
+    registry_namespace: &str,
+    image_name: &str,
+    image_version: &str,
+    vendor_tag_prefix: &str,
+    vendor_image_version: &str,
+    architecture: &Architecture,
+    strip_architecture: bool,
+) -> (String, String, String, String) {
+    let image_repository_uri =
+        format_image_repository_uri(image_registry, registry_namespace, image_name);
+    let image_index_manifest_tag =
+        format_image_index_manifest_tag(image_version, vendor_tag_prefix, vendor_image_version);
+    let image_manifest_tag =
+        format_image_manifest_tag(&image_index_manifest_tag, architecture, strip_architecture);
+    let image_manifest_uri = format_image_manifest_uri(&image_repository_uri, &image_manifest_tag);
+
+    (
+        image_repository_uri,
+        image_index_manifest_tag,
+        image_manifest_tag,
+        image_manifest_uri,
+    )
+}
+
 /// Formats and returns the registry-specific env var name, eg. `BOIL_REGISTRY_TOKEN_OCI_STACKABLE_TECH`.
 pub fn format_registry_token_env_var_name(registry_uri: &str) -> String {
     format!(