Actually stop writing blob files

The previous commit that removed `write_blob` didn't actually accomplish
much because blobs were mostly being written with `write_object`. There
is now a debug assertion in `write_object` to prevent writing blobs.
Once this was in place, the tests starting revealing all the places that
were still writing blobs, and then all the places that didn't work
anymore when blobs don't exist.

This commit redefines some terminology used in the API. Previously an
"object" could include blob objects and their digests could be used
interchangeably with payload digests. Now payloads are not considered to
be an "object" and methods that operate on object digests do not work
for payloads. Some method names have been changed to make this more
apparent.

The term "item" is used for things (digests) that can be either an
object of a payload.

A "ref" can be a digest and it is expected that it is still possible to
interact with payloads via a ref. A tag can refer to a payload as well.

The 'find_digests' operation used to return digests for blob objects so
absent blobs it has been changed to return both object digests and
payload digests.

Signed-off-by: J Robert Ray <[email protected]>

Author: jrray

crates/spfs-cli/main/src/cmd_check.rs

@@ -90,29 +90,29 @@ impl CmdCheck {
         drop(checker); // clean up progress bars
         let spfs::check::CheckSummary {
             missing_tags,
-            checked_tags,
+            valid_tags,
             missing_objects,
             repaired_objects,
-            checked_objects,
+            valid_objects,
             missing_payloads,
             repaired_payloads,
-            checked_payloads,
-            checked_payload_bytes,
+            valid_payloads,
+            valid_payload_bytes,
         } = summary;
         let missing_objects = missing_objects.len();
         let missing_payloads = missing_payloads.len();
 
         println!("{} after {duration:.0?}:", "Finished".bold());
         let missing = "missing".red().italic();
         let repaired = "repaired".cyan().italic();
-        println!("{checked_tags:>12} tags visited     ({missing_tags} {missing})");
+        println!("{valid_tags:>12} tags visited     ({missing_tags} {missing})");
         println!(
-            "{checked_objects:>12} objects visited  ({missing_objects} {missing}, {repaired_objects} {repaired})",
+            "{valid_objects:>12} objects visited  ({missing_objects} {missing}, {repaired_objects} {repaired})",
         );
         println!(
-            "{checked_payloads:>12} payloads visited ({missing_payloads} {missing}, {repaired_payloads} {repaired})",
+            "{valid_payloads:>12} payloads visited ({missing_payloads} {missing}, {repaired_payloads} {repaired})",
         );
-        let human_bytes = match NumberPrefix::binary(checked_payload_bytes as f64) {
+        let human_bytes = match NumberPrefix::binary(valid_payload_bytes as f64) {
             NumberPrefix::Standalone(amt) => format!("{amt} bytes"),
             NumberPrefix::Prefixed(p, amt) => format!("{amt:.2} {}B", p.symbol()),
         };

crates/spfs-cli/main/src/cmd_info.rs

@@ -13,7 +13,10 @@ use spfs::find_path::ObjectPathEntry;
 use spfs::graph::Annotation;
 use spfs::io::{self, DigestFormat, Pluralize};
 use spfs::prelude::*;
-use spfs::{self};
+use spfs::{
+    Error,
+    {self},
+};
 use spfs_cli_common as cli;
 
 #[cfg(test)]
@@ -73,9 +76,21 @@ impl CmdInfo {
                     self.pretty_print_file(&reference, &repo, self.logging.verbose as usize)
                         .await?;
                 } else {
-                    let item = repo.read_ref(reference.as_str()).await?;
-                    self.pretty_print_ref(item, &repo, self.logging.verbose as usize)
-                        .await?;
+                    match repo.read_ref(reference.as_str()).await {
+                        Ok(item) => {
+                            self.pretty_print_ref(item, &repo, self.logging.verbose as usize)
+                                .await?;
+                        }
+                        Err(Error::UnknownObject(_)) => {
+                            let digest = repo.resolve_ref(reference.as_str()).await?;
+                            let payload_size = repo.payload_size(digest).await?;
+                            self.pretty_print_payload(digest, payload_size, &repo)
+                                .await?;
+                        }
+                        Err(err) => {
+                            return Err(err.into());
+                        }
+                    }
                 }
                 if !self.to_process.is_empty() {
                     println!();
@@ -220,6 +235,31 @@ impl CmdInfo {
         Ok(())
     }
 
+    /// Display the spfs payload information
+    async fn pretty_print_payload(
+        &mut self,
+        digest: spfs::encoding::Digest,
+        payload_size: u64,
+        repo: &spfs::storage::RepositoryHandle,
+    ) -> Result<()> {
+        println!(
+            "{}:\n {}:",
+            self.format_digest(digest, repo).await?,
+            "blob".green()
+        );
+        println!(
+            " {} {}",
+            "digest:".bright_blue(),
+            self.format_digest(digest, repo).await?
+        );
+        println!(
+            " {} {}",
+            "size:".bright_blue(),
+            spfs::io::format_size(payload_size)
+        );
+        Ok(())
+    }
+
     /// Display the status of the current runtime.
     async fn print_global_info(&self, repo: &spfs::storage::RepositoryHandle) -> Result<()> {
         let runtime = spfs::active_runtime().await?;

crates/spfs-cli/main/src/cmd_pull.rs

@@ -4,6 +4,7 @@
 
 use clap::Args;
 use miette::Result;
+use spfs::sync::reporter::Summary;
 use spfs_cli_common as cli;
 
 /// Pull one or more objects to the local repository

crates/spfs-cli/main/src/cmd_push.rs

@@ -4,6 +4,7 @@
 
 use clap::Args;
 use miette::Result;
+use spfs::sync::reporter::Summary;
 use spfs_cli_common as cli;
 
 /// Push one or more objects to a remote repository

crates/spfs-cli/main/src/cmd_read.rs

@@ -30,24 +30,27 @@ pub struct CmdRead {
 
 impl CmdRead {
     pub async fn run(&mut self, config: &spfs::Config) -> Result<i32> {
+        use spfs::graph::object::Enum;
+
         let repo =
             spfs::config::open_repository_from_string(config, self.repos.remote.as_ref()).await?;
 
         #[cfg(feature = "sentry")]
         tracing::info!(target: "sentry", "using repo: {}", repo.address());
 
-        let item = repo.read_ref(&self.reference.to_string()).await?;
-        use spfs::graph::object::Enum;
-        let digest = match item.to_enum() {
-            Enum::Blob(blob) => *blob.digest(),
-            _ => {
+        let digest = match repo.read_ref(&self.reference.to_string()).await.map(|fb| {
+            let fb_enum = fb.to_enum();
+            (fb, fb_enum)
+        }) {
+            Ok((_, Enum::Blob(blob))) => *blob.digest(),
+            Ok((obj, _)) => {
                 let path = match &self.path {
                     None => {
-                        miette::bail!("PATH must be given to read from {:?}", item.kind());
+                        miette::bail!("PATH must be given to read from {:?}", obj.kind());
                     }
                     Some(p) => p.strip_prefix("/spfs").unwrap_or(p).to_string(),
                 };
-                let manifest = spfs::compute_object_manifest(item, &repo).await?;
+                let manifest = spfs::compute_object_manifest(obj, &repo).await?;
                 let entry = match manifest.get_path(&path) {
                     Some(e) => e,
                     None => {
@@ -61,6 +64,10 @@ impl CmdRead {
                 }
                 entry.object
             }
+            Err(Error::UnknownObject(digest)) => digest,
+            Err(err) => {
+                return Err(err.into());
+            }
         };
 
         let (mut payload, filename) = repo.open_payload(digest).await?;

crates/spfs-encoding/src/hash.rs

@@ -259,7 +259,10 @@ impl Decodable for String {
     }
 }
 
-/// The first N bytes of a digest that may still be unambiguous as a reference
+/// The first N bytes of a digest that may still be unambiguous as a reference.
+///
+/// This type can represent a full digest, but it does not require that an item
+/// exists with that digest or what type of item it is.
 #[derive(Deserialize, Debug, Hash, Eq, PartialEq, Ord, PartialOrd, Clone)]
 pub struct PartialDigest(Vec<u8>);