feat: Make adding manifest to store optional. (#224)

Signed-off-by: Andrew Lilley Brinker <[email protected]>

Author: alilleybrinker

omnibor-cli/src/cli.rs

@@ -92,7 +92,7 @@ impl Args {
     pub fn config(&self) -> Option<&Path> {
         self.config.as_deref().or_else(|| {
             DEFAULT_CONFIG
-                .get_or_init(|| self.dir().map(|root| pathbuf![root, "omnibor.json"]))
+                .get_or_init(|| self.dir().map(|root| pathbuf![root, "config.json"]))
                 .as_deref()
         })
     }
@@ -145,7 +145,6 @@ pub struct IdArgs {
     #[arg(
         short = 'H',
         long = "hash",
-        global = true,
         help_heading = IMPORTANT
     )]
     hash: Option<SelectedHash>,
@@ -206,8 +205,20 @@ pub struct ManifestCreateArgs {
     #[arg(short = 't', long = "target", help_heading = IMPORTANT)]
     pub target: PathBuf,
 
+    /// Do not store the manifest in the local store.
+    #[arg(long = "no-store", help_heading = IMPORTANT)]
+    pub no_store: bool,
+
+    /// Do not write the manifest to a local directory.
+    #[arg(long = "no-out", help_heading = IMPORTANT)]
+    pub no_out: bool,
+
+    /// Directory to write manifest out to.
+    #[arg(short = 'o', long = "output", help_heading = IMPORTANT, value_name = "DIR")]
+    pub output: Option<PathBuf>,
+
     /// Hash algorithm to use for Artifact IDs.
-    #[arg(short = 'H', long = "hash", global = true, env = "OMNIBOR_HASH")]
+    #[arg(short = 'H', long = "hash", env = "OMNIBOR_HASH", help_heading = IMPORTANT)]
     pub hash: Option<SelectedHash>,
 }
 

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

@@ -7,20 +7,42 @@ use crate::{
     print::PrintSender,
 };
 use omnibor::{
-    embedding::NoEmbed, hashes::Sha256, storage::FileSystemStorage, InputManifestBuilder,
-    IntoArtifactId, RelationKind,
+    embedding::{EmbeddingMode, NoEmbed},
+    hashes::Sha256,
+    storage::{FileSystemStorage, InMemoryStorage, Storage},
+    ArtifactId, InputManifestBuilder, IntoArtifactId, RelationKind, ShouldStore,
+};
+use pathbuf::pathbuf;
+use std::{
+    env::current_dir,
+    fs::File,
+    io::Write,
+    path::{Path, PathBuf},
 };
-use tracing::debug;
 
 /// Run the `manifest create` subcommand.
 pub async fn run(_tx: &PrintSender, app: &App, args: &ManifestCreateArgs) -> Result<()> {
-    let root = app.args.dir().ok_or_else(|| Error::NoRoot)?;
-    debug!(root = %root.display());
-
-    let storage = FileSystemStorage::new(root).map_err(Error::StorageInitFailed)?;
+    let root = app.args.dir().ok_or(Error::NoRoot)?;
 
-    let mut builder = InputManifestBuilder::<Sha256, NoEmbed, _>::with_storage(storage);
+    if args.no_store {
+        let storage = InMemoryStorage::new();
+        let builder = InputManifestBuilder::<Sha256, NoEmbed, _>::with_storage(storage);
+        create_with_builder(args, builder)
+    } else {
+        let storage = FileSystemStorage::new(root).map_err(Error::StorageInitFailed)?;
+        let builder = InputManifestBuilder::<Sha256, NoEmbed, _>::with_storage(storage);
+        create_with_builder(args, builder)
+    }
+}
 
+fn create_with_builder<E, S>(
+    args: &ManifestCreateArgs,
+    mut builder: InputManifestBuilder<Sha256, E, S>,
+) -> Result<()>
+where
+    E: EmbeddingMode,
+    S: Storage<Sha256>,
+{
     for input in &args.inputs {
         let aid = input.clone().into_artifact_id().map_err(Error::IdFailed)?;
         builder
@@ -38,9 +60,44 @@ pub async fn run(_tx: &PrintSender, app: &App, args: &ManifestCreateArgs) -> Res
             .map_err(Error::AddRelationFailed)?;
     }
 
-    builder
-        .finish(&args.target)
+    let should_store = if args.no_store {
+        ShouldStore::No
+    } else {
+        ShouldStore::Yes
+    };
+
+    let transaction_ids = builder
+        .finish(&args.target, should_store)
         .map_err(Error::ManifestBuildFailed)?;
 
+    let path = manifest_file_path(args.output.as_deref(), transaction_ids.target_aid())?;
+
+    let mut output_file = File::create_new(&path).map_err(|source| Error::CantWriteManifest {
+        path: path.to_path_buf(),
+        source,
+    })?;
+
+    output_file
+        // SAFETY: We just constructed the manifest, so we know it's fine.
+        .write_all(&transaction_ids.manifest().as_bytes().unwrap())
+        .map_err(|source| Error::CantWriteManifest {
+            path: path.to_path_buf(),
+            source,
+        })?;
+
     Ok(())
 }
+
+fn manifest_file_path(output: Option<&Path>, target_aid: ArtifactId<Sha256>) -> Result<PathBuf> {
+    let dir = match &output {
+        Some(dir) => dir.to_path_buf(),
+        None => match current_dir() {
+            Ok(dir) => dir,
+            Err(_) => return Err(Error::NoOutputDir),
+        },
+    };
+
+    let file_name = format!("{}.manifest", target_aid.as_hex());
+
+    Ok(pathbuf![&dir, &file_name])
+}

omnibor-cli/src/error.rs

@@ -63,6 +63,12 @@ pub enum Error {
         source: OmniborError,
     },
 
+    #[error("can't identify directory to write manifest")]
+    NoOutputDir,
+
+    #[error("can't write manifest to '{}'", path.display())]
+    CantWriteManifest { path: PathBuf, source: IoError },
+
     #[error("work channel closed for sending")]
     WorkChannelCloseSend(#[source] SendError<PathBuf>),
 

omnibor/Cargo.toml

@@ -40,10 +40,12 @@ gitoid = { version = "0.8.0", path = "../gitoid", default-features = false, feat
     "std",
     "url",
 ] }
+newline-converter = "0.3.0"
 pathbuf = "1.0.0"
 serde = { version = "1.0.197", optional = true }
 thiserror = "1.0.60"
 tokio = { version = "1.36.0", features = ["io-util"] }
+tracing = "0.1.40"
 url = "2.5.0"
 walkdir = "2.5.0"
 

omnibor/src/input_manifest_builder.rs

@@ -30,6 +30,15 @@ pub struct InputManifestBuilder<H: SupportedHash, M: EmbeddingMode, S: Storage<H
     storage: S,
 }
 
+/// Should a manifest be stored after creation?
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+pub enum ShouldStore {
+    /// Yes, store the manifest.
+    Yes,
+    /// No, do not store the manifest.
+    No,
+}
+
 impl<H: SupportedHash, M: EmbeddingMode, S: Storage<H>> Debug for InputManifestBuilder<H, M, S> {
     fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
         f.debug_struct("InputManifestBuilder")
@@ -66,8 +75,12 @@ impl<H: SupportedHash, M: EmbeddingMode, S: Storage<H>> InputManifestBuilder<H,
     }
 
     /// Complete the transaction without updating the target artifact.
-    pub fn finish(&mut self, target: &Path) -> Result<TransactionIds<H>> {
-        Self::finish_with_optional_embedding(self, target, M::mode())
+    pub fn finish(
+        &mut self,
+        target: &Path,
+        should_store: ShouldStore,
+    ) -> Result<TransactionIds<H>> {
+        Self::finish_with_optional_embedding(self, target, M::mode(), should_store)
     }
 
     /// Complete creation of a new [`InputManifest`], possibly embedding in the target.
@@ -79,12 +92,18 @@ impl<H: SupportedHash, M: EmbeddingMode, S: Storage<H>> InputManifestBuilder<H,
         &mut self,
         target: &Path,
         embed_mode: Mode,
+        should_store: ShouldStore,
     ) -> Result<TransactionIds<H>> {
         // Construct a new input manifest.
         let mut manifest = InputManifest::with_relations(self.relations.iter().cloned());
 
-        // Write the manifest to storage.
-        let manifest_aid = self.storage.write_manifest(&manifest)?;
+        let manifest_aid = if should_store == ShouldStore::Yes {
+            // Write the manifest to storage.
+            self.storage.write_manifest(&manifest)?
+        } else {
+            // Otherwise, just build it.
+            ArtifactId::id_manifest(&manifest)?
+        };
 
         // Get the ArtifactID of the target, possibly embedding the
         // manifest ArtifactID into the target first.
@@ -116,6 +135,11 @@ impl<H: SupportedHash, M: EmbeddingMode, S: Storage<H>> InputManifestBuilder<H,
             manifest,
         })
     }
+
+    /// Get a reference to the underlying storage.
+    pub fn storage(&self) -> &S {
+        &self.storage
+    }
 }
 
 pub struct TransactionIds<H: SupportedHash> {
@@ -266,7 +290,7 @@ mod tests {
             .unwrap()
             .add_relation(RelationKind::Input, second_input_aid)
             .unwrap()
-            .finish(&target)
+            .finish(&target, ShouldStore::Yes)
             .unwrap();
 
         // Check the ArtifactIDs of the target and the manifest.

omnibor/src/lib.rs

@@ -87,4 +87,5 @@ pub use crate::input_manifest::InputManifest;
 pub use crate::input_manifest::Relation;
 pub use crate::input_manifest::RelationKind;
 pub use crate::input_manifest_builder::InputManifestBuilder;
+pub use crate::input_manifest_builder::ShouldStore;
 pub use crate::into_artifact_id::IntoArtifactId;

omnibor/src/storage.rs

@@ -22,6 +22,7 @@ use std::ops::Not as _;
 use std::path::Path;
 use std::path::PathBuf;
 use std::str::FromStr;
+use tracing::debug;
 use walkdir::DirEntry;
 use walkdir::WalkDir;
 
@@ -263,6 +264,8 @@ fn artifact_id_from_dir_entry<H: SupportedHash>(entry: &DirEntry) -> Option<Arti
         format!("{}:{}", front, hash)
     };
 
+    debug!(gitoid_url = %gitoid_url);
+
     ArtifactId::<H>::from_str(&gitoid_url).ok()
 }