snix_glue/
known_paths.rs

1//! This module implements logic required for persisting known paths
2//! during an evaluation.
3//!
4//! Snix needs to be able to keep track of each Nix store path that it
5//! knows about during the scope of a single evaluation and its
6//! related builds.
7//!
8//! This data is required to find the derivation needed to actually trigger the
9//! build, if necessary.
10
11use nix_compat::{
12    derivation::Derivation,
13    store_path::{BuildStorePathError, StorePath, StorePathRef},
14};
15use std::collections::HashMap;
16
17use crate::fetchers::Fetch;
18
19/// Struct keeping track of all known Derivations in the current evaluation.
20/// This keeps both the Derivation struct, as well as the "Hash derivation
21/// modulo".
22#[derive(Debug, Default)]
23pub struct KnownPaths {
24    /// All known derivation or FOD hashes.
25    ///
26    /// Keys are derivation paths, values are a tuple of the "hash derivation
27    /// modulo" and the Derivation struct itself.
28    derivations: HashMap<StorePath<String>, ([u8; 32], Derivation)>,
29
30    /// A map from output path to (one) drv path.
31    /// Note that in the case of FODs, multiple drvs can produce the same output
32    /// path. We use one of them.
33    outputs_to_drvpath: HashMap<StorePath<String>, StorePath<String>>,
34
35    /// A map from output path to fetches (and their names).
36    outputs_to_fetches: HashMap<StorePath<String>, (String, Fetch)>,
37}
38
39impl KnownPaths {
40    /// Fetch the opaque "hash derivation modulo" for a given derivation path.
41    pub fn get_hash_derivation_modulo(&self, drv_path: &StorePath<String>) -> Option<&[u8; 32]> {
42        self.derivations
43            .get(drv_path)
44            .map(|(hash_derivation_modulo, _derivation)| hash_derivation_modulo)
45    }
46
47    /// Return a reference to the Derivation for a given drv path.
48    pub fn get_drv_by_drvpath(&self, drv_path: &StorePath<String>) -> Option<&Derivation> {
49        self.derivations
50            .get(drv_path)
51            .map(|(_hash_derivation_modulo, derivation)| derivation)
52    }
53
54    /// Return the drv path of the derivation producing the passed output path.
55    /// Note there can be multiple Derivations producing the same output path in
56    /// flight; this function will only return one of them.
57    pub fn get_drv_path_for_output_path(
58        &self,
59        output_path: &StorePath<String>,
60    ) -> Option<&StorePath<String>> {
61        self.outputs_to_drvpath.get(output_path)
62    }
63
64    /// Insert a new [Derivation] into this struct.
65    /// The Derivation struct must pass validation, and its output paths need to
66    /// be fully calculated.
67    /// All input derivations this refers to must also be inserted to this
68    /// struct.
69    pub fn add_derivation(&mut self, drv_path: StorePath<String>, drv: Derivation) {
70        // check input derivations to have been inserted.
71        #[cfg(debug_assertions)]
72        {
73            for input_drv_path in drv.input_derivations.keys() {
74                debug_assert!(self.derivations.contains_key(input_drv_path));
75            }
76        }
77
78        // compute the hash derivation modulo
79        let hash_derivation_modulo = drv.hash_derivation_modulo(|drv_path| {
80            self.get_hash_derivation_modulo(&drv_path.to_owned())
81                .unwrap_or_else(|| panic!("{} not found", drv_path))
82                .to_owned()
83        });
84
85        // For all output paths, update our lookup table.
86        // We only write into the lookup table once.
87        for output in drv.outputs.values() {
88            self.outputs_to_drvpath
89                .entry(output.path.as_ref().expect("missing store path").clone())
90                .or_insert(drv_path.to_owned());
91        }
92
93        // insert the derivation itself
94        #[allow(unused_variables)] // assertions on this only compiled in debug builds
95        let old = self
96            .derivations
97            .insert(drv_path.to_owned(), (hash_derivation_modulo, drv));
98
99        #[cfg(debug_assertions)]
100        {
101            if let Some(old) = old {
102                debug_assert!(
103                    old.0 == hash_derivation_modulo,
104                    "hash derivation modulo for a given derivation should always be calculated the same"
105                );
106            }
107        }
108    }
109
110    /// Insert a new [Fetch] into this struct, which *must* have an expected
111    /// hash (otherwise we wouldn't be able to calculate the store path).
112    /// Fetches without a known hash need to be fetched inside builtins.
113    pub fn add_fetch<'a>(
114        &mut self,
115        fetch: Fetch,
116        name: &'a str,
117    ) -> Result<StorePathRef<'a>, BuildStorePathError> {
118        let store_path = fetch
119            .store_path(name)?
120            .expect("Snix bug: fetch must have an expected hash");
121        // insert the fetch.
122        self.outputs_to_fetches
123            .insert(store_path.to_owned(), (name.to_owned(), fetch));
124
125        Ok(store_path)
126    }
127
128    /// Return the name and fetch producing the passed output path.
129    /// Note there can also be (multiple) Derivations producing the same output path.
130    pub fn get_fetch_for_output_path(
131        &self,
132        output_path: &StorePath<String>,
133    ) -> Option<(String, Fetch)> {
134        self.outputs_to_fetches
135            .get(output_path)
136            .map(|(name, fetch)| (name.to_owned(), fetch.to_owned()))
137    }
138
139    /// Returns an iterator over all known derivations and their store path.
140    pub fn get_derivations(&self) -> impl Iterator<Item = (&StorePath<String>, &Derivation)> {
141        self.derivations.iter().map(|(k, v)| (k, &v.1))
142    }
143}
144
145#[cfg(test)]
146mod tests {
147    use std::sync::LazyLock;
148
149    use hex_literal::hex;
150    use nix_compat::{derivation::Derivation, nixbase32, nixhash::NixHash, store_path::StorePath};
151    use url::Url;
152
153    use super::KnownPaths;
154    use crate::fetchers::Fetch;
155
156    static BAR_DRV: LazyLock<Derivation> = LazyLock::new(|| {
157        Derivation::from_aterm_bytes(include_bytes!(
158            "tests/ss2p4wmxijn652haqyd7dckxwl4c7hxx-bar.drv"
159        ))
160        .expect("must parse")
161    });
162
163    static FOO_DRV: LazyLock<Derivation> = LazyLock::new(|| {
164        Derivation::from_aterm_bytes(include_bytes!(
165            "tests/ch49594n9avinrf8ip0aslidkc4lxkqv-foo.drv"
166        ))
167        .expect("must parse")
168    });
169
170    static BAR_DRV_PATH: LazyLock<StorePath<String>> = LazyLock::new(|| {
171        StorePath::from_bytes(b"ss2p4wmxijn652haqyd7dckxwl4c7hxx-bar.drv").expect("must parse")
172    });
173
174    static FOO_DRV_PATH: LazyLock<StorePath<String>> = LazyLock::new(|| {
175        StorePath::from_bytes(b"ch49594n9avinrf8ip0aslidkc4lxkqv-foo.drv").expect("must parse")
176    });
177
178    static BAR_OUT_PATH: LazyLock<StorePath<String>> = LazyLock::new(|| {
179        StorePath::from_bytes(b"mp57d33657rf34lzvlbpfa1gjfv5gmpg-bar").expect("must parse")
180    });
181
182    static FOO_OUT_PATH: LazyLock<StorePath<String>> = LazyLock::new(|| {
183        StorePath::from_bytes(b"fhaj6gmwns62s6ypkcldbaj2ybvkhx3p-foo").expect("must parse")
184    });
185
186    static FETCH_URL: LazyLock<Fetch> = LazyLock::new(|| {
187        Fetch::URL {
188        url: Url::parse("https://raw.githubusercontent.com/aaptel/notmuch-extract-patch/f732a53e12a7c91a06755ebfab2007adc9b3063b/notmuch-extract-patch").unwrap(),
189        exp_hash: Some(NixHash::from_sri("sha256-Xa1Jbl2Eq5+L0ww+Ph1osA3Z/Dxe/RkN1/dITQCdXFk=").unwrap())
190    }
191    });
192
193    static FETCH_URL_OUT_PATH: LazyLock<StorePath<String>> = LazyLock::new(|| {
194        StorePath::from_bytes(b"06qi00hylriyfm0nl827crgjvbax84mz-notmuch-extract-patch").unwrap()
195    });
196
197    static FETCH_TARBALL: LazyLock<Fetch> = LazyLock::new(|| {
198        Fetch::Tarball {
199        url: Url::parse("https://github.com/NixOS/nixpkgs/archive/91050ea1e57e50388fa87a3302ba12d188ef723a.tar.gz").unwrap(),
200        exp_nar_sha256: Some(nixbase32::decode_fixed("1hf6cgaci1n186kkkjq106ryf8mmlq9vnwgfwh625wa8hfgdn4dm").unwrap())
201    }
202    });
203
204    static FETCH_TARBALL_OUT_PATH: LazyLock<StorePath<String>> = LazyLock::new(|| {
205        StorePath::from_bytes(b"7adgvk5zdfq4pwrhsm3n9lzypb12gw0g-source").unwrap()
206    });
207
208    /// Ensure that we don't allow adding a derivation that depends on another,
209    /// not-yet-added derivation.
210    #[test]
211    #[should_panic]
212    fn drv_reject_if_missing_input_drv() {
213        let mut known_paths = KnownPaths::default();
214
215        // FOO_DRV depends on BAR_DRV, which wasn't added.
216        known_paths.add_derivation(FOO_DRV_PATH.clone(), FOO_DRV.clone());
217    }
218
219    #[test]
220    fn drv_happy_path() {
221        let mut known_paths = KnownPaths::default();
222
223        // get_drv_by_drvpath should return None for non-existing Derivations,
224        // same as get_hash_derivation_modulo and get_drv_path_for_output_path
225        assert_eq!(None, known_paths.get_drv_by_drvpath(&BAR_DRV_PATH));
226        assert_eq!(None, known_paths.get_hash_derivation_modulo(&BAR_DRV_PATH));
227        assert_eq!(
228            None,
229            known_paths.get_drv_path_for_output_path(&BAR_OUT_PATH)
230        );
231
232        // Add BAR_DRV
233        known_paths.add_derivation(BAR_DRV_PATH.clone(), BAR_DRV.clone());
234
235        // We should get it back
236        assert_eq!(
237            Some(&BAR_DRV.clone()),
238            known_paths.get_drv_by_drvpath(&BAR_DRV_PATH)
239        );
240
241        // Test get_drv_path_for_output_path
242        assert_eq!(
243            Some(&BAR_DRV_PATH.clone()),
244            known_paths.get_drv_path_for_output_path(&BAR_OUT_PATH)
245        );
246
247        // It should be possible to get the hash derivation modulo.
248        assert_eq!(
249            Some(&hex!(
250                "c79aebd0ce3269393d4a1fde2cbd1d975d879b40f0bf40a48f550edc107fd5df"
251            )),
252            known_paths.get_hash_derivation_modulo(&BAR_DRV_PATH.clone())
253        );
254
255        // Now insert FOO_DRV too. It shouldn't panic, as BAR_DRV is already
256        // added.
257        known_paths.add_derivation(FOO_DRV_PATH.clone(), FOO_DRV.clone());
258
259        assert_eq!(
260            Some(&FOO_DRV.clone()),
261            known_paths.get_drv_by_drvpath(&FOO_DRV_PATH)
262        );
263        assert_eq!(
264            Some(&hex!(
265                "af030d36d63d3d7f56a71adaba26b36f5fa1f9847da5eed953ed62e18192762f"
266            )),
267            known_paths.get_hash_derivation_modulo(&FOO_DRV_PATH.clone())
268        );
269
270        // Test get_drv_path_for_output_path
271        assert_eq!(
272            Some(&FOO_DRV_PATH.clone()),
273            known_paths.get_drv_path_for_output_path(&FOO_OUT_PATH)
274        );
275    }
276
277    #[test]
278    fn fetch_happy_path() {
279        let mut known_paths = KnownPaths::default();
280
281        // get_fetch_for_output_path should return None for new fetches.
282        assert!(
283            known_paths
284                .get_fetch_for_output_path(&FETCH_TARBALL_OUT_PATH)
285                .is_none()
286        );
287
288        // add_fetch should return the properly calculated store paths.
289        assert_eq!(
290            *FETCH_TARBALL_OUT_PATH,
291            known_paths
292                .add_fetch(FETCH_TARBALL.clone(), "source")
293                .unwrap()
294                .to_owned()
295        );
296
297        assert_eq!(
298            *FETCH_URL_OUT_PATH,
299            known_paths
300                .add_fetch(FETCH_URL.clone(), "notmuch-extract-patch")
301                .unwrap()
302                .to_owned()
303        );
304    }
305
306    #[test]
307    fn get_derivations_working() {
308        let mut known_paths = KnownPaths::default();
309
310        // Add BAR_DRV
311        known_paths.add_derivation(BAR_DRV_PATH.clone(), BAR_DRV.clone());
312
313        // We should be able to find BAR_DRV_PATH and BAR_DRV as a pair in get_derivations.
314        assert_eq!(
315            Some((&BAR_DRV_PATH.clone(), &BAR_DRV.clone())),
316            known_paths
317                .get_derivations()
318                .find(|(s, d)| (*s, *d) == (&BAR_DRV_PATH, &BAR_DRV))
319        );
320    }
321
322    // TODO: add test panicking about missing digest
323}
snix_glue/known_paths.rs

snix_glue/
known_paths.rs
