refactor(tvix/nix-compat): move build_store_path out of derivation r/6060

This doesn't have anything to do with ATerms, we just happen to be using
the aterm representation of a Derivation as contents.

Moving this into store_path/utils.rs makes these things much cleaner -
Have a build_store_path_from_references function, and a
build_store_path_from_fingerprint helper function that makes use of it.

build_store_path_from_references is invoked from the derivation module
which can be used to calculate the derivation path.

In the derivation module, we also invoke
build_store_path_from_fingerprint during the output path calculation.

Change-Id: Ia8d61a5e8e5d3f396f93593676ed3f5d1a3f1d66
Reviewed-on: https://cl.tvl.fyi/c/depot/+/8367
Autosubmit: flokli <flokli@flokli.de>
Reviewed-by: tazjin <tazjin@tvl.su>
Tested-by: BuildkiteCI

1 files changed, 0 insertions, 198 deletions

diff --git a/tvix/nix-compat/src/store_path.rs b/tvix/nix-compat/src/store_path.rs
deleted file mode 100644
index 980312bff1b1..000000000000
--- a/tvix/nix-compat/src/store_path.rs
+++ /dev/null
@@ -1,198 +0,0 @@
-use crate::nixbase32::{self, Nixbase32DecodeError};
-use std::fmt;
-use thiserror::Error;
-
-pub const DIGEST_SIZE: usize = 20;
-// lazy_static doesn't allow us to call NIXBASE32.encode_len(), so we ran it
-// manually and have an assert in the tests.
-pub const ENCODED_DIGEST_SIZE: usize = 32;
-
-// The store dir prefix, without trailing slash.
-// That's usually where the Nix store is mounted at.
-pub const STORE_DIR: &str = "/nix/store";
-pub const STORE_DIR_WITH_SLASH: &str = "/nix/store/";
-
-/// Errors that can occur during the validation of name characters.
-#[derive(Debug, PartialEq, Eq, Error)]
-pub enum ParseStorePathError {
-    #[error("Dash is missing between hash and name")]
-    MissingDash(),
-    #[error("Hash encoding is invalid: {0}")]
-    InvalidHashEncoding(Nixbase32DecodeError),
-    #[error("Invalid name: {0}")]
-    InvalidName(String),
-    #[error("Tried to parse an absolute path which was missing the store dir prefix.")]
-    MissingStoreDir(),
-}
-
-/// Represents a path in the Nix store (a direct child of [STORE_DIR]).
-///
-/// It starts with a digest (20 bytes), [crate::nixbase32]-encoded,
-/// followed by a `-`, and ends with a `name`, which is a string, consisting only of ASCCI
-/// alphanumeric characters, or one of the following characters: `-`, `_`, `.`,
-/// `+`, `?`, `=`.
-///
-/// The name is usually used to describe the pname and version of a package.
-/// Derivations paths can also be represented as store paths, they end
-/// with .drv.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct StorePath {
-    pub digest: [u8; DIGEST_SIZE],
-    pub name: String,
-}
-
-impl StorePath {
-    pub fn from_string(s: &str) -> Result<StorePath, ParseStorePathError> {
-        // the whole string needs to be at least:
-        //
-        // - 32 characters (encoded hash)
-        // - 1 dash
-        // - 1 character for the name
-        if s.len() < ENCODED_DIGEST_SIZE + 2 {
-            return Err(ParseStorePathError::InvalidName("".to_string()));
-        }
-
-        let digest = match nixbase32::decode(s[..ENCODED_DIGEST_SIZE].as_bytes()) {
-            Ok(decoded) => decoded,
-            Err(decoder_error) => {
-                return Err(ParseStorePathError::InvalidHashEncoding(decoder_error))
-            }
-        };
-
-        if s.as_bytes()[ENCODED_DIGEST_SIZE] != b'-' {
-            return Err(ParseStorePathError::MissingDash());
-        }
-
-        StorePath::validate_name(&s[ENCODED_DIGEST_SIZE + 2..])?;
-
-        Ok(StorePath {
-            name: s[ENCODED_DIGEST_SIZE + 1..].to_string(),
-            digest: digest.try_into().expect("size is known"),
-        })
-    }
-
-    /// Construct a [StorePath] from an absolute store path string.
-    /// That is a string starting with the store prefix (/nix/store)
-    pub fn from_absolute_path(s: &str) -> Result<StorePath, ParseStorePathError> {
-        match s.strip_prefix(STORE_DIR_WITH_SLASH) {
-            Some(s_stripped) => Self::from_string(s_stripped),
-            None => Err(ParseStorePathError::MissingStoreDir()),
-        }
-    }
-
-    /// Converts the [StorePath] to an absolute store path string.
-    /// That is a string starting with the store prefix (/nix/store)
-    pub fn to_absolute_path(&self) -> String {
-        format!("{}/{}", STORE_DIR, self)
-    }
-
-    /// Checks a given &str to match the restrictions for store path names.
-    pub fn validate_name(s: &str) -> Result<(), ParseStorePathError> {
-        for c in s.chars() {
-            if c.is_ascii_alphanumeric()
-                || c == '-'
-                || c == '_'
-                || c == '.'
-                || c == '+'
-                || c == '?'
-                || c == '='
-            {
-                continue;
-            }
-
-            return Err(ParseStorePathError::InvalidName(s.to_string()));
-        }
-
-        Ok(())
-    }
-}
-
-impl fmt::Display for StorePath {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}-{}", nixbase32::encode(&self.digest), self.name)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::nixbase32;
-    use crate::store_path::{DIGEST_SIZE, ENCODED_DIGEST_SIZE};
-
-    use super::{ParseStorePathError, StorePath};
-
-    #[test]
-    fn encoded_digest_size() {
-        assert_eq!(ENCODED_DIGEST_SIZE, nixbase32::encode_len(DIGEST_SIZE));
-    }
-
-    #[test]
-    fn happy_path() {
-        let example_nix_path_str =
-            "00bgd045z0d4icpbc2yyz4gx48ak44la-net-tools-1.60_p20170221182432";
-        let nixpath =
-            StorePath::from_string(example_nix_path_str).expect("Error parsing example string");
-
-        let expected_digest: [u8; DIGEST_SIZE] = [
-            0x8a, 0x12, 0x32, 0x15, 0x22, 0xfd, 0x91, 0xef, 0xbd, 0x60, 0xeb, 0xb2, 0x48, 0x1a,
-            0xf8, 0x85, 0x80, 0xf6, 0x16, 0x00,
-        ];
-
-        assert_eq!("net-tools-1.60_p20170221182432", nixpath.name);
-        assert_eq!(nixpath.digest, expected_digest);
-
-        assert_eq!(example_nix_path_str, nixpath.to_string())
-    }
-
-    #[test]
-    fn invalid_hash_length() {
-        StorePath::from_string("00bgd045z0d4icpbc2yy-net-tools-1.60_p20170221182432")
-            .expect_err("No error raised.");
-    }
-
-    #[test]
-    fn invalid_encoding_hash() {
-        StorePath::from_string("00bgd045z0d4icpbc2yyz4gx48aku4la-net-tools-1.60_p20170221182432")
-            .expect_err("No error raised.");
-    }
-
-    #[test]
-    fn more_than_just_the_bare_nix_store_path() {
-        StorePath::from_string(
-            "00bgd045z0d4icpbc2yyz4gx48aku4la-net-tools-1.60_p20170221182432/bin/arp",
-        )
-        .expect_err("No error raised.");
-    }
-
-    #[test]
-    fn no_dash_between_hash_and_name() {
-        StorePath::from_string("00bgd045z0d4icpbc2yyz4gx48ak44lanet-tools-1.60_p20170221182432")
-            .expect_err("No error raised.");
-    }
-
-    #[test]
-    fn absolute_path() {
-        let example_nix_path_str =
-            "00bgd045z0d4icpbc2yyz4gx48ak44la-net-tools-1.60_p20170221182432";
-        let nixpath_expected = StorePath::from_string(example_nix_path_str).expect("must parse");
-
-        let nixpath_actual = StorePath::from_absolute_path(
-            "/nix/store/00bgd045z0d4icpbc2yyz4gx48ak44la-net-tools-1.60_p20170221182432",
-        )
-        .expect("must parse");
-
-        assert_eq!(nixpath_expected, nixpath_actual);
-
-        assert_eq!(
-            "/nix/store/00bgd045z0d4icpbc2yyz4gx48ak44la-net-tools-1.60_p20170221182432",
-            nixpath_actual.to_absolute_path(),
-        );
-    }
-
-    #[test]
-    fn absolute_path_missing_prefix() {
-        assert_eq!(
-            ParseStorePathError::MissingStoreDir(),
-            StorePath::from_absolute_path("foobar-123").expect_err("must fail")
-        );
-    }
-}