foster/denoland-deno
1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2024-12-23 15:49:44 -05:00
Code Issues Packages 1 Wiki Activity

refactor(ext/node): combine deno_node::Fs with deno_fs::FileSystem (#18991)

Browse source
This commit is contained in:
David Sherret 2023-05-05 12:44:24 -04:00 committed by GitHub
parent 5270c43e41
commit a6c47ee740
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
21 changed files with 142 additions and 187 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
Cargo.lock generated
View file

@ -1154,6 +1154,7 @@ dependencies = [
"cbc",
"data-encoding",
"deno_core",
"deno_fs",
"deno_media_type",
"deno_npm",
"deno_semver",

8
cli/build.rs
View file

@ -326,6 +326,7 @@ deno_core::extension!(
fn create_cli_snapshot(snapshot_path: PathBuf) {
// NOTE(bartlomieju): ordering is important here, keep it in sync with
// `runtime/worker.rs`, `runtime/web_worker.rs` and `runtime/build.rs`!
let fs = Arc::new(deno_fs::RealFs);
let extensions: Vec<Extension> = vec![
deno_webidl::deno_webidl::init_ops(),
deno_console::deno_console::init_ops(),
@ -360,11 +361,8 @@ fn create_cli_snapshot(snapshot_path: PathBuf) {
deno_napi::deno_napi::init_ops::<PermissionsContainer>(),
deno_http::deno_http::init_ops(),
deno_io::deno_io::init_ops(Default::default()),
deno_fs::deno_fs::init_ops::<PermissionsContainer>(
false,
Arc::new(deno_fs::RealFs),
),
deno_node::deno_node::init_ops::<PermissionsContainer>(None, None),
deno_fs::deno_fs::init_ops::<PermissionsContainer>(false, fs.clone()),
deno_node::deno_node::init_ops::<PermissionsContainer>(None, fs),
cli::init_ops_and_esm(), // NOTE: This needs to be init_ops_and_esm!
];

27
cli/factory.rs
View file

@ -43,7 +43,6 @@ use deno_core::error::AnyError;
use deno_core::parking_lot::Mutex;
use deno_runtime::deno_fs;
use deno_runtime::deno_node;
use deno_runtime::deno_node::analyze::NodeCodeTranslator;
use deno_runtime::deno_node::NodeResolver;
use deno_runtime::deno_tls::RootCertStoreProvider;
@ -133,6 +132,7 @@ struct CliFactoryServices {
http_client: Deferred<Arc<HttpClient>>,
emit_cache: Deferred<EmitCache>,
emitter: Deferred<Arc<Emitter>>,
fs: Deferred<Arc<dyn deno_fs::FileSystem>>,
graph_container: Deferred<Arc<ModuleGraphContainer>>,
lockfile: Deferred<Option<Arc<Mutex<Lockfile>>>>,
maybe_import_map: Deferred<Option<Arc<ImportMap>>>,
@ -146,7 +146,6 @@ struct CliFactoryServices {
module_graph_builder: Deferred<Arc<ModuleGraphBuilder>>,
module_load_preparer: Deferred<Arc<ModuleLoadPreparer>>,
node_code_translator: Deferred<Arc<CliNodeCodeTranslator>>,
node_fs: Deferred<Arc<dyn deno_node::NodeFs>>,
node_resolver: Deferred<Arc<NodeResolver>>,
npm_api: Deferred<Arc<CliNpmRegistryApi>>,
npm_cache: Deferred<Arc<NpmCache>>,
@ -245,6 +244,10 @@ impl CliFactory {
})
}
pub fn fs(&self) -> &Arc<dyn deno_fs::FileSystem> {
self.services.fs.get_or_init(|| Arc::new(deno_fs::RealFs))
}
pub fn maybe_lockfile(&self) -> &Option<Arc<Mutex<Lockfile>>> {
self
.services
@ -292,13 +295,6 @@ impl CliFactory {
.await
}
pub fn node_fs(&self) -> &Arc<dyn deno_node::NodeFs> {
self
.services
.node_fs
.get_or_init(|| Arc::new(deno_node::RealFs))
}
pub async fn npm_resolver(&self) -> Result<&Arc<CliNpmResolver>, AnyError> {
self
.services
@ -306,7 +302,7 @@ impl CliFactory {
.get_or_try_init_async(async {
let npm_resolution = self.npm_resolution().await?;
let npm_fs_resolver = create_npm_fs_resolver(
self.node_fs().clone(),
self.fs().clone(),
self.npm_cache()?.clone(),
self.text_only_progress_bar(),
CliNpmRegistryApi::default_url().to_owned(),
@ -437,7 +433,7 @@ impl CliFactory {
.node_resolver
.get_or_try_init_async(async {
Ok(Arc::new(NodeResolver::new(
self.node_fs().clone(),
self.fs().clone(),
self.npm_resolver().await?.clone(),
)))
})
@ -458,7 +454,7 @@ impl CliFactory {
Ok(Arc::new(NodeCodeTranslator::new(
cjs_esm_analyzer,
self.node_fs().clone(),
self.fs().clone(),
self.node_resolver().await?.clone(),
self.npm_resolver().await?.clone(),
)))
@ -554,8 +550,7 @@ impl CliFactory {
let node_code_translator = self.node_code_translator().await?.clone();
let options = self.cli_options().clone();
let main_worker_options = self.create_cli_main_worker_options()?;
let fs = Arc::new(deno_fs::RealFs);
let node_fs = self.node_fs().clone();
let fs = self.fs().clone();
let root_cert_store_provider = self.root_cert_store_provider().clone();
let node_resolver = self.node_resolver().await?.clone();
let npm_resolver = self.npm_resolver().await?.clone();
@ -582,7 +577,6 @@ impl CliFactory {
)),
root_cert_store_provider.clone(),
fs.clone(),
node_fs.clone(),
maybe_inspector_server.clone(),
main_worker_options.clone(),
)
@ -613,8 +607,7 @@ impl CliFactory {
),
)),
self.root_cert_store_provider().clone(),
Arc::new(deno_fs::RealFs),
self.node_fs().clone(),
self.fs().clone(),
self.maybe_inspector_server().clone(),
self.create_cli_main_worker_options()?,
))

6
cli/lsp/language_server.rs
View file

@ -9,7 +9,7 @@ use deno_core::serde_json;
use deno_core::serde_json::json;
use deno_core::serde_json::Value;
use deno_core::ModuleSpecifier;
use deno_runtime::deno_node;
use deno_runtime::deno_fs;
use deno_runtime::deno_node::NodeResolver;
use deno_runtime::deno_node::PackageJson;
use deno_runtime::deno_tls::rustls::RootCertStore;
@ -458,7 +458,7 @@ fn create_lsp_structs(
let resolution =
Arc::new(NpmResolution::from_serialized(api.clone(), None, None));
let fs_resolver = create_npm_fs_resolver(
Arc::new(deno_node::RealFs),
Arc::new(deno_fs::RealFs),
npm_cache.clone(),
&progress_bar,
registry_url.clone(),
@ -709,7 +709,7 @@ impl Inner {
self.npm_resolution.snapshot(),
None,
));
let node_fs = Arc::new(deno_node::RealFs);
let node_fs = Arc::new(deno_fs::RealFs);
let npm_resolver = Arc::new(CliNpmResolver::new(
npm_resolution.clone(),
create_npm_fs_resolver(

8
cli/npm/resolvers/local.rs
View file

@ -23,7 +23,7 @@ use deno_npm::resolution::NpmResolutionSnapshot;
use deno_npm::NpmPackageCacheFolderId;
use deno_npm::NpmPackageId;
use deno_runtime::deno_core::futures;
use deno_runtime::deno_node::NodeFs;
use deno_runtime::deno_fs;
use deno_runtime::deno_node::NodePermissions;
use deno_runtime::deno_node::NodeResolutionMode;
use deno_runtime::deno_node::PackageJson;
@ -44,7 +44,7 @@ use super::common::NpmPackageFsResolver;
/// and resolves packages from it.
#[derive(Debug)]
pub struct LocalNpmPackageResolver {
fs: Arc<dyn NodeFs>,
fs: Arc<dyn deno_fs::FileSystem>,
cache: Arc<NpmCache>,
progress_bar: ProgressBar,
resolution: Arc<NpmResolution>,
@ -55,7 +55,7 @@ pub struct LocalNpmPackageResolver {
impl LocalNpmPackageResolver {
pub fn new(
fs: Arc<dyn NodeFs>,
fs: Arc<dyn deno_fs::FileSystem>,
cache: Arc<NpmCache>,
progress_bar: ProgressBar,
registry_url: Url,
@ -94,7 +94,7 @@ impl LocalNpmPackageResolver {
// Canonicalize the path so it's not pointing to the symlinked directory
// in `node_modules` directory of the referrer.
Some(path) => {
Ok(deno_core::strip_unc_prefix(self.fs.canonicalize(&path)?))
Ok(deno_core::strip_unc_prefix(self.fs.realpath_sync(&path)?))
}
None => bail!("could not find npm package for '{}'", specifier),
}

4
cli/npm/resolvers/mod.rs
View file

@ -18,7 +18,7 @@ use deno_npm::resolution::NpmResolutionSnapshot;
use deno_npm::resolution::PackageReqNotFoundError;
use deno_npm::resolution::SerializedNpmResolutionSnapshot;
use deno_npm::NpmPackageId;
use deno_runtime::deno_node;
use deno_runtime::deno_fs;
use deno_runtime::deno_node::NodePermissions;
use deno_runtime::deno_node::NodeResolutionMode;
use deno_runtime::deno_node::NpmResolver;
@ -270,7 +270,7 @@ impl NpmResolver for CliNpmResolver {
}
pub fn create_npm_fs_resolver(
fs: Arc<dyn deno_node::NodeFs>,
fs: Arc<dyn deno_fs::FileSystem>,
cache: Arc<NpmCache>,
progress_bar: &ProgressBar,
registry_url: Url,

10
cli/standalone/mod.rs
View file

@ -31,7 +31,6 @@ use deno_core::ModuleType;
use deno_core::ResolutionKind;
use deno_graph::source::Resolver;
use deno_runtime::deno_fs;
use deno_runtime::deno_node;
use deno_runtime::deno_node::NodeResolver;
use deno_runtime::deno_tls::rustls::RootCertStore;
use deno_runtime::deno_tls::RootCertStoreProvider;
@ -208,11 +207,11 @@ pub async fn run(
http_client.clone(),
progress_bar.clone(),
));
let node_fs = Arc::new(deno_node::RealFs);
let fs = Arc::new(deno_fs::RealFs);
let npm_resolution =
Arc::new(NpmResolution::from_serialized(npm_api.clone(), None, None));
let npm_fs_resolver = create_npm_fs_resolver(
node_fs.clone(),
fs.clone(),
npm_cache,
&progress_bar,
npm_registry_url,
@ -225,7 +224,7 @@ pub async fn run(
None,
));
let node_resolver =
Arc::new(NodeResolver::new(node_fs.clone(), npm_resolver.clone()));
Arc::new(NodeResolver::new(fs.clone(), npm_resolver.clone()));
let module_loader_factory = StandaloneModuleLoaderFactory {
loader: EmbeddedModuleLoader {
eszip: Arc::new(eszip),
@ -254,8 +253,7 @@ pub async fn run(
BlobStore::default(),
Box::new(module_loader_factory),
root_cert_store_provider,
Arc::new(deno_fs::RealFs),
node_fs,
fs,
None,
CliMainWorkerOptions {
argv: metadata.argv,

5
cli/worker.rs
View file

@ -99,7 +99,6 @@ struct SharedWorkerState {
module_loader_factory: Box<dyn ModuleLoaderFactory>,
root_cert_store_provider: Arc<dyn RootCertStoreProvider>,
fs: Arc<dyn deno_fs::FileSystem>,
node_fs: Arc<dyn deno_node::NodeFs>,
maybe_inspector_server: Option<Arc<InspectorServer>>,
}
@ -311,7 +310,6 @@ impl CliMainWorkerFactory {
module_loader_factory: Box<dyn ModuleLoaderFactory>,
root_cert_store_provider: Arc<dyn RootCertStoreProvider>,
fs: Arc<dyn deno_fs::FileSystem>,
node_fs: Arc<dyn deno_node::NodeFs>,
maybe_inspector_server: Option<Arc<InspectorServer>>,
options: CliMainWorkerOptions,
) -> Self {
@ -329,7 +327,6 @@ impl CliMainWorkerFactory {
module_loader_factory,
root_cert_store_provider,
fs,
node_fs,
maybe_inspector_server,
}),
}
@ -450,7 +447,6 @@ impl CliMainWorkerFactory {
should_wait_for_inspector_session: shared.options.inspect_wait,
module_loader,
fs: shared.fs.clone(),
node_fs: Some(shared.node_fs.clone()),
npm_resolver: Some(shared.npm_resolver.clone()),
get_error_class_fn: Some(&errors::get_error_class_name),
cache_storage_dir,
@ -576,7 +572,6 @@ fn create_web_worker_callback(
source_map_getter: maybe_source_map_getter,
module_loader,
fs: shared.fs.clone(),
node_fs: Some(shared.node_fs.clone()),
npm_resolver: Some(shared.npm_resolver.clone()),
worker_type: args.worker_type,
maybe_inspector_server,

24
ext/fs/interface.rs
View file

@ -73,7 +73,7 @@ pub struct FsDirEntry {
}
#[async_trait::async_trait(?Send)]
pub trait FileSystem: Send + Sync {
pub trait FileSystem: std::fmt::Debug + Send + Sync {
fn cwd(&self) -> FsResult<PathBuf>;
fn tmp_dir(&self) -> FsResult<PathBuf>;
fn chdir(&self, path: &Path) -> FsResult<()>;
@ -225,4 +225,26 @@ pub trait FileSystem: Send + Sync {
let buf = file.read_all_async().await?;
Ok(buf)
}
fn is_file(&self, path: &Path) -> bool {
self.stat_sync(path).map(|m| m.is_file).unwrap_or(false)
}
fn is_dir(&self, path: &Path) -> bool {
self
.stat_sync(path)
.map(|m| m.is_directory)
.unwrap_or(false)
}
fn exists(&self, path: &Path) -> bool {
self.stat_sync(path).is_ok()
}
fn read_to_string(&self, path: &Path) -> FsResult<String> {
let buf = self.read_file_sync(path)?;
String::from_utf8(buf).map_err(|err| {
std::io::Error::new(std::io::ErrorKind::InvalidData, err).into()
})
}
}

2
ext/fs/std_fs.rs
View file

@ -22,7 +22,7 @@ use crate::OpenOptions;
#[cfg(not(unix))]
use deno_io::fs::FsError;
#[derive(Clone)]
#[derive(Debug, Clone)]
pub struct RealFs;
#[async_trait::async_trait(?Send)]

10
ext/io/fs.rs
View file

@ -21,6 +21,16 @@ pub enum FsError {
NotSupported,
}
impl FsError {
pub fn kind(&self) -> io::ErrorKind {
match self {
Self::Io(err) => err.kind(),
Self::FileBusy => io::ErrorKind::Other,
Self::NotSupported => io::ErrorKind::Other,
}
}
}
impl From<io::Error> for FsError {
fn from(err: io::Error) -> Self {
Self::Io(err)

1
ext/node/Cargo.toml
View file

@ -18,6 +18,7 @@ aes.workspace = true
cbc.workspace = true
data-encoding = "2.3.3"
deno_core.workspace = true
deno_fs.workspace = true
deno_media_type.workspace = true
deno_npm.workspace = true
deno_semver.workspace = true

6
ext/node/analyze.rs
View file

@ -13,7 +13,6 @@ use once_cell::sync::Lazy;
use deno_core::error::AnyError;
use crate::NodeFs;
use crate::NodeModuleKind;
use crate::NodePermissions;
use crate::NodeResolutionMode;
@ -67,7 +66,7 @@ pub trait CjsEsmCodeAnalyzer {
pub struct NodeCodeTranslator<TCjsEsmCodeAnalyzer: CjsEsmCodeAnalyzer> {
cjs_esm_code_analyzer: TCjsEsmCodeAnalyzer,
fs: Arc<dyn NodeFs>,
fs: Arc<dyn deno_fs::FileSystem>,
node_resolver: Arc<NodeResolver>,
npm_resolver: Arc<dyn NpmResolver>,
}
@ -77,7 +76,7 @@ impl<TCjsEsmCodeAnalyzer: CjsEsmCodeAnalyzer>
{
pub fn new(
cjs_esm_code_analyzer: TCjsEsmCodeAnalyzer,
fs: Arc<dyn NodeFs>,
fs: Arc<dyn deno_fs::FileSystem>,
node_resolver: Arc<NodeResolver>,
npm_resolver: Arc<dyn NpmResolver>,
) -> Self {
@ -161,6 +160,7 @@ impl<TCjsEsmCodeAnalyzer: CjsEsmCodeAnalyzer>
let reexport_file_text = self
.fs
.read_to_string(&resolved_reexport)
.map_err(AnyError::from)
.with_context(|| {
format!(
"Could not find '{}' ({}) referenced from {}",

76
ext/node/clippy.toml
View file

@ -1,40 +1,40 @@
disallowed-methods = [
{ path = "std::env::current_dir", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::path::Path::exists", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::path::Path::canonicalize", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::path::Path::is_dir", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::path::Path::is_file", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::path::Path::is_symlink", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::path::Path::metadata", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::path::Path::read_dir", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::path::Path::read_link", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::path::Path::symlink_metadata", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::path::Path::try_exists", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::path::PathBuf::exists", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::path::PathBuf::canonicalize", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::path::PathBuf::is_dir", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::path::PathBuf::is_file", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::path::PathBuf::is_symlink", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::path::PathBuf::metadata", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::path::PathBuf::read_dir", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::path::PathBuf::read_link", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::path::PathBuf::symlink_metadata", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::path::PathBuf::try_exists", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::fs::canonicalize", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::fs::copy", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::fs::create_dir", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::fs::create_dir_all", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::fs::hard_link", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::fs::metadata", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::fs::read", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::fs::read_dir", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::fs::read_link", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::fs::read_to_string", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::fs::remove_dir", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::fs::remove_dir_all", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::fs::remove_file", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::fs::rename", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::fs::set_permissions", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::fs::symlink_metadata", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::fs::write", reason = "File system operations should be done using NodeFs trait" },
{ path = "std::env::current_dir", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::path::Path::exists", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::path::Path::canonicalize", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::path::Path::is_dir", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::path::Path::is_file", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::path::Path::is_symlink", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::path::Path::metadata", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::path::Path::read_dir", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::path::Path::read_link", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::path::Path::symlink_metadata", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::path::Path::try_exists", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::path::PathBuf::exists", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::path::PathBuf::canonicalize", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::path::PathBuf::is_dir", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::path::PathBuf::is_file", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::path::PathBuf::is_symlink", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::path::PathBuf::metadata", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::path::PathBuf::read_dir", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::path::PathBuf::read_link", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::path::PathBuf::symlink_metadata", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::path::PathBuf::try_exists", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::fs::canonicalize", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::fs::copy", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::fs::create_dir", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::fs::create_dir_all", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::fs::hard_link", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::fs::metadata", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::fs::read", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::fs::read_dir", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::fs::read_link", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::fs::read_to_string", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::fs::remove_dir", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::fs::remove_dir_all", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::fs::remove_file", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::fs::rename", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::fs::set_permissions", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::fs::symlink_metadata", reason = "File system operations should be done using FileSystem trait" },
{ path = "std::fs::write", reason = "File system operations should be done using FileSystem trait" },
]

70
ext/node/lib.rs
View file

@ -14,7 +14,6 @@ use deno_semver::npm::NpmPackageReq;
use deno_semver::npm::NpmPackageReqReference;
use once_cell::sync::Lazy;
use std::collections::HashSet;
use std::io;
use std::path::Path;
use std::path::PathBuf;
use std::rc::Rc;
@ -51,71 +50,6 @@ impl NodePermissions for AllowAllNodePermissions {
}
}
#[derive(Default, Clone)]
pub struct NodeFsMetadata {
pub is_file: bool,
pub is_dir: bool,
}
pub trait NodeFs: std::fmt::Debug + Send + Sync {
fn current_dir(&self) -> io::Result<PathBuf>;
fn metadata(&self, path: &Path) -> io::Result<NodeFsMetadata>;
fn is_file(&self, path: &Path) -> bool;
fn is_dir(&self, path: &Path) -> bool;
fn exists(&self, path: &Path) -> bool;
fn read_to_string(&self, path: &Path) -> io::Result<String>;
fn canonicalize(&self, path: &Path) -> io::Result<PathBuf>;
}
#[derive(Debug)]
pub struct RealFs;
impl NodeFs for RealFs {
fn current_dir(&self) -> io::Result<PathBuf> {
#[allow(clippy::disallowed_methods)]
std::env::current_dir()
}
fn metadata(&self, path: &Path) -> io::Result<NodeFsMetadata> {
#[allow(clippy::disallowed_methods)]
std::fs::metadata(path).map(|metadata| {
// on most systems, calling is_file() and is_dir() is cheap
// and returns information already found in the metadata object
NodeFsMetadata {
is_file: metadata.is_file(),
is_dir: metadata.is_dir(),
}
})
}
fn exists(&self, path: &Path) -> bool {
#[allow(clippy::disallowed_methods)]
std::fs::metadata(path).is_ok()
}
fn is_file(&self, path: &Path) -> bool {
#[allow(clippy::disallowed_methods)]
std::fs::metadata(path)
.map(|m| m.is_file())
.unwrap_or(false)
}
fn is_dir(&self, path: &Path) -> bool {
#[allow(clippy::disallowed_methods)]
std::fs::metadata(path).map(|m| m.is_dir()).unwrap_or(false)
}
fn read_to_string(&self, path: &Path) -> io::Result<String> {
#[allow(clippy::disallowed_methods)]
std::fs::read_to_string(path)
}
fn canonicalize(&self, path: &Path) -> io::Result<PathBuf> {
#[allow(clippy::disallowed_methods)]
std::path::Path::canonicalize(path)
}
}
pub trait NpmResolver: std::fmt::Debug + Send + Sync {
/// Resolves an npm package folder path from an npm package referrer.
fn resolve_package_folder_from_package(
@ -516,10 +450,10 @@ deno_core::extension!(deno_node,
],
options = {
maybe_npm_resolver: Option<Arc<dyn NpmResolver>>,
fs: Option<Arc<dyn NodeFs>>,
fs: Arc<dyn deno_fs::FileSystem>,
},
state = |state, options| {
let fs = options.fs.unwrap_or_else(|| Arc::new(RealFs));
let fs = options.fs;
state.put(fs.clone());
if let Some(npm_resolver) = options.maybe_npm_resolver {
state.put(npm_resolver.clone());

22
ext/node/ops/require.rs
View file

@ -16,7 +16,6 @@ use std::rc::Rc;
use std::sync::Arc;
use crate::resolution;
use crate::NodeFs;
use crate::NodeModuleKind;
use crate::NodePermissions;
use crate::NodeResolutionMode;
@ -94,11 +93,11 @@ pub fn op_require_node_module_paths<P>(
where
P: NodePermissions + 'static,
{
let fs = state.borrow::<Arc<dyn NodeFs>>();
let fs = state.borrow::<Arc<dyn deno_fs::FileSystem>>();
// Guarantee that "from" is absolute.
let from = deno_core::resolve_path(
&from,
&(fs.current_dir()).context("Unable to get CWD")?,
&(fs.cwd().map_err(AnyError::from)).context("Unable to get CWD")?,
)
.unwrap()
.to_file_path()
@ -263,8 +262,8 @@ where
{
let path = PathBuf::from(path);
ensure_read_permission::<P>(state, &path)?;
let fs = state.borrow::<Arc<dyn NodeFs>>();
if let Ok(metadata) = fs.metadata(&path) {
let fs = state.borrow::<Arc<dyn deno_fs::FileSystem>>();
if let Ok(metadata) = fs.stat_sync(&path) {
if metadata.is_file {
return Ok(0);
} else {
@ -285,8 +284,9 @@ where
{
let path = PathBuf::from(request);
ensure_read_permission::<P>(state, &path)?;
let fs = state.borrow::<Arc<dyn NodeFs>>();
let canonicalized_path = deno_core::strip_unc_prefix(fs.canonicalize(&path)?);
let fs = state.borrow::<Arc<dyn deno_fs::FileSystem>>();
let canonicalized_path =
deno_core::strip_unc_prefix(fs.realpath_sync(&path)?);
Ok(canonicalized_path.to_string_lossy().to_string())
}
@ -346,8 +346,8 @@ where
if let Some(parent_id) = maybe_parent_id {
if parent_id == "<repl>" || parent_id == "internal/preload" {
let fs = state.borrow::<Arc<dyn NodeFs>>();
if let Ok(cwd) = fs.current_dir() {
let fs = state.borrow::<Arc<dyn deno_fs::FileSystem>>();
if let Ok(cwd) = fs.cwd() {
ensure_read_permission::<P>(state, &cwd)?;
return Ok(Some(cwd.to_string_lossy().to_string()));
}
@ -429,7 +429,7 @@ where
{
let file_path = PathBuf::from(file_path);
ensure_read_permission::<P>(state, &file_path)?;
let fs = state.borrow::<Arc<dyn NodeFs>>();
let fs = state.borrow::<Arc<dyn deno_fs::FileSystem>>();
Ok(fs.read_to_string(&file_path)?)
}
@ -457,7 +457,7 @@ fn op_require_resolve_exports<P>(
where
P: NodePermissions + 'static,
{
let fs = state.borrow::<Arc<dyn NodeFs>>();
let fs = state.borrow::<Arc<dyn deno_fs::FileSystem>>();
let npm_resolver = state.borrow::<Arc<dyn NpmResolver>>();
let node_resolver = state.borrow::<Rc<NodeResolver>>();
let permissions = state.borrow::<P>();

7
ext/node/package_json.rs
View file

@ -1,6 +1,5 @@
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
use crate::NodeFs;
use crate::NodeModuleKind;
use crate::NodePermissions;
@ -63,7 +62,7 @@ impl PackageJson {
}
pub fn load(
fs: &dyn NodeFs,
fs: &dyn deno_fs::FileSystem,
resolver: &dyn NpmResolver,
permissions: &dyn NodePermissions,
path: PathBuf,
@ -73,7 +72,7 @@ impl PackageJson {
}
pub fn load_skip_read_permission(
fs: &dyn NodeFs,
fs: &dyn deno_fs::FileSystem,
path: PathBuf,
) -> Result<PackageJson, AnyError> {
assert!(path.is_absolute());
@ -90,7 +89,7 @@ impl PackageJson {
Err(err) => bail!(
"Error loading package.json at {}. {:#}",
path.display(),
err
AnyError::from(err),
),
};

17
ext/node/resolution.rs
View file

@ -19,7 +19,6 @@ use deno_semver::npm::NpmPackageReqReference;
use crate::errors;
use crate::AllowAllNodePermissions;
use crate::NodeFs;
use crate::NodePermissions;
use crate::NpmResolver;
use crate::PackageJson;
@ -107,12 +106,15 @@ impl NodeResolution {
#[derive(Debug)]
pub struct NodeResolver {
fs: Arc<dyn NodeFs>,
fs: Arc<dyn deno_fs::FileSystem>,
npm_resolver: Arc<dyn NpmResolver>,
}
impl NodeResolver {
pub fn new(fs: Arc<dyn NodeFs>, npm_resolver: Arc<dyn NpmResolver>) -> Self {
pub fn new(
fs: Arc<dyn deno_fs::FileSystem>,
npm_resolver: Arc<dyn NpmResolver>,
) -> Self {
Self { fs, npm_resolver }
}
@ -280,8 +282,9 @@ impl NodeResolver {
p_str.to_string()
};
let (is_dir, is_file) = if let Ok(stats) = self.fs.metadata(Path::new(&p)) {
(stats.is_dir, stats.is_file)
let (is_dir, is_file) = if let Ok(stats) = self.fs.stat_sync(Path::new(&p))
{
(stats.is_directory, stats.is_file)
} else {
(false, false)
};
@ -491,7 +494,7 @@ impl NodeResolver {
referrer_kind: NodeModuleKind,
) -> Option<PathBuf> {
fn probe_extensions(
fs: &dyn NodeFs,
fs: &dyn deno_fs::FileSystem,
path: &Path,
referrer_kind: NodeModuleKind,
) -> Option<PathBuf> {
@ -1079,7 +1082,7 @@ impl NodeResolver {
) -> Result<PathBuf, AnyError> {
let file_path = url.to_file_path().unwrap();
let current_dir = deno_core::strip_unc_prefix(
self.fs.canonicalize(file_path.parent().unwrap())?,
self.fs.realpath_sync(file_path.parent().unwrap())?,
);
let mut current_dir = current_dir.as_path();
let package_json_path = current_dir.join("package.json");

8
runtime/build.rs
View file

@ -273,6 +273,7 @@ mod startup_snapshot {
pub fn create_runtime_snapshot(snapshot_path: PathBuf) {
// NOTE(bartlomieju): ordering is important here, keep it in sync with
// `runtime/worker.rs`, `runtime/web_worker.rs` and `cli/build.rs`!
let fs = std::sync::Arc::new(deno_fs::RealFs);
let extensions: Vec<Extension> = vec![
deno_webidl::deno_webidl::init_ops_and_esm(),
deno_console::deno_console::init_ops_and_esm(),
@ -309,14 +310,11 @@ mod startup_snapshot {
deno_napi::deno_napi::init_ops_and_esm::<Permissions>(),
deno_http::deno_http::init_ops_and_esm(),
deno_io::deno_io::init_ops_and_esm(Default::default()),
deno_fs::deno_fs::init_ops_and_esm::<Permissions>(
false,
std::sync::Arc::new(deno_fs::RealFs),
),
deno_fs::deno_fs::init_ops_and_esm::<Permissions>(false, fs.clone()),
runtime::init_ops_and_esm(),
// FIXME(bartlomieju): these extensions are specified last, because they
// depend on `runtime`, even though it should be other way around
deno_node::deno_node::init_ops_and_esm::<Permissions>(None, None),
deno_node::deno_node::init_ops_and_esm::<Permissions>(None, fs),
#[cfg(not(feature = "snapshot_from_snapshot"))]
runtime_main::init_ops_and_esm(),
];

8
runtime/web_worker.rs
View file

@ -333,7 +333,6 @@ pub struct WebWorkerOptions {
pub seed: Option<u64>,
pub fs: Arc<dyn FileSystem>,
pub module_loader: Rc<dyn ModuleLoader>,
pub node_fs: Option<Arc<dyn deno_node::NodeFs>>,
pub npm_resolver: Option<Arc<dyn deno_node::NpmResolver>>,
pub create_web_worker_cb: Arc<ops::worker_host::CreateWebWorkerCb>,
pub preload_module_cb: Arc<ops::worker_host::WorkerEventCb>,
@ -442,10 +441,13 @@ impl WebWorker {
deno_napi::deno_napi::init_ops::<PermissionsContainer>(),
deno_http::deno_http::init_ops(),
deno_io::deno_io::init_ops(Some(options.stdio)),
deno_fs::deno_fs::init_ops::<PermissionsContainer>(unstable, options.fs),
deno_fs::deno_fs::init_ops::<PermissionsContainer>(
unstable,
options.fs.clone(),
),
deno_node::deno_node::init_ops::<PermissionsContainer>(
options.npm_resolver,
options.node_fs,
options.fs,
),
// Runtime ops that are always initialized for WebWorkers
ops::web_worker::deno_web_worker::init_ops(),

9
runtime/worker.rs
View file

@ -94,7 +94,6 @@ pub struct WorkerOptions {
/// If not provided runtime will error if code being
/// executed tries to load modules.
pub module_loader: Rc<dyn ModuleLoader>,
pub node_fs: Option<Arc<dyn deno_node::NodeFs>>,
pub npm_resolver: Option<Arc<dyn deno_node::NpmResolver>>,
// Callbacks invoked when creating new instance of WebWorker
pub create_web_worker_cb: Arc<ops::worker_host::CreateWebWorkerCb>,
@ -166,7 +165,6 @@ impl Default for WorkerOptions {
broadcast_channel: Default::default(),
source_map_getter: Default::default(),
root_cert_store_provider: Default::default(),
node_fs: Default::default(),
npm_resolver: Default::default(),
blob_store: Default::default(),
extensions: Default::default(),
@ -268,10 +266,13 @@ impl MainWorker {
deno_napi::deno_napi::init_ops::<PermissionsContainer>(),
deno_http::deno_http::init_ops(),
deno_io::deno_io::init_ops(Some(options.stdio)),
deno_fs::deno_fs::init_ops::<PermissionsContainer>(unstable, options.fs),
deno_fs::deno_fs::init_ops::<PermissionsContainer>(
unstable,
options.fs.clone(),
),
deno_node::deno_node::init_ops::<PermissionsContainer>(
options.npm_resolver,
options.node_fs,
options.fs,
),
// Ops from this crate
ops::runtime::deno_runtime::init_ops(main_module.clone()),