about summary refs log tree commit diff
path: root/tvix/nix-compat/src/nixhash
diff options
context:
space:
mode:
authorJohn Ericson <John.Ericson@Obsidian.Systems>2023-03-31T14·20-0400
committerJohn Ericson <git@johnericson.me>2023-04-09T15·12+0000
commit26c68f8e892633bde4aeebbfc0e4ae7ee571687d (patch)
treee6ee1bcf805ceb83b974f6d1c6a8e7d0b30a9b1f /tvix/nix-compat/src/nixhash
parentb4670bfbd16dd80fb52e61e79b4aa6e1d0453570 (diff)
refactor(nix-compat): Properly encapsulate store path construction r/6088
Before there was code scattered about (e.g. text hashing module and
derivation output computation) constructing store paths from low level
building blocks --- there was some duplication and it was easy to make
nonsense store paths.

Now, we have roughly the same "safe-ish" ways of constructing them as
C++ Nix, and only those are exposed:

- Make text hashed content-addressed store paths

- Make other content-addressed store paths

- Make input-addressed fixed output hashes

Change-Id: I122a3ee0802b4f45ae386306b95b698991be89c8
Reviewed-on: https://cl.tvl.fyi/c/depot/+/8411
Reviewed-by: flokli <flokli@flokli.de>
Tested-by: BuildkiteCI
Diffstat (limited to 'tvix/nix-compat/src/nixhash')
-rw-r--r--tvix/nix-compat/src/nixhash/algos.rs2
-rw-r--r--tvix/nix-compat/src/nixhash/with_mode.rs33
2 files changed, 30 insertions, 5 deletions
diff --git a/tvix/nix-compat/src/nixhash/algos.rs b/tvix/nix-compat/src/nixhash/algos.rs
index 1864b4ef975f..d6b0bf47bdb7 100644
--- a/tvix/nix-compat/src/nixhash/algos.rs
+++ b/tvix/nix-compat/src/nixhash/algos.rs
@@ -5,7 +5,7 @@ use serde::{Deserialize, Serialize};
 use crate::nixhash::Error;
 
 /// This are the hash algorithms supported by cppnix.
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
 pub enum HashAlgo {
     Md5,
     Sha1,
diff --git a/tvix/nix-compat/src/nixhash/with_mode.rs b/tvix/nix-compat/src/nixhash/with_mode.rs
index e895f0c62704..1908f27b4759 100644
--- a/tvix/nix-compat/src/nixhash/with_mode.rs
+++ b/tvix/nix-compat/src/nixhash/with_mode.rs
@@ -3,6 +3,20 @@ use crate::nixhash::{HashAlgo, NixHash};
 use serde::ser::SerializeMap;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
+pub enum NixHashMode {
+    Flat,
+    Recursive,
+}
+
+impl NixHashMode {
+    pub fn prefix(self) -> &'static str {
+        match self {
+            Self::Flat => "",
+            Self::Recursive => "r:",
+        }
+    }
+}
+
 /// A Nix Hash can either be flat or recursive.
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum NixHashWithMode {
@@ -11,14 +25,25 @@ pub enum NixHashWithMode {
 }
 
 impl NixHashWithMode {
+    pub fn mode(&self) -> NixHashMode {
+        match self {
+            Self::Flat(_) => NixHashMode::Flat,
+            Self::Recursive(_) => NixHashMode::Recursive,
+        }
+    }
+
+    pub fn digest(&self) -> &NixHash {
+        match self {
+            Self::Flat(ref h) => h,
+            Self::Recursive(ref h) => h,
+        }
+    }
+
     /// Formats a [NixHashWithMode] in the Nix default hash format,
     /// which is the algo, followed by a colon, then the lower hex encoded digest.
     /// In case the hash itself is recursive, a `r:` is added as prefix
     pub fn to_nix_hash_string(&self) -> String {
-        match self {
-            NixHashWithMode::Flat(h) => h.to_nix_hash_string(),
-            NixHashWithMode::Recursive(h) => format!("r:{}", h.to_nix_hash_string()),
-        }
+        String::from(self.mode().prefix()) + &self.digest().to_nix_hash_string()
     }
 }