Wire up all callsites that need to account for content-based hashes and leave TODOs

Summary: Content-based path hashing requires that you pass in the content-based hash when you want to resolve the path. So, wire up all the callsites that need to do that and add a TODO for them to actually pass in a content-based hash correctly.

Reviewed By: JakobDegen

Differential Revision: D72457374

fbshipit-source-id: fd005eabae4b7831558eee7bc6d9751480cde57b

Author: Ian Childs

app/buck2_action_impl/src/actions/impls/cas_artifact.rs

@@ -291,7 +291,8 @@ impl Action for CasArtifactAction {
             }
         };
 
-        let path = ctx.fs().resolve_build(self.output.get_path())?;
+        // TODO(T219919866) Add support for experimental content-based path hashing
+        let path = ctx.fs().resolve_build(self.output.get_path(), None)?;
         ctx.materializer()
             .declare_cas_many(
                 Arc::new(CasDownloadInfo::new_declared(self.inner.re_use_case)),

app/buck2_action_impl/src/actions/impls/copy.rs

@@ -157,8 +157,9 @@ impl Action for CopyAction {
             .buck_error_context("Input did not dereference to exactly one artifact")?;
 
         let artifact_fs = ctx.fs();
-        let src = input.resolve_path(artifact_fs)?;
-        let dest = artifact_fs.resolve_build(self.output().get_path())?;
+        // TODO(T219919866) Add support for experimental content-based path hashing
+        let src = input.resolve_path(artifact_fs, None)?;
+        let dest = artifact_fs.resolve_build(self.output().get_path(), None)?;
 
         let value = {
             let fs = artifact_fs.fs();

app/buck2_action_impl/src/actions/impls/download_file.rs

@@ -279,7 +279,8 @@ impl Action for DownloadFileAction {
             match self.declared_metadata(&client, ctx.digest_config()).await? {
                 Some(metadata) => {
                     let artifact_fs = ctx.fs();
-                    let rel_path = artifact_fs.resolve_build(self.output().get_path())?;
+                    // TODO(T219919866) Add support for experimental content-based path hashing
+                    let rel_path = artifact_fs.resolve_build(self.output().get_path(), None)?;
 
                     // Fast path: download later via the materializer.
                     ctx.materializer()
@@ -302,7 +303,8 @@ impl Action for DownloadFileAction {
 
                     let artifact_fs = ctx.fs();
                     let project_fs = artifact_fs.fs();
-                    let rel_path = artifact_fs.resolve_build(self.output().get_path())?;
+                    // TODO(T219919866) Add support for experimental content-based path hashing
+                    let rel_path = artifact_fs.resolve_build(self.output().get_path(), None)?;
 
                     // Slow path: download now.
                     let digest = http_download(

app/buck2_action_impl/src/actions/impls/offline.rs

@@ -26,10 +26,11 @@ pub(crate) async fn declare_copy_to_offline_output_cache(
     output: &BuildArtifact,
     value: ArtifactValue,
 ) -> buck2_error::Result<ProjectRelativePathBuf> {
-    let build_path = ctx.fs().resolve_build(output.get_path())?;
+    // TODO(T219919866) Add support for experimental content-based path hashing
+    let build_path = ctx.fs().resolve_build(output.get_path(), None)?;
     let offline_cache_path = ctx
         .fs()
-        .resolve_offline_output_cache_path(output.get_path())?;
+        .resolve_offline_output_cache_path(output.get_path(), None)?;
     declare_copy_materialization(ctx, build_path, offline_cache_path.clone(), value).await?;
 
     Ok(offline_cache_path)
@@ -43,9 +44,10 @@ pub(crate) async fn declare_copy_from_offline_cache(
     ctx: &mut dyn ActionExecutionCtx,
     output: &BuildArtifact,
 ) -> buck2_error::Result<ActionOutputs> {
+    // TODO(T219919866) Add support for experimental content-based path hashing
     let offline_cache_path = ctx
         .fs()
-        .resolve_offline_output_cache_path(output.get_path())?;
+        .resolve_offline_output_cache_path(output.get_path(), None)?;
 
     let (value, _hashing_time) = build_entry_from_disk(
         ctx.fs().fs().resolve(&offline_cache_path),
@@ -69,7 +71,8 @@ pub(crate) async fn declare_copy_from_offline_cache(
         });
     let value = ArtifactValue::from(entry);
 
-    let build_path = ctx.fs().resolve_build(output.get_path())?;
+    // TODO(T219919866) Add support for experimental content-based path hashing
+    let build_path = ctx.fs().resolve_build(output.get_path(), None)?;
     declare_copy_materialization(ctx, offline_cache_path, build_path, value.dupe()).await?;
 
     Ok(ActionOutputs::from_single(output.get_path().dupe(), value))

app/buck2_action_impl/src/actions/impls/run.rs

@@ -43,6 +43,7 @@ use buck2_core::execution_types::executor_config::MetaInternalExtraParams;
 use buck2_core::execution_types::executor_config::RemoteExecutorCustomImage;
 use buck2_core::execution_types::executor_config::RemoteExecutorDependency;
 use buck2_core::fs::artifact_path_resolver::ArtifactFs;
+use buck2_core::fs::buck_out_path::BuckOutPathKind;
 use buck2_core::fs::buck_out_path::BuildArtifactPath;
 use buck2_core::fs::fs_util;
 use buck2_core::fs::paths::forward_rel_path::ForwardRelativePathBuf;
@@ -533,10 +534,14 @@ impl RunAction {
         extra_env: &mut Vec<(String, String)>,
     ) -> buck2_error::Result<()> {
         if let Some(metadata_param) = &self.inner.metadata_param {
-            let path =
-                BuildArtifactPath::new(ctx.target().owner().dupe(), metadata_param.path.clone());
+            let path = BuildArtifactPath::new(
+                ctx.target().owner().dupe(),
+                metadata_param.path.clone(),
+                BuckOutPathKind::default(),
+            );
+            // TODO(T219919866) Add support for experimental content-based path hashing
             let env = cli_ctx
-                .resolve_project_path(fs.buck_out_path_resolver().resolve_gen(&path)?)?
+                .resolve_project_path(fs.buck_out_path_resolver().resolve_gen(&path, None)?)?
                 .into_string();
             let (data, digest) = metadata_content(fs, artifact_inputs, ctx.digest_config())?;
             inputs.push(CommandExecutionInput::ActionMetadata(ActionMetadataBlob {
@@ -628,7 +633,8 @@ impl RunAction {
             .map(|artifact| {
                 artifact
                     .artifact()
-                    .and_then(|a| a.get_path().resolve(ctx.fs()))
+                    // TODO(T219919866) Add support for experimental content-based path hashing
+                    .and_then(|a| a.get_path().resolve(ctx.fs(), None))
             })
             .collect::<buck2_error::Result<Vec<_>>>()?;
 
@@ -868,7 +874,8 @@ impl Action for RunAction {
 
         for x in self.starlark_values.outputs_for_error_handler.iter() {
             let artifact = (*x.artifact()?).dupe().ensure_bound()?.into_artifact();
-            let path = artifact.get_path().resolve(artifact_fs)?;
+            // TODO(T219919866) Add support for experimental content-based path hashing
+            let path = artifact.get_path().resolve(artifact_fs, None)?;
 
             let abs = artifact_fs.fs().resolve(&path);
             // Check if the output file specified exists. We will return an error if it doesn't

app/buck2_action_impl/src/actions/impls/run/dep_files.rs

@@ -772,7 +772,13 @@ async fn outputs_match(
     let output_matches = previous_state
         .result
         .iter()
-        .map(|(path, value)| Ok((fs.buck_out_path_resolver().resolve_gen(path)?, value.dupe())))
+        // TODO(T219919866) Add support for experimental content-based path hashing
+        .map(|(path, value)| {
+            Ok((
+                fs.buck_out_path_resolver().resolve_gen(path, None)?,
+                value.dupe(),
+            ))
+        })
         .collect::<buck2_error::Result<Vec<(ProjectRelativePathBuf, ArtifactValue)>>>()?;
 
     let materializer_accepts = ctx
@@ -1231,7 +1237,8 @@ impl DeclaredDepFiles {
 
         for declared_dep_file in self.tagged.values() {
             let dep_file = &declared_dep_file.output;
-            let path = dep_file.resolve_path(fs).map_err(|e| {
+            // TODO(T219919866) Add support for experimental content-based path hashing
+            let path = dep_file.resolve_path(fs, None).map_err(|e| {
                 MaterializeDepFilesError::MaterializationFailed { source: e.into() }
             })?;
             paths.push(path);
@@ -1276,7 +1283,8 @@ impl DeclaredDepFiles {
         for declared_dep_file in self.tagged.values() {
             let mut selector = DirectorySelector::empty();
 
-            let dep_file = declared_dep_file.output.resolve_path(fs)?;
+            // TODO(T219919866) Add support for experimental content-based path hashing
+            let dep_file = declared_dep_file.output.resolve_path(fs, None)?;
 
             let read_dep_file: buck2_error::Result<()> = try {
                 let dep_file_path = fs.fs().resolve(&dep_file);

app/buck2_action_impl/src/actions/impls/symlinked_dir.rs

@@ -224,7 +224,8 @@ impl Action for SymlinkedDirAction {
         ctx: &mut dyn ActionExecutionCtx,
     ) -> Result<(ActionOutputs, ActionExecutionMetadata), ExecuteError> {
         let fs = ctx.fs().fs();
-        let output = ctx.fs().resolve_build(self.output().get_path())?;
+        // TODO(T219919866) Add support for experimental content-based path hashing
+        let output = ctx.fs().resolve_build(self.output().get_path(), None)?;
         let mut builder = ArtifactValueBuilder::new(fs, ctx.digest_config());
         let mut srcs = Vec::new();
 
@@ -235,7 +236,8 @@ impl Action for SymlinkedDirAction {
                 .into_singleton()
                 .buck_error_context("Input did not dereference to exactly one artifact")?;
 
-            let src = src_artifact.resolve_path(ctx.fs())?;
+            // TODO(T219919866) Add support for experimental content-based path hashing
+            let src = src_artifact.resolve_path(ctx.fs(), None)?;
             let dest = output.join(dest);
 
             if self.copy {

app/buck2_action_impl/src/actions/impls/write.rs

@@ -191,7 +191,8 @@ impl Action for WriteAction {
                 execution_start = Some(Instant::now());
                 let content = self.get_contents(&ctx.executor_fs())?.into_bytes();
                 Ok(vec![WriteRequest {
-                    path: fs.resolve_build(self.output.get_path())?,
+                    // TODO(T219919866) Add support for experimental content-based path hashing
+                    path: fs.resolve_build(self.output.get_path(), None)?,
                     content,
                     is_executable: self.inner.is_executable,
                 }])

app/buck2_action_impl/src/actions/impls/write_json.rs

@@ -208,7 +208,8 @@ impl Action for WriteJsonAction {
                 execution_start = Some(Instant::now());
                 let content = self.get_contents(&ctx.executor_fs())?;
                 Ok(vec![WriteRequest {
-                    path: fs.resolve_build(self.output.get_path())?,
+                    // TODO(T219919866) Add support for experimental content-based path hashing
+                    path: fs.resolve_build(self.output.get_path(), None)?,
                     content,
                     is_executable: false,
                 }])

app/buck2_action_impl/src/actions/impls/write_macros.rs

@@ -176,7 +176,8 @@ impl Action for WriteMacrosToFileAction {
                 std::iter::zip(self.outputs.iter(), output_contents.into_iter())
                     .map(|(output, content)| {
                         Ok(WriteRequest {
-                            path: fs.fs().resolve_build(output.get_path())?,
+                            // TODO(T219919866) Add support for experimental content-based path hashing
+                            path: fs.fs().resolve_build(output.get_path(), None)?,
                             content: content.into_bytes(),
                             is_executable: false,
                         })