From 58f474041ec18551b8e77b25f8c92e9347784f76 Mon Sep 17 00:00:00 2001
From: Florian Klink <flokli@flokli.de>
Date: Sat, 10 Feb 2024 16:04:31 +0100
Subject: refactor(tvix/glue/KnownPaths): track Derivation struct too

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>
---
 tvix/glue/src/known_paths.rs | 67 ++++++++++++++++++++++++++++++++++----------
 1 file changed, 52 insertions(+), 15 deletions(-)

(limited to 'tvix/glue/src/known_paths.rs')

diff --git a/tvix/glue/src/known_paths.rs b/tvix/glue/src/known_paths.rs
index 626b320ed5..d3059da4ad 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"
                 );
             }
-- 
cgit 1.4.1