diff options
Diffstat (limited to 'tvix/nix-compat/src')
| -rw-r--r-- | tvix/nix-compat/src/lib.rs | 1 | ||||
| -rw-r--r-- | tvix/nix-compat/src/nixhash.rs | 110 | ||||
| -rw-r--r-- | tvix/nix-compat/src/nixhash_with_mode.rs | 111 |
3 files changed, 114 insertions, 108 deletions
diff --git a/tvix/nix-compat/src/lib.rs b/tvix/nix-compat/src/lib.rs index 40237f94c2cd..5aea5e242f25 100644 --- a/tvix/nix-compat/src/lib.rs +++ b/tvix/nix-compat/src/lib.rs @@ -4,6 +4,7 @@ pub mod derivation; pub mod nar; pub mod nixbase32; pub mod nixhash; +mod nixhash_with_mode; pub mod store_path; /// Nix placeholders (i.e. values returned by `builtins.placeholder`) diff --git a/tvix/nix-compat/src/nixhash.rs b/tvix/nix-compat/src/nixhash.rs index 0da90fe4ccf5..69ed98ff962e 100644 --- a/tvix/nix-compat/src/nixhash.rs +++ b/tvix/nix-compat/src/nixhash.rs @@ -1,117 +1,11 @@ use data_encoding::{BASE64, BASE64_NOPAD, HEXLOWER}; -use serde::ser::SerializeMap; -use serde::{Deserialize, Deserializer, Serialize, Serializer}; +use serde::{Deserialize, Serialize}; use std::fmt::Display; use thiserror::Error; use crate::nixbase32; -/// A Nix Hash can either be flat or recursive. -#[derive(Clone, Debug, Eq, PartialEq)] -pub enum NixHashWithMode { - Flat(NixHash), - Recursive(NixHash), -} - -impl NixHashWithMode { - /// 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()), - } - } -} - -impl Serialize for NixHashWithMode { - /// map a NixHashWithMode into the serde data model. - fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> - where - S: Serializer, - { - let mut map = serializer.serialize_map(Some(2))?; - match self { - NixHashWithMode::Flat(h) => { - map.serialize_entry("hash", &nixbase32::encode(&h.digest))?; - map.serialize_entry("hashAlgo", &h.algo.to_string())?; - } - NixHashWithMode::Recursive(h) => { - map.serialize_entry("hash", &nixbase32::encode(&h.digest))?; - map.serialize_entry("hashAlgo", &format!("r:{}", &h.algo.to_string()))?; - } - }; - map.end() - } -} - -impl<'de> Deserialize<'de> for NixHashWithMode { - /// map the serde data model into a NixHashWithMode. - /// - /// The serde data model has a `hash` field (containing a digest in nixbase32), - /// and a `hashAlgo` field, containing the stringified hash algo. - /// In case the hash is recursive, hashAlgo also has a `r:` prefix. - /// - /// This is to match how `nix show-derivation` command shows them in JSON - /// representation. - fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> - where - D: Deserializer<'de>, - { - // TODO: don't use serde_json here? - // TODO: serde seems to simply set `hash_with_mode` to None if hash - // and hashAlgo fail, but that should be a proper deserialization error - // that should be propagated to the user! - - let json = serde_json::Value::deserialize(deserializer)?; - match json.as_object() { - None => Err(serde::de::Error::custom("couldn't parse as map"))?, - Some(map) => { - let digest: Vec<u8> = { - if let Some(v) = map.get("hash") { - if let Some(s) = v.as_str() { - data_encoding::HEXLOWER - .decode(s.as_bytes()) - .map_err(|e| serde::de::Error::custom(e.to_string()))? - } else { - return Err(serde::de::Error::custom( - "couldn't parse 'hash' as string", - )); - } - } else { - return Err(serde::de::Error::custom("couldn't extract 'hash' key")); - } - }; - - if let Some(v) = map.get("hashAlgo") { - if let Some(s) = v.as_str() { - match s.strip_prefix("r:") { - Some(rest) => Ok(NixHashWithMode::Recursive(NixHash::new( - HashAlgo::try_from(rest).map_err(|e| { - serde::de::Error::custom(format!("unable to parse algo: {}", e)) - })?, - digest, - ))), - None => Ok(NixHashWithMode::Flat(NixHash::new( - HashAlgo::try_from(s).map_err(|e| { - serde::de::Error::custom(format!("unable to parse algo: {}", e)) - })?, - digest, - ))), - } - } else { - Err(serde::de::Error::custom( - "couldn't parse 'hashAlgo' as string", - )) - } - } else { - Err(serde::de::Error::custom("couldn't extract 'hashAlgo' key")) - } - } - } - } -} +pub use crate::nixhash_with_mode::NixHashWithMode; /// Nix allows specifying hashes in various encodings, and magically just /// derives the encoding. diff --git a/tvix/nix-compat/src/nixhash_with_mode.rs b/tvix/nix-compat/src/nixhash_with_mode.rs new file mode 100644 index 000000000000..e895f0c62704 --- /dev/null +++ b/tvix/nix-compat/src/nixhash_with_mode.rs @@ -0,0 +1,111 @@ +use crate::nixbase32; +use crate::nixhash::{HashAlgo, NixHash}; +use serde::ser::SerializeMap; +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +/// A Nix Hash can either be flat or recursive. +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum NixHashWithMode { + Flat(NixHash), + Recursive(NixHash), +} + +impl NixHashWithMode { + /// 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()), + } + } +} + +impl Serialize for NixHashWithMode { + /// map a NixHashWithMode into the serde data model. + fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + let mut map = serializer.serialize_map(Some(2))?; + match self { + NixHashWithMode::Flat(h) => { + map.serialize_entry("hash", &nixbase32::encode(&h.digest))?; + map.serialize_entry("hashAlgo", &h.algo.to_string())?; + } + NixHashWithMode::Recursive(h) => { + map.serialize_entry("hash", &nixbase32::encode(&h.digest))?; + map.serialize_entry("hashAlgo", &format!("r:{}", &h.algo.to_string()))?; + } + }; + map.end() + } +} + +impl<'de> Deserialize<'de> for NixHashWithMode { + /// map the serde data model into a NixHashWithMode. + /// + /// The serde data model has a `hash` field (containing a digest in nixbase32), + /// and a `hashAlgo` field, containing the stringified hash algo. + /// In case the hash is recursive, hashAlgo also has a `r:` prefix. + /// + /// This is to match how `nix show-derivation` command shows them in JSON + /// representation. + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> + where + D: Deserializer<'de>, + { + // TODO: don't use serde_json here? + // TODO: serde seems to simply set `hash_with_mode` to None if hash + // and hashAlgo fail, but that should be a proper deserialization error + // that should be propagated to the user! + + let json = serde_json::Value::deserialize(deserializer)?; + match json.as_object() { + None => Err(serde::de::Error::custom("couldn't parse as map"))?, + Some(map) => { + let digest: Vec<u8> = { + if let Some(v) = map.get("hash") { + if let Some(s) = v.as_str() { + data_encoding::HEXLOWER + .decode(s.as_bytes()) + .map_err(|e| serde::de::Error::custom(e.to_string()))? + } else { + return Err(serde::de::Error::custom( + "couldn't parse 'hash' as string", + )); + } + } else { + return Err(serde::de::Error::custom("couldn't extract 'hash' key")); + } + }; + + if let Some(v) = map.get("hashAlgo") { + if let Some(s) = v.as_str() { + match s.strip_prefix("r:") { + Some(rest) => Ok(NixHashWithMode::Recursive(NixHash::new( + HashAlgo::try_from(rest).map_err(|e| { + serde::de::Error::custom(format!("unable to parse algo: {}", e)) + })?, + digest, + ))), + None => Ok(NixHashWithMode::Flat(NixHash::new( + HashAlgo::try_from(s).map_err(|e| { + serde::de::Error::custom(format!("unable to parse algo: {}", e)) + })?, + digest, + ))), + } + } else { + Err(serde::de::Error::custom( + "couldn't parse 'hashAlgo' as string", + )) + } + } else { + Err(serde::de::Error::custom("couldn't extract 'hashAlgo' key")) + } + } + } + } +} |