feat(cli): add manifest find command

This adds a new `manifest find` command, which works similarly to `id find`,
but instead searches for build inputs across Input Manifests.

Signed-off-by: Andrew Lilley Brinker <alilleybrinker@gmail.com>

Author: alilleybrinker

omnibor-cli/src/cli.rs

@@ -180,6 +180,8 @@ pub struct ManifestArgs {
 pub enum ManifestCommand {
     /// Create a new manifest and add it to the store
     Create(ManifestCreateArgs),
+    /// Find manifests containing an Artifact ID.
+    Find(ManifestFindArgs),
 }
 
 #[derive(Debug, clap::Args)]
@@ -202,6 +204,18 @@ pub struct ManifestCreateArgs {
     pub store: bool,
 }
 
+#[derive(Debug, clap::Args)]
+#[command(arg_required_else_help = true)]
+pub struct ManifestFindArgs {
+    /// Artifact ID to match
+    #[arg(short = 'a', long = "aid", help_heading = IMPORTANT)]
+    pub aid: ArtifactId<Sha256>,
+
+    /// The root path to search under
+    #[arg(short = 'p', long = "path", help_heading = IMPORTANT)]
+    pub path: PathBuf,
+}
+
 #[derive(Debug, clap::Args)]
 #[command(arg_required_else_help = true)]
 pub struct StoreArgs {

omnibor-cli/src/cmd/manifest/find.rs

@@ -0,0 +1,76 @@
+//! The `manifest find` command, which searches in manifests.
+
+use crate::{
+    app::App,
+    cli::{Format, ManifestFindArgs},
+    error::{Error, Result},
+    fs::*,
+    print::{msg::manifest_find::ManifestFindMsg, PrintSender, PrinterCmd},
+};
+use async_channel::{bounded, Receiver};
+use futures_lite::stream::StreamExt as _;
+use futures_util::pin_mut;
+use omnibor::{hash_algorithm::Sha256, ArtifactId, InputManifest};
+use std::path::PathBuf;
+use tokio::task::JoinSet;
+use tracing::debug;
+
+/// Run the `manifest find` subcommand.
+pub async fn run(app: &App, args: &ManifestFindArgs) -> Result<()> {
+    let ManifestFindArgs { aid, path } = args;
+
+    let (sender, receiver) = bounded(app.config.perf.work_queue_size());
+
+    tokio::spawn(walk_target(
+        sender,
+        app.print_tx.clone(),
+        app.args.format(),
+        path.to_path_buf(),
+    ));
+
+    let mut join_set = JoinSet::new();
+
+    let num_workers = app.config.perf.num_workers();
+    debug!(num_workers = %num_workers);
+
+    for _ in 0..num_workers {
+        join_set.spawn(open_and_match_manifests(
+            receiver.clone(),
+            app.print_tx.clone(),
+            app.args.format(),
+            *aid,
+        ));
+    }
+
+    while let Some(result) = join_set.join_next().await {
+        result.map_err(Error::CouldNotJoinWorker)??;
+    }
+
+    Ok(())
+}
+
+async fn open_and_match_manifests(
+    path_rx: Receiver<PathBuf>,
+    tx: PrintSender,
+    format: Format,
+    target_aid: ArtifactId<Sha256>,
+) -> Result<()> {
+    pin_mut!(path_rx);
+
+    while let Some(path) = path_rx.next().await {
+        if let Ok(manifest) = InputManifest::<Sha256>::from_path(&path) {
+            if manifest.contains_input(target_aid) {
+                tx.send(PrinterCmd::msg(
+                    ManifestFindMsg {
+                        path: path.to_path_buf(),
+                        manifest: manifest.clone(),
+                    },
+                    format,
+                ))
+                .await?;
+            }
+        }
+    }
+
+    Ok(())
+}

omnibor-cli/src/cmd/manifest/mod.rs

@@ -1 +1,2 @@
 pub mod create;
+pub mod find;

omnibor-cli/src/main.rs

@@ -72,6 +72,7 @@ async fn run_cmd(app: &App) -> Result<()> {
         },
         Command::Manifest(ref args) => match args.command {
             ManifestCommand::Create(ref args) => manifest::create::run(app, args).await,
+            ManifestCommand::Find(ref args) => manifest::find::run(app, args).await,
         },
         Command::Store(ref args) => match args.command {
             StoreCommand::Add(ref args) => store::add::run(app, args).await,

omnibor-cli/src/print/msg/manifest_find.rs

@@ -0,0 +1,39 @@
+use crate::print::{CommandOutput, Status};
+use omnibor::{hash_algorithm::Sha256, InputManifest};
+use std::path::PathBuf;
+
+#[derive(Debug, Clone)]
+pub struct ManifestFindMsg {
+    /// The path the Manifest was found in.
+    pub path: PathBuf,
+    /// The Input Manifest
+    pub manifest: InputManifest<Sha256>,
+}
+
+impl CommandOutput for ManifestFindMsg {
+    fn plain_output(&self) -> String {
+        let mut output = String::new();
+
+        output.push_str(&format!("Found in '{}'\n", self.path.display()));
+
+        output.push_str(&self.manifest.header().to_string());
+
+        for relation in self.manifest.relations() {
+            output.push_str(&relation.to_string());
+        }
+
+        output
+    }
+
+    fn short_output(&self) -> String {
+        self.plain_output()
+    }
+
+    fn json_output(&self) -> serde_json::Value {
+        serde_json::json!({"path": self.path.display().to_string(), "manifest": self.plain_output()})
+    }
+
+    fn status(&self) -> Status {
+        Status::Success
+    }
+}

omnibor-cli/src/print/msg/mod.rs

@@ -2,6 +2,7 @@ pub mod error;
 pub mod find_file;
 pub mod id_file;
 pub mod manifest_create;
+pub mod manifest_find;
 pub mod paths;
 pub mod store_get;
 pub mod store_remove;

omnibor-cli/tests/snapshots/test__manifest_no_args.snap

@@ -16,6 +16,7 @@ Usage: omnibor manifest [OPTIONS] <COMMAND>
 
 Commands:
   create  Create a new manifest and add it to the store
+  find    Find manifests containing an Artifact ID
   help    Print this message or the help of the given subcommand(s)
 
 Options:

omnibor/src/input_manifest/input_manifest.rs

@@ -88,6 +88,11 @@ impl<H: HashAlgorithm> InputManifest<H> {
         &self.relations[..]
     }
 
+    /// Check if the manifest contains the given input.
+    pub fn contains_input(&self, input_aid: ArtifactId<H>) -> bool {
+        self.relations().iter().any(|rel| rel.artifact == input_aid)
+    }
+
     /// Construct an [`InputManifest`] from a file at a specified path.
     pub fn from_path(path: &Path) -> Result<Self, InputManifestError> {
         let file = BufReader::new(