refactor(tvix/build): remove proto::BuildRequest::validate r/8831

Change-Id: I96fa98946bf6aff5eedcb220e2b6b3d90c204eec
Reviewed-on: https://cl.tvl.fyi/c/depot/+/12633
Reviewed-by: flokli <flokli@flokli.de>
Tested-by: BuildkiteCI

2 files changed, 4 insertions, 108 deletions

diff --git a/tvix/build/src/buildservice/build_request.rs b/tvix/build/src/buildservice/build_request.rs
index a93fef5b393c..78409c34e3b2 100644
--- a/tvix/build/src/buildservice/build_request.rs
+++ b/tvix/build/src/buildservice/build_request.rs
@@ -35,7 +35,7 @@ use tvix_castore::{Node, PathComponent};
 ///
 /// As of now, we're okay to accept this, but it prevents uploading an
 /// entirely-non-IFD subgraph of BuildRequests eagerly.
-#[derive(Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct BuildRequest {
     /// The list of all root nodes that should be visible in `inputs_dir` at the
     /// time of the build.
@@ -94,7 +94,7 @@ pub struct BuildRequest {
     pub refscan_needles: Vec<String>,
 }
 
-#[derive(Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct EnvVar {
     /// name of the environment variable. Must not contain =.
     pub key: String,
@@ -105,7 +105,7 @@ pub struct EnvVar {
 /// Constraints can be things like required architecture and minimum amount of memory.
 /// The required input paths are *not* represented in here, because it
 /// wouldn't be hermetic enough - see the comment around inputs too.
-#[derive(Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum BuildConstraints {
     /// The system that's needed to execute the build.
     /// Must not be empty.
@@ -124,7 +124,7 @@ pub enum BuildConstraints {
     ProvideBinSh,
 }
 
-#[derive(Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct AdditionalFile {
     pub path: PathBuf,
     pub contents: Bytes,
diff --git a/tvix/build/src/proto/mod.rs b/tvix/build/src/proto/mod.rs
index 97d56c6e625d..e6c94f5b56c9 100644
--- a/tvix/build/src/proto/mod.rs
+++ b/tvix/build/src/proto/mod.rs
@@ -118,90 +118,6 @@ where
     data.tuple_windows().all(|(a, b)| a <= b)
 }
 
-impl BuildRequest {
-    /// Ensures the build request is valid.
-    /// This means, all input nodes need to be valid, paths in lists need to be sorted,
-    /// and all restrictions around paths themselves (relative, clean, …) need
-    // to be fulfilled.
-    pub fn validate(&self) -> Result<(), ValidateBuildRequestError> {
-        // validate names. Make sure they're sorted
-
-        let mut last_name: bytes::Bytes = "".into();
-        for (i, node) in self.inputs.iter().enumerate() {
-            // TODO(flokli): store result somewhere
-            let (name, _node) = node
-                .clone()
-                .into_name_and_node()
-                .map_err(|e| ValidateBuildRequestError::InvalidInputNode(i, e))?;
-
-            if name.as_ref() <= last_name.as_ref() {
-                return Err(ValidateBuildRequestError::InputNodesNotSorted);
-            } else {
-                last_name = name.into()
-            }
-        }
-
-        // validate working_dir
-        if !is_clean_relative_path(&self.working_dir) {
-            Err(ValidateBuildRequestError::InvalidWorkingDir)?;
-        }
-
-        // validate scratch paths
-        for (i, p) in self.scratch_paths.iter().enumerate() {
-            if !is_clean_relative_path(p) {
-                Err(ValidateBuildRequestError::InvalidScratchPath(i))?
-            }
-        }
-        if !is_sorted(self.scratch_paths.iter().map(|e| e.as_bytes())) {
-            Err(ValidateBuildRequestError::ScratchPathsNotSorted)?;
-        }
-
-        // validate inputs_dir
-        if !is_clean_relative_path(&self.inputs_dir) {
-            Err(ValidateBuildRequestError::InvalidInputsDir)?;
-        }
-
-        // validate outputs
-        for (i, p) in self.outputs.iter().enumerate() {
-            if !is_clean_relative_path(p) {
-                Err(ValidateBuildRequestError::InvalidOutputPath(i))?
-            }
-        }
-        if !is_sorted(self.outputs.iter().map(|e| e.as_bytes())) {
-            Err(ValidateBuildRequestError::OutputsNotSorted)?;
-        }
-
-        // validate environment_vars.
-        for (i, e) in self.environment_vars.iter().enumerate() {
-            if e.key.is_empty() || e.key.contains('=') {
-                Err(ValidateBuildRequestError::InvalidEnvVar(i))?
-            }
-        }
-        if !is_sorted(self.environment_vars.iter().map(|e| e.key.as_bytes())) {
-            Err(ValidateBuildRequestError::EnvVarNotSorted)?;
-        }
-
-        // validate build constraints
-        if let Some(constraints) = self.constraints.as_ref() {
-            constraints
-                .validate()
-                .map_err(ValidateBuildRequestError::InvalidBuildConstraints)?;
-        }
-
-        // validate additional_files
-        for (i, additional_file) in self.additional_files.iter().enumerate() {
-            if !is_clean_relative_path(&additional_file.path) {
-                Err(ValidateBuildRequestError::InvalidAdditionalFilePath(i))?
-            }
-        }
-        if !is_sorted(self.additional_files.iter().map(|e| e.path.as_bytes())) {
-            Err(ValidateBuildRequestError::AdditionalFilesNotSorted)?;
-        }
-
-        Ok(())
-    }
-}
-
 impl TryFrom<BuildRequest> for crate::buildservice::BuildRequest {
     type Error = ValidateBuildRequestError;
     fn try_from(value: BuildRequest) -> Result<Self, Self::Error> {
@@ -311,26 +227,6 @@ pub enum ValidateBuildConstraintsError {
     AvailableRoPathsNotSorted,
 }
 
-impl build_request::BuildConstraints {
-    pub fn validate(&self) -> Result<(), ValidateBuildConstraintsError> {
-        // validate system
-        if self.system.is_empty() {
-            Err(ValidateBuildConstraintsError::InvalidSystem)?;
-        }
-        // validate available_ro_paths
-        for (i, p) in self.available_ro_paths.iter().enumerate() {
-            if !is_clean_absolute_path(p) {
-                Err(ValidateBuildConstraintsError::InvalidAvailableRoPaths(i))?
-            }
-        }
-        if !is_sorted(self.available_ro_paths.iter().map(|e| e.as_bytes())) {
-            Err(ValidateBuildConstraintsError::AvailableRoPathsNotSorted)?;
-        }
-
-        Ok(())
-    }
-}
-
 impl From<build_request::EnvVar> for crate::buildservice::EnvVar {
     fn from(value: build_request::EnvVar) -> Self {
         Self {