feat: oci compliance work (#85)

* chore: rework oci crate to be more composable

* feat: image pull is now internally explicit

* feat: utilize vfs for assembling oci images

* feat: rework oci to preserve permissions via a vfs

crates/ctl/src/pull.rs

@@ -0,0 +1,118 @@
+use std::collections::HashMap;
+
+use anyhow::{anyhow, Result};
+use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
+use krata::v1::control::{PullImageProgressLayerPhase, PullImageProgressPhase, PullImageReply};
+use tokio_stream::StreamExt;
+use tonic::Streaming;
+
+pub async fn pull_interactive_progress(
+    mut stream: Streaming<PullImageReply>,
+) -> Result<PullImageReply> {
+    let mut multi_progress: Option<(MultiProgress, HashMap<String, ProgressBar>)> = None;
+
+    while let Some(reply) = stream.next().await {
+        let reply = reply?;
+
+        if reply.progress.is_none() && !reply.digest.is_empty() {
+            return Ok(reply);
+        }
+
+        let Some(oci) = reply.progress else {
+            continue;
+        };
+
+        if multi_progress.is_none() {
+            multi_progress = Some((MultiProgress::new(), HashMap::new()));
+        }
+
+        let Some((multi_progress, progresses)) = multi_progress.as_mut() else {
+            continue;
+        };
+
+        match oci.phase() {
+            PullImageProgressPhase::Resolved
+            | PullImageProgressPhase::ConfigAcquire
+            | PullImageProgressPhase::LayerAcquire => {
+                if progresses.is_empty() && !oci.layers.is_empty() {
+                    for layer in &oci.layers {
+                        let bar = ProgressBar::new(layer.total);
+                        bar.set_style(ProgressStyle::with_template("{msg} {bar}").unwrap());
+                        progresses.insert(layer.id.clone(), bar.clone());
+                        multi_progress.add(bar);
+                    }
+                }
+
+                for layer in oci.layers {
+                    let Some(progress) = progresses.get_mut(&layer.id) else {
+                        continue;
+                    };
+
+                    let phase = match layer.phase() {
+                        PullImageProgressLayerPhase::Waiting => "waiting",
+                        PullImageProgressLayerPhase::Downloading => "downloading",
+                        PullImageProgressLayerPhase::Downloaded => "downloaded",
+                        PullImageProgressLayerPhase::Extracting => "extracting",
+                        PullImageProgressLayerPhase::Extracted => "extracted",
+                        _ => "unknown",
+                    };
+
+                    let simple = if let Some((_, hash)) = layer.id.split_once(':') {
+                        hash
+                    } else {
+                        "unknown"
+                    };
+                    let simple = if simple.len() > 10 {
+                        &simple[0..10]
+                    } else {
+                        simple
+                    };
+                    let message = format!(
+                        "{:width$} {:phwidth$}",
+                        simple,
+                        phase,
+                        width = 10,
+                        phwidth = 11
+                    );
+
+                    if message != progress.message() {
+                        progress.set_message(message);
+                    }
+
+                    progress.update(|state| {
+                        state.set_len(layer.total);
+                        state.set_pos(layer.value);
+                    });
+                }
+            }
+
+            PullImageProgressPhase::Packing => {
+                for (key, bar) in &mut *progresses {
+                    if key == "packing" {
+                        continue;
+                    }
+                    bar.finish_and_clear();
+                    multi_progress.remove(bar);
+                }
+                progresses.retain(|k, _| k == "packing");
+                if progresses.is_empty() {
+                    let progress = ProgressBar::new(100);
+                    progress.set_message("packing    ");
+                    progress.set_style(ProgressStyle::with_template("{msg} {bar}").unwrap());
+                    progresses.insert("packing".to_string(), progress);
+                }
+                let Some(progress) = progresses.get("packing") else {
+                    continue;
+                };
+
+                progress.update(|state| {
+                    state.set_len(oci.total);
+                    state.set_pos(oci.value);
+                });
+            }
+
+            _ => {}
+        }
+    }
+    Err(anyhow!("never received final reply for image pull"))
+}