feat(tvix/store): add NARCalculationService trait and impl r/5918

This adds a NARCalculationService trait, which will take a root node,
and provide a proto::CalculateNarResponse in return.

It also adds a NonCachingNARCalculationService implementation, that will
simply always render the NAR in memory to calculate the size and sha256,
without any caching.

Change-Id: Id1ffb18559212fa6001f70f2634bbc3dfd0aa343
Reviewed-on: https://cl.tvl.fyi/c/depot/+/8096
Reviewed-by: raitobezarius <tvl@lahfa.xyz>
Tested-by: BuildkiteCI

2 files changed, 61 insertions, 0 deletions

diff --git a/tvix/store/src/nar/mod.rs b/tvix/store/src/nar/mod.rs
index a3a8677d92..d9e0c8143b 100644
--- a/tvix/store/src/nar/mod.rs
+++ b/tvix/store/src/nar/mod.rs
@@ -1,8 +1,11 @@
+use crate::proto;
 use data_encoding::BASE64;
 use thiserror::Error;
 
+mod non_caching_calculation_service;
 mod renderer;
 
+pub use non_caching_calculation_service::NonCachingNARCalculationService;
 pub use renderer::NARRenderer;
 
 /// Errors that can encounter while rendering NARs.
@@ -23,3 +26,11 @@ pub enum RenderError {
     #[error("failure using the NAR writer: {0}")]
     NARWriterError(std::io::Error),
 }
+
+/// The base trait for something calculating NARs, and returning their size and sha256.
+pub trait NARCalculationService {
+    fn calculate_nar(
+        &self,
+        root_node: proto::node::Node,
+    ) -> Result<proto::CalculateNarResponse, RenderError>;
+}
diff --git a/tvix/store/src/nar/non_caching_calculation_service.rs b/tvix/store/src/nar/non_caching_calculation_service.rs
new file mode 100644
index 0000000000..880d126369
--- /dev/null
+++ b/tvix/store/src/nar/non_caching_calculation_service.rs
@@ -0,0 +1,50 @@
+use count_write::CountWrite;
+use sha2::{Digest, Sha256};
+
+use crate::blobservice::BlobService;
+use crate::chunkservice::ChunkService;
+use crate::directoryservice::DirectoryService;
+use crate::proto;
+
+use super::renderer::NARRenderer;
+use super::{NARCalculationService, RenderError};
+
+/// A NAR calculation service which simply renders the whole NAR whenever
+/// we ask for the calculation.
+#[derive(Clone)]
+pub struct NonCachingNARCalculationService<
+    BS: BlobService,
+    CS: ChunkService + Clone,
+    DS: DirectoryService,
+> {
+    nar_renderer: NARRenderer<BS, CS, DS>,
+}
+
+impl<BS: BlobService, CS: ChunkService + Clone, DS: DirectoryService>
+    NonCachingNARCalculationService<BS, CS, DS>
+{
+    pub fn new(blob_service: BS, chunk_service: CS, directory_service: DS) -> Self {
+        Self {
+            nar_renderer: NARRenderer::new(blob_service, chunk_service, directory_service),
+        }
+    }
+}
+
+impl<BS: BlobService, CS: ChunkService + Clone, DS: DirectoryService> NARCalculationService
+    for NonCachingNARCalculationService<BS, CS, DS>
+{
+    fn calculate_nar(
+        &self,
+        root_node: proto::node::Node,
+    ) -> Result<proto::CalculateNarResponse, RenderError> {
+        let h = Sha256::new();
+        let mut cw = CountWrite::from(h);
+
+        self.nar_renderer.write_nar(&mut cw, root_node)?;
+
+        Ok(proto::CalculateNarResponse {
+            nar_size: cw.count() as u32,
+            nar_sha256: cw.into_inner().finalize().to_vec(),
+        })
+    }
+}