maybe fix ci

denoland · dsherret · Nov 18, 2024 · Oct 22, 2024 · Oct 23, 2024 · Oct 23, 2024
commit fd1333974be458c1c217261b4cc9924786a89c5b
diff --git a/cli/standalone/binary.rs b/cli/standalone/binary.rs
@@ -628,13 +628,17 @@ impl<'a> DenoCompileBinaryWriter<'a> {
       };
       if module.specifier().scheme() == "file" {
         let file_path = deno_path_util::url_to_file_path(module.specifier())?;
-        vfs.add_file_with_data(
-          &file_path,
-          match maybe_source {
-            Some(source) => source,
-            None => RealFs.read_file_sync(&file_path, None)?,
-          },
-        )?;
+        vfs
+          .add_file_with_data(
+            &file_path,
+            match maybe_source {
+              Some(source) => source,
+              None => RealFs.read_file_sync(&file_path, None)?,
+            },
+          )
+          .with_context(|| {
+            format!("Failed adding '{}'", file_path.display())
+          })?;
       } else if let Some(source) = maybe_source {
         remote_modules_store.add(module.specifier(), media_type, source);
       }

diff --git a/cli/standalone/mod.rs b/cli/standalone/mod.rs
@@ -55,6 +55,7 @@ use crate::args::CacheSetting;
 use crate::args::NpmInstallDepsProvider;
 use crate::args::StorageKeyResolver;
 use crate::cache::Caches;
+use crate::cache::DenoCacheEnvFsAdapter;
 use crate::cache::DenoDirProvider;
 use crate::cache::NodeAnalysisCache;
 use crate::cache::RealDenoCacheEnv;
@@ -407,92 +408,80 @@ pub async fn run(data: StandaloneData) -> Result<i32, AnyError> {
   let root_dir_url =
     Arc::new(ModuleSpecifier::from_directory_path(&root_path).unwrap());
   let main_module = root_dir_url.join(&metadata.entrypoint_key).unwrap();
-  let root_node_modules_path = root_path.join(".deno_compile_node_modules");
-  let npm_cache_dir = NpmCacheDir::new(
-    &RealDenoCacheEnv,
-    root_node_modules_path.clone(),
-    vec![npm_registry_url.clone()],
-  );
-  let npm_global_cache_dir = npm_cache_dir.get_cache_location();
+  let npm_global_cache_dir = root_path.join(".deno_compile_node_modules");
   let cache_setting = CacheSetting::Only;
-  let (fs, npm_resolver) = match metadata.node_modules {
+  let npm_resolver = match metadata.node_modules {
     Some(binary::NodeModules::Managed { node_modules_dir }) => {
       let snapshot = npm_snapshot.unwrap();
       let maybe_node_modules_path = node_modules_dir
         .map(|node_modules_dir| root_path.join(node_modules_dir));
-      let npm_resolver =
-        create_cli_npm_resolver(CliNpmResolverCreateOptions::Managed(
-          CliNpmResolverManagedCreateOptions {
-            snapshot: CliNpmResolverManagedSnapshotOption::Specified(Some(
-              snapshot,
-            )),
-            maybe_lockfile: None,
-            fs: fs.clone(),
-            http_client_provider: http_client_provider.clone(),
-            npm_global_cache_dir,
-            cache_setting,
-            text_only_progress_bar: progress_bar,
-            maybe_node_modules_path,
-            npm_system_info: Default::default(),
-            npm_install_deps_provider: Arc::new(
-              // this is only used for installing packages, which isn't necessary with deno compile
-              NpmInstallDepsProvider::empty(),
-            ),
-            // create an npmrc that uses the fake npm_registry_url to resolve packages
-            npmrc: Arc::new(ResolvedNpmRc {
-              default_config: deno_npm::npm_rc::RegistryConfigWithUrl {
-                registry_url: npm_registry_url.clone(),
-                config: Default::default(),
-              },
-              scopes: Default::default(),
-              registry_configs: Default::default(),
-            }),
-            lifecycle_scripts: Default::default(),
-          },
-        ))
-        .await?;
-      (fs, npm_resolver)
+      create_cli_npm_resolver(CliNpmResolverCreateOptions::Managed(
+        CliNpmResolverManagedCreateOptions {
+          snapshot: CliNpmResolverManagedSnapshotOption::Specified(Some(
+            snapshot,
+          )),
+          maybe_lockfile: None,
+          fs: fs.clone(),
+          http_client_provider: http_client_provider.clone(),
+          npm_global_cache_dir,
+          cache_setting,
+          text_only_progress_bar: progress_bar,
+          maybe_node_modules_path,
+          npm_system_info: Default::default(),
+          npm_install_deps_provider: Arc::new(
+            // this is only used for installing packages, which isn't necessary with deno compile
+            NpmInstallDepsProvider::empty(),
+          ),
+          // create an npmrc that uses the fake npm_registry_url to resolve packages
+          npmrc: Arc::new(ResolvedNpmRc {
+            default_config: deno_npm::npm_rc::RegistryConfigWithUrl {
+              registry_url: npm_registry_url.clone(),
+              config: Default::default(),
+            },
+            scopes: Default::default(),
+            registry_configs: Default::default(),
+          }),
+          lifecycle_scripts: Default::default(),
+        },
+      ))
+      .await?
     }
     Some(binary::NodeModules::Byonm {
       root_node_modules_dir,
     }) => {
       let root_node_modules_dir =
         root_node_modules_dir.map(|p| vfs.root().join(p));
-      let npm_resolver = create_cli_npm_resolver(
-        CliNpmResolverCreateOptions::Byonm(CliByonmNpmResolverCreateOptions {
+      create_cli_npm_resolver(CliNpmResolverCreateOptions::Byonm(
+        CliByonmNpmResolverCreateOptions {
           fs: CliDenoResolverFs(fs.clone()),
           root_node_modules_dir,
-        }),
-      )
-      .await?;
-      (fs, npm_resolver)
+        },
+      ))
+      .await?
     }
     None => {
-      let fs = Arc::new(deno_fs::RealFs) as Arc<dyn deno_fs::FileSystem>;
-      let npm_resolver =
-        create_cli_npm_resolver(CliNpmResolverCreateOptions::Managed(
-          CliNpmResolverManagedCreateOptions {
-            snapshot: CliNpmResolverManagedSnapshotOption::Specified(None),
-            maybe_lockfile: None,
-            fs: fs.clone(),
-            http_client_provider: http_client_provider.clone(),
-            npm_global_cache_dir,
-            cache_setting,
-            text_only_progress_bar: progress_bar,
-            maybe_node_modules_path: None,
-            npm_system_info: Default::default(),
-            npm_install_deps_provider: Arc::new(
-              // this is only used for installing packages, which isn't necessary with deno compile
-              NpmInstallDepsProvider::empty(),
-            ),
-            // Packages from different registries are already inlined in the ESZip,
-            // so no need to create actual `.npmrc` configuration.
-            npmrc: create_default_npmrc(),
-            lifecycle_scripts: Default::default(),
-          },
-        ))
-        .await?;
-      (fs, npm_resolver)
+      create_cli_npm_resolver(CliNpmResolverCreateOptions::Managed(
+        CliNpmResolverManagedCreateOptions {
+          snapshot: CliNpmResolverManagedSnapshotOption::Specified(None),
+          maybe_lockfile: None,
+          fs: fs.clone(),
+          http_client_provider: http_client_provider.clone(),
+          npm_global_cache_dir,
+          cache_setting,
+          text_only_progress_bar: progress_bar,
+          maybe_node_modules_path: None,
+          npm_system_info: Default::default(),
+          npm_install_deps_provider: Arc::new(
+            // this is only used for installing packages, which isn't necessary with deno compile
+            NpmInstallDepsProvider::empty(),
+          ),
+          // Packages from different registries are already inlined in the ESZip,
+          // so no need to create actual `.npmrc` configuration.
+          npmrc: create_default_npmrc(),
+          lifecycle_scripts: Default::default(),
+        },
+      ))
+      .await?
     }
   };
 

diff --git a/cli/standalone/virtual_fs.rs b/cli/standalone/virtual_fs.rs
@@ -72,7 +72,8 @@ impl VfsBuilder {
     &mut self,
     root_path: PathBuf,
   ) -> Result<(), AnyError> {
-    self.root_path = canonicalize_path(&root_path)?;
+    let root_path = canonicalize_path(&root_path)?;
+    self.root_path = root_path;
     self.root_dir = VirtualDirectory {
       name: self
         .root_path
@@ -139,7 +140,7 @@ impl VfsBuilder {
                 // inline the symlink and make the target file
                 let file_bytes = std::fs::read(&target)
                   .with_context(|| format!("Reading {}", path.display()))?;
-                self.add_file_with_data(&path, file_bytes)?;
+                self.add_file_with_data_inner(&path, file_bytes)?;
               } else {
                 log::warn!(
                   "{} Symlink target is outside '{}'. Excluding symlink at '{}' with target '{}'.",
@@ -211,19 +212,31 @@ impl VfsBuilder {
     self.add_file_at_path_not_symlink(&target_path)
   }
 
-  pub fn add_file_at_path_not_symlink(
+  fn add_file_at_path_not_symlink(
     &mut self,
     path: &Path,
   ) -> Result<(), AnyError> {
     let file_bytes = std::fs::read(path)
       .with_context(|| format!("Reading {}", path.display()))?;
-    self.add_file_with_data(path, file_bytes)
+    self.add_file_with_data_inner(path, file_bytes)
   }
 
   pub fn add_file_with_data(
     &mut self,
     path: &Path,
     data: Vec<u8>,
+  ) -> Result<(), AnyError> {
+    let target_path = canonicalize_path(path)?;
+    if target_path != path {
+      self.add_symlink(path, &target_path)?;
+    }
+    self.add_file_with_data_inner(&target_path, data)
+  }
+
+  fn add_file_with_data_inner(
+    &mut self,
+    path: &Path,
+    data: Vec<u8>,
   ) -> Result<(), AnyError> {
     log::debug!("Adding file '{}'", path.display());
     let checksum = util::checksum::gen(&[&data]);
@@ -273,8 +286,15 @@ impl VfsBuilder {
       path.display(),
       target.display()
     );
-    let dest = self.path_relative_root(target)?;
-    if dest == self.path_relative_root(path)? {
+    let relative_target = self.path_relative_root(target)?;
+    let relative_path = match self.path_relative_root(path) {
+      Ok(path) => path,
+      Err(StripRootError { .. }) => {
+        // ignore if the original path is outside the root directory
+        return Ok(());
+      }
+    };
+    if relative_target == relative_path {
       // it's the same, ignore
       return Ok(());
     }
@@ -287,7 +307,7 @@ impl VfsBuilder {
           insert_index,
           VfsEntry::Symlink(VirtualSymlink {
             name: name.to_string(),
-            dest_parts: dest
+            dest_parts: relative_target
               .components()
               .map(|c| c.as_os_str().to_string_lossy().to_string())
               .collect::<Vec<_>>(),
@@ -939,20 +959,23 @@ mod test {
     let src_path = src_path.to_path_buf();
     let mut builder = VfsBuilder::new(src_path.clone()).unwrap();
     builder
-      .add_file_with_data(&src_path.join("a.txt"), "data".into())
+      .add_file_with_data_inner(&src_path.join("a.txt"), "data".into())
       .unwrap();
     builder
-      .add_file_with_data(&src_path.join("b.txt"), "data".into())
+      .add_file_with_data_inner(&src_path.join("b.txt"), "data".into())
       .unwrap();
     assert_eq!(builder.files.len(), 1); // because duplicate data
     builder
-      .add_file_with_data(&src_path.join("c.txt"), "c".into())
+      .add_file_with_data_inner(&src_path.join("c.txt"), "c".into())
       .unwrap();
     builder
-      .add_file_with_data(&src_path.join("sub_dir").join("d.txt"), "d".into())
+      .add_file_with_data_inner(
+        &src_path.join("sub_dir").join("d.txt"),
+        "d".into(),
+      )
       .unwrap();
     builder
-      .add_file_with_data(&src_path.join("e.txt"), "e".into())
+      .add_file_with_data_inner(&src_path.join("e.txt"), "e".into())
       .unwrap();
     builder
       .add_symlink(
@@ -1120,7 +1143,7 @@ mod test {
     let temp_path = temp_dir.path().canonicalize();
     let mut builder = VfsBuilder::new(temp_path.to_path_buf()).unwrap();
     builder
-      .add_file_with_data(
+      .add_file_with_data_inner(
         temp_path.join("a.txt").as_path(),
         "0123456789".to_string().into_bytes(),
       )

diff --git a/cli/tools/compile.rs b/cli/tools/compile.rs
@@ -134,7 +134,10 @@ pub async fn compile(
     )
     .await
     .with_context(|| {
-      format!("Writing temporary file '{}'", temp_path.display())
+      format!(
+        "Writing deno compile executable to temporary file '{}'",
+        temp_path.display()
+      )
     });
 
   // set it as executable