diff options
author | Florian Klink <flokli@flokli.de> | 2024-02-10T15·04+0100 |
---|---|---|
committer | flokli <flokli@flokli.de> | 2024-02-17T04·49+0000 |
commit | 58f474041ec18551b8e77b25f8c92e9347784f76 (patch) | |
tree | cd54710da27eda51f6a12013eb26300492e968d8 /tvix/glue/src/known_paths.rs | |
parent | e7815945df66b2893e0c424169dde8ddbeb0efe3 (diff) |
refactor(tvix/glue/KnownPaths): track Derivation struct too r/7534
We need to not only store a map from drv path to hash derivation modulo, but also keep the original Derivation struct - because we'll use that later to trigger builds. Change-Id: I78e2e8431ab5ae853188866b797a79025200de98 Reviewed-on: https://cl.tvl.fyi/c/depot/+/10790 Tested-by: BuildkiteCI Reviewed-by: raitobezarius <tvl@lahfa.xyz>
Diffstat (limited to '')
-rw-r--r-- | tvix/glue/src/known_paths.rs | 67 |
1 files changed, 52 insertions, 15 deletions
diff --git a/tvix/glue/src/known_paths.rs b/tvix/glue/src/known_paths.rs index 626b320ed515..d3059da4ad7d 100644 --- a/tvix/glue/src/known_paths.rs +++ b/tvix/glue/src/known_paths.rs @@ -8,40 +8,77 @@ //! This data is required to find the derivation needed to actually trigger the //! build, if necessary. -use nix_compat::{nixhash::NixHash, store_path::StorePath}; +use nix_compat::{ + derivation::Derivation, + nixhash::NixHash, + store_path::{StorePath, StorePathRef}, +}; use std::collections::HashMap; +/// Struct keeping track of all known Derivations in the current evaluation. +/// This keeps both the Derivation struct, as well as the "Hash derivation +/// modulo". #[derive(Debug, Default)] pub struct KnownPaths { /// All known derivation or FOD hashes. /// - /// Keys are derivation paths, values is the NixHash. - derivation_or_fod_hashes: HashMap<StorePath, NixHash>, + /// Keys are derivation paths, values are a tuple of the "hash derivation + /// modulo" and the Derivation struct itself. + derivations: HashMap<StorePath, (NixHash, Derivation)>, } impl KnownPaths { /// Fetch the opaque "hash derivation modulo" for a given derivation path. - pub fn get_hash_derivation_modulo(&self, drv_path: &StorePath) -> NixHash { - // TODO: we rely on an invariant that things *should* have - // been calculated if we get this far. - self.derivation_or_fod_hashes[drv_path].clone() + pub fn get_hash_derivation_modulo(&self, drv_path: &StorePathRef) -> Option<&NixHash> { + self.derivations + .get(&drv_path.to_owned()) + .map(|(hash_derivation_modulo, _derivation)| hash_derivation_modulo) } - pub fn add_hash_derivation_modulo( - &mut self, - drv_path: StorePath, - hash_derivation_modulo: &NixHash, - ) { + /// Return a reference to the Derivation for a given drv path. + pub fn get_drv_by_drvpath(&self, drv_path: &StorePath) -> Option<&Derivation> { + self.derivations + .get(drv_path) + .map(|(_hash_derivation_modulo, derivation)| derivation) + } + + /// Insert a new Derivation into this struct. + /// The Derivation struct must pass validation, and its output paths need to + /// be fully calculated. + /// All input derivations this refers to must also be inserted to this + /// struct. + pub fn add(&mut self, drv_path: StorePath, drv: Derivation) { + // check input derivations to have been inserted. + #[cfg(debug_assertions)] + { + // TODO: b/264 + // We assume derivations to be passed validated, so ignoring rest + // and expecting parsing is ok. + for input_drv_path_str in drv.input_derivations.keys() { + let (input_drv_path, _rest) = + StorePath::from_absolute_path_full(input_drv_path_str) + .expect("parse input drv path"); + debug_assert!(self.derivations.contains_key(&input_drv_path)); + } + } + + // compute the hash derivation modulo + let hash_derivation_modulo = drv.derivation_or_fod_hash(|drv_path| { + self.get_hash_derivation_modulo(drv_path) + .unwrap_or_else(|| panic!("{} not found", drv_path)) + .to_owned() + }); + #[allow(unused_variables)] // assertions on this only compiled in debug builds let old = self - .derivation_or_fod_hashes - .insert(drv_path, hash_derivation_modulo.to_owned()); + .derivations + .insert(drv_path.to_owned(), (hash_derivation_modulo.clone(), drv)); #[cfg(debug_assertions)] { if let Some(old) = old { debug_assert!( - old == *hash_derivation_modulo, + old.0 == hash_derivation_modulo, "hash derivation modulo for a given derivation should always be calculated the same" ); } |